python（三）数据类型： int bool str list tuple dict

一  、int

 bit_length()        计算十进制转化成二进制的有效位数

v = 11 
data = v.bit_length()
print(data)

二 、 bool

布尔值就两种：True，False。就是反应条件的正确与否。

真   1   True。

假   0   False。 

s1 = '王大锤'
s2 = ' '  #  字符串中有空格
s3 = ''
print(bool(s1))  #  结果为True
print(bool(s2))  #  结果为True
print(bool(s3))  #  结果为false

bool转换成字符串： bool ---> str

print(str(True), type(str(True))) 
# 执行结果为 True <class 'str'> # 虽然结果还是true， 但是这时已转换成字符串格式 

三 、 str

1. 字符串的索引与切片

　　索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推

a = 'ABCDEFGHIJK'
print(a[0])  # 结果为 A，因为从0开始，所以0为第一个
print(a[3])  # 结果为 D，因为从0开始，所以3为第4个
print(a[5])  # 结果为 F，因为从0开始，所以5为第6个
print(a[7])  # 结果为 H，因为从0开始，所以7为第8个

2. 切片

　　就是通过索引（索引：结尾索引+1  ：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）

a = 'ABCDEFGHIJK'
print(a[0:3])  # 结果为ABC
print(a[2:5])  # 结果为CDE
print(a[0:])  # 0：表示默认到最后，可以取到k元素 结果为ABCDEFGHIJK
print(a[0:-1])  # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素，结果为ABCDEFGHIJ
print(a[0:5:2])  # 加步长，从0-5元素，步长为2，结果为:ACE
print(a[5:0:-2])  # 反向加步长，从左第5个元素起至末尾，步长为2，结果为:FDB
print(a[-1:-3:-1])  # -:-3表示输出倒数两个元素，最后的-1表示从字符串的右侧切

3. 常用方法： 对字符串操作形成的都是新的字符串

# captalize, swapcase, title
name = 'daChui'
print(name.capitalize()) # 首字母大写,其他小写，已大写的也小写
print(name.swapcase()) # 大小写翻转
msg='hello word, zhenhao!'
print(msg.title()) # 每个单词的首字母大写

# center  内同居中，设置总长度，空白处填充
a1 = 'dachui'
a2 = a1.center(10, "*")  # 设置总长度为10，不足的空白处用*填充
print(a2)  # 结果为**dachui**

# title()  非字母隔开的'单词'首字母大写
ss = 'hello me2dachui*word'
s4 = ss.title()
print(s4)  # 结果为 Hello Me2Dachui*Word ， 以非字母*隔开的单词也要首字母大写

# upper() 全大写   lower() 全小写
s = 'daChui'
s5 = s.upper()
print(s5)  # 结果为DACHUI
s6 = s.lower()
print(s6)  # 结果为dachui


# count 数字符串中的元素出现的个数。
ret3 = a1.count("a",0,4) # 可切片
print(ret3)

a2 = "hqw	"
# 	前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
ret4 = a2.expandtabs()
print(ret4)


# startswith 判断是否以...开头
# endswith 判断是否以...结尾
a4 = "dkfjdkfasf54"
ret4 = a4.endswith('jdk', 3, 6)  # 顾头不顾腚，到第几个字符，就用索引号-1
print(ret4)  # 返回的是布尔值true
ret5 = a4.startswith('jdk', 3)  # 以...开始的，可以省略末尾索引
print(ret5)  # 返回的是布尔值 true
ret6 = a4.endswith('f54', 9)  # 以...结束的，可以省略末尾索引
print(ret6)  # 返回的是布尔值true
ret7 = a4.startswith("kfj", 1, 4)
print(ret7)  # 返回的是布尔值true


# find  通过元素找索引，找不到返回-1  ***
# index 通过元素找索引，找不到报错  ***
s = 'oldboy'
print(s.find('d'))  # 结果为 2
print(s.find('o'))  # 结果为 0
print(s.find('A'))  # 结果为 -1，因为没找到
print(s.index('d'))  # 结果为 2
print(s.index('A'))  # 结果报错
print(s.find("db", 1, 4))  # 结果为2,只返回d的索引


# split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。可将str 转换为 list
ret9 = 'title, Tilte, atre,'.split('t')
print(ret9)  # 结果为: ['', 'i', 'le, Til', 'e, a', 're,']
ret91 = 'title, Tilte, atre,'.rsplit('t', 1)
print(ret91)  # 结果为: ['title, Tilte, a', 're,'] ，参数为1， 只分割右边第一个
s = '我 是 谁'
print(s.split())  # 默认按照空格分割,结果为: ['我', '是', '谁']


# format的三种玩法 格式化输出
res = '{} {} {}'.format('egon', 18, 'male')
print(res)  # 结果为： egon 18 male
res1 = '{1} {0} {1}'.format('egon', 18, 'male')
print(res1)  # 结果为： 18 egon 18
res2 = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res2)  # 结果为： egon 18 male

# strip 默认去除str前后两端换行符，制表符  空格  ***  中文
name = '*egon**'
print(name.strip('*'))  # 去除所有的*
print(name.lstrip('*'))  # 只去除左边的*
print(name.rstrip('*'))  # 只去除右边的*

# replace  把字符串中的 旧字符串 替换成 新字符串
ame = '我 是 大鱼 我 是 大鱼'
print(name.replace('大鱼', '小美'))  # 结果为: 我 是 小美 我 是 小美
print(name.replace('大鱼', '小美', 1))  # 结果为： 我 是 小美 我 是 大鱼，加了参数1后，只替换了第一个元素


# join   将原有的 列表 或 字符串 中的 元素 以指定的 字符 连接生成一个新的 字符串，用途将 list 转换为 str
s = '-*—'
s1 = 'bcd'
s2 = ['b', 'c', 'd']
print('_'.join(s1))  # 结果为 b_c_d
print(s.join(s1))  # 结果为 b-*—c-*—d
print(s.join(s2))  # 结果为 b-*—c-*—d ,列表（list）也可以用此方法
print(s1.join(s))  # 结果为-bcd*bcd—,因为s中的元素被s1连接的时候，
print('x'.join(s1))  # 结果为 bxcxd
l1 = ['wo', 'shi', 'shui'] # 转换为字符换 'wo shi shui'
print(' '.join(l1))  # 结果为: wo shi shui


# is系列
name='dachui456'
print(name.isalnum())  # 判断字符串是否由字母或数字组成
print(name.isalpha())  # 判断字符串是否只由字母组成
print(name.isdigit())  # 判断字符串是否只由数字组成  str ---> int 可以作为一个判断条件
print(name.isspace())  # 判断字符串是否只有空格组成


# is: 比较内存地址
s1 = 1000
s2 = 1000
print(s1 is s2)  # 返回true， 证明这两个内存地址一样


# 公共方法 len count
# len 测量个数，返回对象（字符、列表、元组等）长度或项目个数
s = 'qwer123 qwq'
ss = ''
print(len(s))  # 结果为11，空格也会统计
print(len(ss))  # 结果为0，统计不到不会报错，会返回0
# count 某个元素出现的次数,可选参数为在字符串搜索的开始与结束位置
print(s.count('q'))  # 结果为3
print(s.count('4'))  # 结果为0，统计不到不会报错，会返回0

四、 tuple

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

 tu = (1, True, [12, 3], 'afdlsfa')
可以索引，可以切片（步长）。
不能增删改（儿子不能，孙子有可能），只能查询。
index  count  for 循环。

五、list

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

1. 索引切片。(与字符串一样)

# 1,索引切片。(与字符串一样)
l1 = ['孙悟空', '猪八戒', '唐僧', 100, 'lily']
print(l1[0], type(l1[0]))
print(l1[-2], type(l1[-2]))
print(l1[:2])

2. 增删改查，以及其他操作。

l1 = ['alex', 'wusir', 'wusir', 'wusir','太白', 100, '女神']

#1、 增

# append追加
l1.append('文刚')
print(l1.append('文刚'))
print(l1)

# insert 插入
l1.insert(1,'oldboy')
print(l1)

# extend() 迭代的追加
l1.extend('abc')
l1.extend(['abc', 'erf'])
print(l1)



# 2、删

# pop 按照索引删除,有返回值

ret = l1.pop(1)
print(ret)
print(l1)

# remove 移除列表中某个值的第一个匹配项，无返回值
l1.remove('alex')
print(l1)

# clear 清空列表,无返回值
l1.clear()
print(l1)

# del 按照索引,不返回删除值
del l1[1]
print(l1)
# 按照切片（步长）
del l1[:2]
print(l1)
del l1[::2]
print(l1)


# 3、改

# 按照索引
l1[1] = 'SB'
print(l1)
# 按照切片（步长）
l1[:2] = 'fsdjksdhfjsdf'
l1[::2] = 'abc' # 加上步长一定要一一对应。
l1[::2] = ['alex', [12,3], 'c'] # 加上步长一定要一一对应。
print(l1)

# 4 、查
# 索引，切片，切片（步长）
for i in l1:
    print(i)


# 5、其他方法：
print(l1.index('太白')) 通过元素查索引
len()
print(len(l1))

# count 计算个数
print(l1.count('wusir'))

#  排序 翻转
l2 = [2, 3, 5, 1, 9, 8, 7, 6]
l2.sort()  # 从小到大排序
l2.sort(reverse=True)  # 从大到小排序
l2.reverse()  # 翻转

# 大小写
l1 = ['alex', 'wusir', [1,'taibai'],'LiLy']
l1[1] = l1[1].upper() # 'wusir'全部大写
print(l1)

l1[3] = l1[3].lower() # 'LiLy' # 全部小写
print(l1)

l1[-1][-1] = l1[-1][-1].capitalize() # 'taibai' # 首字母大写
print(l1)
print(l1[-1][-1])

3. 列表的嵌套。

l1 = ['alex', 'wusir', 'wusir', 100, '女神']
for i in range(len(l1)):
    print(i)  # 利用for range 打印出列表的索引。

六、 dict

　　键值对   Key:value 字典的key唯一重复，可以存储大量的关系型数据。
　　字典3.5版本包括3.5之前是无序的。3.6之后有序。

　　   

　　字典的key：str,int,（bool值，tuple不常用） 不可变的数据类型(可哈希的)
　　字典的value：任意数据类型。

dic = {'name_list':['张三', '李四'],
       'alex': {'sex':'男','爱好': '非男'},
       }

print(dic)

1. 增删改查  以及其他操作

dic = {'name': 'TaiBai', 'age': 25, 'sex': '男',}
# 1、增
# 按照键值对  有则改之，无则添加
dic['job'] = 'Teacher'
dic['name'] = 'alex'


# setdefault
dic.setdefault('job')  # 无则添加，有则不变。返回值是这个键值对的值
dic.setdefault('job', 'Teacher')
dic.setdefault('name', 'alex')
print(dic)


# 2、删
ret = dic.pop('name')
print(ret) # 返回值是删除的值
print(dic)


# 3、清空
dic.clear()
print(dic)

del
del dic['name']
print(dic)


# 4、改
dic['name'] = 'alex'
print(dic)

dic = {"name":"jin", "age":18,"sex":"male"}
dic2 = {"name":"alex", "weight":75}
dic2.update(dic)  # 将dic 的所有键值对覆盖并添加到dic2中。dic不变。
print(dic)
print(dic2)

# 5、查
print(dic['name'])
print(dic['name1'])

# 查--get 返回指定键的值，如果值不在字典中返回默认值
print(dic.get('name'))
print(dic.get('name1'))
print(dic.get('name1', '没有此键'))

# 类似于列表的容器
print(dic.keys())
for i in dic.keys():
    print(i)
print(list(dic.keys()))
print(dic.values())
print(list(dic.items()))

a, b, c = 1, 2, 3
print(a, b, c)
a, b, c = [1, 2, 3]
print(a, b, c)

a = 10
b = 100
a, b = b, a
print(a, b)

for k,v in dic.items():
    print(k, v)

# 嵌套
dic = {'name': 'alex',
       'name_list': ['wusir', 'taibai'],
       1: {'name': '日天'}}

# 改变指定值
# 将wusir全部变成大写
print(dic['name_list'][0])
dic['name_list'][0] = dic['name_list'][0].upper()
print(dic)
# 将日天 改成 泰迪。
dic[1]['name'] = '泰迪'
print(dic)

七  、基础数据类型补充

# tuple 元祖中如果只有一个元素且没有逗号，则他不是元组而是该元素对应的类型。
tu1 = (1)
print(tu1, type(tu1))
tu2 = ('alex')
print(tu2, type(tu2))
tu3 = ([1, 2, 3])
print(tu3, type(tu3))

tu1 = (1,)  # 如果只有一个元素，则需加逗号才能成为一个元组
print(tu1, type(tu1))


dict
dic = dict.fromkeys('abc', 'alex')
print(dic)


# == 比较的是两边的数值是否相同
# is 比较的是内存地址是否相同
# id 查询的是内存地址


# 在 正向 循环一个list中，如果改变的列表的大小，那么结果可以和你预想的不一样。
l1 = [11, 22, 33, 44, 55, 66]
# 将索引为奇数位置的元素删除。
del l1[1::2]
print(l1)

# for循环。
for ind in range(len(l1)):
    print(ind, l1)
    if ind % 2 == 1:
        del l1[ind]
    print(ind, l1)
print(l1)

# 倒叙删除
for ind in range(len(l1)-1, -1, -1):
    if ind % 2 == 1:
        del l1[ind]
print(l1)


dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'name': 'alex'}
# 将字典中的key键含有'k'元素的所有键值对删除。
# 在循环一个字典时，不能改变该字典的大小。
for key in dic:
    if 'k' in key:
        del dic[key]
l1 = []
for key in dic:
    if 'k' in key:
        l1.append(key)
print(l1)
for key in l1:
    del dic[key]
print(dic)

课后练习

'''
1、有变量name = "aleX leNb" 完成如下操作：
1)  移除 name 变量对应的值两边的空格,并输出处理结果
'''
name = "   aleX leNb   "
print(name.strip())
'''
 2)  移除name变量左边的"al"并输出处理结果
'''
# 第一种方法
name = "aleX leNb"
name = list(name)  # 先将字符串转换为列表形式
del name[:2]  # 通过操作列表，删除前两个元素
print(''.join(name))  # 最后，将元素重新连接，组成新的字符串

# 第二种方法
name = "aleX leNb"
print(name.lstrip('al'))  # 直接用lstrip命令

'''
3)  移除name变量右面的"Nb",并输出处理结果
'''
# 第一种方法
name = "aleX leNb"
name = list(name)  # 先将字符串转换为列表形式
del name[-1:-3:-1]  # 通过操作列表，删除最后两个元素
print(''.join(name))


# 第二种方法
name = "aleX leNb"
print(name.rstrip('Nb'))
'''
 4)  移除name变量开头的a"与最后的"b",并输出处理结果
'''
name = "aleX leNb"
name = name.lstrip('a')
name = name.rstrip('b')
print(name)

'''
 5)  判断 name 变量是否以 "al" 开头,并输出结果
'''
name = "aleX leNb"
if name.startswith('al'):
    print('该字符串是以al开头')
else:
    print('该字符串不是以al开头')

'''
6)  判断name变量是否以"Nb"结尾,并输出结果
'''
name = "aleX leNb"
if name.endswith('Nb'):
    print('该字符串是以Nb结尾')
else:
    print('该字符串不是以Nb结尾')
'''
 7)  将 name 变量对应的值中的 所有的"l" 替换为 "p",并输出结果
'''
name = "aleX leNb"
print(name.replace('l', 'p'))
'''
 8)  将name变量对应的值中的第一个"l"替换成"p",并输出结果
'''
# 第一种
name = "aleX leNb"
name = list(name)
name[1] = 'p'
print(''.join(name))

# 第二种方法
name = "aleX leNb"
print(name.replace('l', 'p', 1))

'''
 9)  将 name 变量对应的值根据所有的"l" 分割,并输出结果。
'''
name = "aleX leNb"
print(name.split('l'))

'''
 10) 将name变量对应的值根据第一个"l"分割,并输出结果。
'''
name = "aleX leNb"
print(name.split('l', 1))
'''
 11) 将 name 变量对应的值变大写,并输出结果
'''
name = "aleX leNb"
print(name.upper())

'''
 12) 将 name 变量对应的值变小写,并输出结果
'''
name = "aleX leNb"
print(name.lower())


'''
 13) 将name变量对应的值首字母"a"大写,并输出结果
     将name变量对应的值首字母"a"和"l"大写,并输出结果
'''
name = "aleX leNb"
print(name.capitalize())  # 只有a大写

name = "aleX leNb"
print(name.title())  # a和l大写

'''
 14) 判断name变量对应的值字母"l"出现几次，并输出结果
'''
namx

'''
 15) 如果判断name变量对应的值前四位"l"出现几次,并输出结果
'''
name = "alelX leNb"
print(name.count('l', 0, 3))

'''
 16) 从name变量对应的值中找到"N"对应的索引(如果找不到则报错)，并输出结果
'''
name = "aleX leNb"
print(name.index('N'))
'''
 17) 从name变量对应的值中找到"N"对应的索引(如果找不到则返回-1)输出结果
'''
name = "aleX leNb"
print(name.find('N'))

'''
 18) 从name变量对应的值中找到对应的索引,并输出结果
'''
name = "aleX leNb"
name = name.find("X le")
print(name)
'''
 19) 请输出 name 变量对应的值的第 2 个字符?
'''
name = "aleX leNb"
print(name[1])
'''
 20) 请输出 name 变量对应的值的前 3 个字符?
'''
name = "aleX leNb"
print(name[:3])

'''
 21) 请输出 name 变量对应的值的后 2 个字符?
'''
name = "aleX leNb"
print(name[-1:-3:-1])
'''
 22) 请输出 name 变量对应的值中 "e" 所在索引位置?
'''
name = "aleX leNb"
x = 0
for i in name:
    if i == 'e':
        print(x)
    x += 1

'''
2、有字符串s = "123a4b5c"
1)通过对s切片形成新的字符串s1,s1 = "123"
'''
s = "123a4b5c"
print(s[:3])
'''
2)通过对s切片形成新的字符串s2,s2 = "a4b"
'''
s = "123a4b5c"
print(s[3:6])
'''
3)通过对s切片形成新的字符串s3,s3 = "1345"
'''
s = "123a4b5c"
print(s[::2])
'''
4)通过对s切片形成字符串s4,s4 = "2ab"
'''
s = "123a4b5c"
print(s[1:-2:2])
'''
5)通过对s切片形成字符串s5,s5 = "c"
'''
s = "123a4b5c"
print(s[-1])
'''
6)通过对s切片形成字符串s6,s6 = "ba2"
'''
s = "123a4b5c"
print(s[-3:0:-2])
'''
3、使用while或for循环分别打印字符串s="asdfer"中每个元素。
'''
s = "asdfer"
for i in s:
    print(i)
'''
4、使用for循环对s="asdfer"进行循环，但是每次打印的内容都是"asdfer"。
'''
s="asdfer"
for i in s:
    print(s)
'''
5、使用for循环对s="abcdefg"进行循环，每次打印的内容是每个字符加上sb， 例如：asb, bsb，csb,...gsb。
'''
s="asdfer"
for i in s:
    print(i + 'sb')
'''
6、使用for循环对s="321"进行循环，打印的内容依次是："倒计时3秒"，"倒计时2秒"，"倒计时1秒"，"出发！"。
'''
s = "321"
for i in s:
    print('倒计时%d秒' % int(i))
print('出发')
'''
7、实现一个整数加法计算器(两个数相加)：
    如：content = input("请输入内容:") 用户输入：5+9或5+ 9或5 + 9，然后进行分割再进行计算。
'''
content = input("请输入内容:")
content = content.split('+')
content[0].strip()
content[1].strip()
print(int(content[0])+int(content[1]))

'''
8、升级题：实现一个整数加法计算器（多个数相加）：
如：content = input("请输入内容:") 用户输入：5+9+6 +12+  13，然后进行分割再进行计算。
'''
content = input("请输入内容:")
content = content.split('+')
i = 0
sum = 0
content[i] = content[i].strip()
for x in content:
    sum += int(content[i])
    i += 1
print(sum)

'''
9、测量用户输入的内容的个数（以个位数为单位）。
 如：content = input("请输入内容：")   # 如fhdal234slfh98769fjdla
'''
content = input("请输入内容：")
print(len(content))

'''
10、写代码，完成下列需求：
用户可持续输入（用while循环），用户使用的情况：
输入A，则显示走大路回家，然后在让用户进一步选择
是选择公交车，还是步行？
选择公交车，显示10分钟到家，并退出整个程序。
选择步行，显示20分钟到家，并退出整个程序。
输入B，则显示走小路回家，并退出整个程序
输入C，则显示绕道回家，然后在让用户进一步选择：
是选择游戏厅玩会，还是网吧？
选择游戏厅，则显示 ‘一个半小时到家，爸爸在家，拿棍等你。’并让其重新输入A，B,C选项。
选择网吧，则显示‘两个小时到家，妈妈已做好了战斗准备。’并让其重新输入A，B,C选
'''
while 1:
    msg = input('请输入 A/B/C:')
    if msg.upper() == 'A':
        print('大路')
        msg1 = input('公交or不行？ G/B')
        if msg1.upper() == 'G':
            print('10分钟到家')
        else:
            print('20分钟')
        break
    elif msg.upper() == 'B':
        print('小路回家')
        break
    elif msg.upper() == 'C':
        print('绕道回家')
        msg2 = input('游戏厅or网吧  Y/W')
        if msg2.upper() == 'Y':
            print('一个半小时到家，爸爸在家，拿棍等你')
        elif msg2.upper() == 'W':
            print('两个小时到家，妈妈已做好了战斗准备')
    else:
        print('输入错误啦，重选')
        
'''
11、写代码：计算 1 - 2 + 3 ... + 99 中除了88以外所有数的总和？
'''
n = 0
sum = 0
while n < 100:
    n += 1
    if n % 2 == 1:
        sum += n
    if n % 2 == 0:
        sum -= n
    if n == 88:
        continue
print(sum)


'''
16、制作趣味模板程序需求：等待⽤户输⼊名字、地点、爱好，根据⽤户的名字和爱好进⾏任意现实
如：敬爱可亲的xxx，最喜欢在xxx地⽅⼲xxx
'''
name = input('请输入姓名：')
age = input('请输入年龄：')
hobby = input('请输入爱好：')
msg = '我叫%s,今年%d岁,爱好%s。' % (name, int(age), hobby )
print(msg)
'''
17、等待⽤户输⼊内容，检测⽤户输⼊内容中是否包含敏感字符？
如果存在敏感字符提示“存在敏感字符请重新输⼊”，并允许⽤户重新输⼊并打印。敏感字符：“⼩粉嫩”、“⼤铁锤”
'''
msg = ['大傻子', '混蛋', '白痴', '滚']
while 1:
    msg1 = input('请输入内容:')
    if msg1 in msg:
        print('您输入的内容中包含敏感词汇：' + msg1)
    else:
        break
print('输入很规范，您输入的内容是:' + msg1)

'''
18、写代码，有如下列表，按照要求实现每一个功能
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
1)计算列表的长度并输出
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
print(len(li))
'''
2)列表中追加元素"seven",并输出添加后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.append('seven')
print(li)
'''
3)请在列表的第1个位置插入元素"Tony",并输出添加后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.insert(0, 'Tony')
print(li)
'''
4)请修改列表第2个位置的元素为"Kelly",并输出修改后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li[1] = "Kelly"
print(li)
'''
5)请将列表l2=[1,"a",3,4,"heart"]的每一个元素添加到列表li中，一行代码实现，不允许循环添加。
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.extend([1, "a", 3, 4, 'heart'])
'''
6)请将字符串s = "qwert"的每一个元素添加到列表li中，一行代码实现，不允许循环添加
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.extend("qwert")
'''
7)请给列表添加元素"eric",并输出添加后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.append("eric")
print(li)
'''
8)请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li1 = li.pop(2)
print(li1)
print(li)
'''
9)请删除列表中的第2至4个元素，并输出删除元素后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
del li[2:5]
print(li)
'''
10)请将列表所有得元素反转，并输出反转后的列表
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
li.reverse()
print(li)
'''
11)请计算出"alex"元素在列表li中出现的次数，并输出该次数。
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
print(li.count('alex'))
'''
19、写代码，有如下列表，利用切片实现每一个功能
    li = [1, 3, 2, "a", 4, "b", 5,"c"]
1)通过对li列表的切片形成新的列表l1,l1 = [1,3,2]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l2 = li[0:3]
'''
2)通过对li列表的切片形成新的列表l2,l2 = ["a",4,"b"]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l2 = li[3:6]
'''
3)通过对li列表的切片形成新的列表l3,l3 = ["1,2,4,5]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l3 = li[::2]
'''
4)通过对li列表的切片形成新的列表l4,l4 = [3,"a","b"]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l4 = li[1:-1:2]
'''
5)通过对li列表的切片形成新的列表l5,l5 = ["c"]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l5 = li[-1]
'''
6)通过对li列表的切片形成新的列表l6,l6 = ["b","a",3]
'''
li = [1, 3, 2, "a", 4, "b", 5,"c"]
l6 = li[-3:0:-2]
'''
20、写代码，有如下列表，按照要求实现每一个功能。
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
1)将列表lis中的"tt"变成大写（用两种方式）。
'''
# 方式一:
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[3][2][1][0] = lis[3][2][1][0].upper()
print(lis)

# 方式二:
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[3][2][1][0] = lis[3][2][1][0].replace('tt', 'TT')
print(lis)

'''
2)将列表中的数字3变成字符串"100"（用两种方式）
'''
# 方式一:
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[1] = '100'
lis[3][2][1][1] = '100'
print(lis)

# 方式二:
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[1] = str(lis[1]).replace('3', '100')
lis[3][2][1][1] = str(lis[3][2][1][1]).replace('3', '100')
print(lis)

'''
3)将列表中的字符串"1"变成数字101（用两种方式）
'''
# 方式一:
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[1] = '100'
lis[3][2][1][2] = int(101)
print(lis)

# 方式二:
lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[3][2][1][2] = int(lis[3][2][1][2].replace('1', '101'))
print(lis)

'''
21、请用代码实现：
 li = ["alex", "eric", "rain"]
 利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"
'''
li = ["alex", "eric", "rain"]
print('_'.join(li))

'''
22、利用for循环和range打印出下面列表的索引。
 li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
'''
li = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
for i in range(len(li)):
    print(i)
'''
23、利用for循环和range找出100以内所有的偶数并将这些偶数插入到一个新列表中
'''
lis = []
for i in range(100):
    if i%2 == 0:
        lis.append(i)
print(lis)

'''
24、利用for循环和range 找出50以内能被3整除的数，并将这些数插入到一个新列表中
'''
lis = []
for i in range(50):
    if i % 3 == 0:
        lis.append(i)
print(lis)

'''
25、利用for循环和range从100~1，倒序打印。
'''
for i in range(100, 0, -1):
    print(i)
'''
26、利用for循环和range从100~10，倒序将所有的偶数添加到一个新列表中，
    然后对列表的元素进行筛选，将能被4整除的数留下来。
'''
li = []
for i in range(100, 9, -1):
    if i % 4 == 0:
        li.append(i)
print(li)

'''
26、利用for循环和range，将1-30的数字一次添加到一个列表中，并循环这个列表，将能被3整除的数改成*
'''
li = []
x = 0
for i in range(1, 31):
    li.append(i)
    if i % 3 == 0:
        li[x] = '*'
    x += 1
print(li)
'''
27、查找列表li中的元素，移除每个元素的空格，并找出以"A"或者"a"开头，
    并以"c"结尾的所有元素，并添加到一个新列表中,最后循环打印这个新列表。
'''
l2 = []
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", "  aqc"]
for i in li:
    if (i.strip().startswith('a') or i.strip().startswith('A')) and i.strip().endswith('c'):
        l2.append(i)
for i in l2:
    print(i)
'''
28、开发敏感词语过滤程序，提示用户输入评论内容，如果用户输入的内容中包含特殊的字符：
    敏感词列表 li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
    则将用户输入的内容中的敏感词汇替换成等长度的*（苍老师就替换***），
    并添加到一个列表中；如果用户输入的内容没有敏感词汇，则直接添加到上述的列表中。
'''
li = ["苍老师", "东京热", "武藤兰", "波多野结衣"]
l2 = []
msg = input('请输入内容:')
for i in li:
    if i in msg:
        msg = msg.replace(i, '*'*len(i))  # 第二个* 代表乘以的意思
l2.append(i)
print(msg)
'''
29、有如下变量（tu是个元祖），请实现要求的功能
    tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
    a. 讲述元祖的特性
'''
# 数据可以被查询，但不能被修改
'''
    b. 请问tu变量中的第一个元素 "alex" 是否可被修改？
'''
# 不能
'''
    c. 请问tu变量中的"k2"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"
'''
# "k2"对应的值是 列表
# 可以被修改
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11, 22, 33)}, 44])
tu2 = tu[1][2]['k2']
tu2 = tu2.append('Seven')
print(tu)

'''
    d. 请问tu变量中的"k3"对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素 "Seven"
'''
# "k3"对应的值是 元祖
# 不可被修改

'''
30、字典dic,dic = {'k1': "v1", "k2": "v2", "k3": [11,22,33]}
    a. 请循环输出所有的key
'''
# 第一种方法：
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic:
    print(i)

# 第二种方法：
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic.keys():
    print(i)
'''
    b. 请循环输出所有的value
'''
# 第一种方法：
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic:
    print(dic[i])

# 第二种方法：
for i in dic.values():
    print(i)

'''
    c. 请循环输出所有的key和value
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
for i in dic.items():
    print(i)

'''
    d. 请在字典中添加一个键值对，"k4": "v4"，输出添加后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k4'] = 'v4'
print(dic)

'''
    e. 请在修改字典中 "k1" 对应的值为 "alex"，输出修改后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k1'] = 'alex'
print(dic)
'''
    f. 请在k3对应的值中追加一个元素 44，输出修改后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k3'].append(44)
print(dic)

'''
    g. 请在k3对应的值的第 1 个位置插入个元素 18，输出修改后的字典
'''
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
dic['k3'].insert(0, 18)
print(dic)

'''
31.av_catalog = {
    "欧美":{
        "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
        "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
        "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
        "x-art.com":["质量很高,真的很高","全部收费,屌丝请绕过"]
    },
    "日韩":{
    "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]
    },
        "大陆":{
    "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
    }
}
'''

'''
a,给此 ["很多免费的,世界最大的","质量一般"]列表第二个位置插入一个  元素：'量很大'。
'''
# av_catalog['欧美']['www.youporn.com'].insert(1, '量很大')

'''
b,将此 ["质量很高,真的很高","全部收费,屌丝请绕过"]列表的 "全部收费,屌丝请绕过" 删除。

'''
# 方法一
# av_catalog['欧美']['x-art.com'].remove('全部收费,屌丝请绕过')

# 方法二
# del av_catalog['欧美']['x-art.com'][1]

# 方法三
# av_catalog['欧美']['x-art.com'].pop(1)

'''
d,将此["质量怎样不清楚,个人已经不喜欢日韩范了","verygood"]列表的 "verygood"全部变成大写。

'''
# av_catalog['日韩']['tokyo-hot'][1] = av_catalog['日韩']['tokyo-hot'][1].upper()

'''
e,给 '大陆' 对应的字典添加一个键值对 '1048' :['一天就封了']

'''
# av_catalog['大陆']['1048'] = '一天就封了'

'''
f,删除此"letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"]键值对。

'''
# 方法一
# av_catalog['欧美'].pop('letmedothistoyou.com')

# 方法二
# del av_catalog['欧美']['letmedothistoyou.com']

'''
g,给此["全部免费,真好,好人一生平安","服务器在国外,慢"]列表的第一个元素，加上一句话：'可以爬下来'

'''
# av_catalog['大陆']['1024'][1] = '可以爬下来,服务器在国外,慢'

'''
32、有字符串"k:1|k1:2|k2:3|k3:4" 处理成字典 {'k':1,'k1':2....}
'''
dic = {}
s = 'k:1|k1:2|k2:3|k3:4'
s = s.split('|')
for i in s:
    i = i.split(':')
    dic[i[0]] = int(i[1])
print(dic)
'''
33、元素分类
    有如下值li= [11,22,33,44,55,66,77,88,99,90]，
    将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
    即： {'k1': 大于66的所有值列表, 'k2': 小于66的所有值列表}
'''
li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dic = {'k1': [], 'k2': []}
for i in li:
    if i > 66:
        dic['k1'].append(i)
    if i < 66:
        dic['k2'].append(i)
print(dic)


'''
作业：购物车
1. 用户先给自己的账户充钱：比如先充3000元。
2. 页面显示 序号 + 商品名称 + 商品价格，如：
    1 电脑 1999
    2 鼠标 10
    …
    n 购物车结算
3. 用户输入选择的商品序号，然后打印商品名称及商品价格,并将此商品，添加到购物车，用户还可继续添加商品。
4. 如果用户输入的商品序号有误，则提示输入有误，并重新输入。
5. 用户输入n为购物车结算，依次显示用户购物车里面的商品，数量及单价，
   若充值的钱数不足，则让用户删除某商品，直至可以购买，若充值的钱数充足，则可以直接购买。
6. 用户输入Q或者q退出程序。
7. 退出程序之后，依次显示用户购买的商品，数量，单价，以及此次共消费多少钱，账户余额多少。
'''

# 定义商品信息
shoping = {'1': {'name': '电脑', 'price': 1999},  # 选择商品编号的时候，输入的是字符串，所以此处编号用str型
           '2': {'name': '鼠标', 'price': 10},
           '3': {'name': '键盘', 'price': 20},
           }
# 定义购物车信息
my_car = {
    'accounts_money': 0,  # 账户余额
    'shopping_cart': {},  # 购物车内的商品，因为商品有多种，每种商品有价格和名称，所以用dic型
}

# 充值
while 1:
    money = input('请先充值:').strip()  # 去除输入时的左右空格等
    if money.isdigit():  # 判断输入的金额是否是数字
        my_car['accounts_money'] = int(money)  # 将充值金额传给账户余额
        print('成功充值%s元' % money)
        break
    else:
        print('充值失败，请输入正确的金额')

while 1:
    # 循环打印购物车商品信息，共用户选择添加到购物车
    for i in shoping:
        print(i, shoping[i]['name'], shoping[i]['price'])
    
    num = input('请输入商品序号，将会添加至购物车,退出请输入Q/q,结算请输入n:')
    if num in shoping:  # 判断输入的商品序号是否在商品信息内
        # 记录购物车物品数量
        count = my_car['shopping_cart'].setdefault(num, 0)  # setdefault表示新建一个键值对(x, 0)，并将value的值会返给count
        my_car['shopping_cart'][num] = count + 1  # 用户每次输入商品序号，购物车中该商品的数量+1
    
    # 购物车结算
    elif num.lower() == 'n':
        total_money = 0  # 初始化购物车的总金额
        for i in my_car['shopping_cart']:
            # 计算购物车内商品的总金额,每循环一次商品，金额都会在原来的基础上累加
            total_money += shoping[i]['price'] * my_car['shopping_cart'][i]  # 总金额 = 商品单价*商品数量
        
        # 判断购物车中的金额是否超出当前账户余额
        if total_money > my_car['accounts_money']:  # 如果账户余额>购物车中的总金额
            for i in my_car['shopping_cart']:  # 判断哪些商品在购物车中
                # 打印购物车商品信息，序号、商品名称、商品单价、商品数量,供用户删除
                print(i, shoping[i]['name'], shoping[i]['price'], my_car['shopping_cart'][i])
            del_num = input('余额不足，请删除购物车任意商品:')
            
            # 判断要删除的商品是否在购物车内
            if del_num in my_car['shopping_cart']:
                my_car['shopping_cart'][del_num] -= 1  # 购物车内输入的编号对应的商品数量-1
                
                # 如果购物车内该商品只剩下一件，则直接删除该商品
                if my_car['shopping_cart'][del_num] == 0:
                    my_car['shopping_cart'].pop(del_num)
        
        else:  # 如果账户余额<=购物车中的总金额
            print('购物车商品如下:')
            # 打印当前购物车剩余商品信息，商品名称、商品单价、商品数量
            for i in my_car['shopping_cart']:
                print(shoping[i]['name'], shoping[i]['price'], my_car['shopping_cart'][i])
            # 购物完成后，计算当前账户余额
            my_car['accounts_money'] -= total_money
            print('本次共消费%s元,账户余额%s元' % (total_money, my_car['accounts_money']))
            break
    
    # 退出程序
    elif num.upper() == 'Q':
        print('您已退出购物车')
        break
    else:
        print('输入错误，请重新输入')