一、字符格式化输出
1 name = input("名字：") 2 age = input("年龄：") 3 wage = input("工资：") 4 if age.isdigit(): #判断age是否是数字 5 age = int(age) 6 else: 7 exit("年龄输入错误") 8 a1 = '''---------Your %s------------ 9 name:%s 10 age:%d 11 wage:%s 12 你还能活%s年 13 -------------end-----------''' % (name,name,age,wage,80-age) 14 #占位符%s s = string 15 #数字 %d d=digit
二、数据类型出初识
整数为整型和长整型，python3 里面已经不区分整型与长整型，统一都叫整型。
布尔 只有2种状态，分别是
真 True
假 False
计算机中， 一切皆为对象
世界万物，皆为对象，一切对象皆可分类
三 、列表（list）
- 序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字- 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。
- Python有6个序列的内置类型，但最常见的是列表和元组。
- 序列都可以进行的操作包括索引，切片，加，乘，检查成员。
- 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
- 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
- 列表的数据项不需要具有相同的类型
- 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
列表的创建
1 num = ["a1","a2",2018,[2019,2020]] #可进行嵌套 2 b = list(("a1","a2"))#用list直接创建
列表一般操作
1 num = ["a1","a2","a3",2018,[2019,2020],"a4"]#[]里面的为元素，列表里的元素数据类型可以不同，也可以是另一个列表 2 num2 = ["a","b"] 3 print(num)#输出["a1","a2","a3",2018,[2019,2020],"a4"] 4 5 #使用下标索引来访问列表中的值，同样也可以使用方括号的形式截取字符，如下所示： 6 print(num[1])#输出a2 7 print(num[0],num[3])#输出为a1 2018 8 print(num[-1],num[-3])#输出a4 2018 9 #切片使用索引位置 10 print(num[0:3]) 11 print(num[:3])#输出为['a1','a2','a3'],此操作顾头不顾尾 12 print(num[-2:])#输出[[2019, 2020], 'a4'] 13 print(num[1:-2])#输出['a2', 'a3', 2018] 14 print(num[1:-1:2])#['a2', 2018] 第三个数值为步长 15 print(num[3:0:-1])#[2018, 'a3', 'a2'] 步长为负数时，怎从右往左取，依然顾头不顾尾 16 #添加 17 num.append("a5")#无法输出print(x.append("xx")） 18 print(num)#输出['a1', 'a2', 'a3', 2018, [2019, 2020], 'a4', 'a5'] append为默认输入到最后 19 num.insert(3,"2018a")#无法输出print(x.insert("xx")） 20 print(num)#输出结果['a1', 'a2', 'a3', '2018a', 2018, [2019, 2020], 'a4', 'a5'] insert 可插入到某个具体的位置 21 #删除 22 num.remove("2018a") 23 print(num)#输出结果为['a1', 'a2', 'a3', 2018, [2019, 2020], 'a4', 'a5']，可删除某一具体元素 24 b = num.pop(6)#()无索引数值择默认删除最后一个元素 25 print(num)#输出为['a1', 'a2', 'a3', 2018, [2019, 2020], 'a4']。可删除某一具体的索引 26 print(b)#输出为a5 pop删除可直接输出删除的内容 27 '''del num2[1] 28 print(num2)['1'] 29 #输出为['a'] del 通过索引删除元素，也可以直接删除整个列表如：del num2''' 30 31 #查找某一元素的索引数值 32 print(num.index("a3"))#输出为2 33 #查找某一元素出现的次数 34 print(num.count(2018))#输出结果为1 35 #反转列表 36 num.reverse() 37 print(num)#输出['a4', [2019, 2020], 2018, 'a3', 'a2', 'a1'] 38 # #排序 39 num.sort()#按照ASISS 排序 40 print(num) 41 #列表合并 42 num.extend(num2) 43 print(num)#输出：['a4', [2019, 2020], 2018, 'a3', 'a2', 'a1', 'a', 'b']
补充
1 b = {"名字":["wangming","xiaoli"],"nianling":[25,20]} 2 c=b.get("das","没有该键值对") # 没有该键值对 3 print(c)
三、元组（tuple）
元组也是存一组数据，只是一旦创建，便不能修改和删除，所以又叫只读列表。
1 tup1 = (1,2,3,4,5) 2 tup2 = ('frui', 27) 3 tup3 = "a", "b", "c", "d"; 4 tup4 = () #创建空元组
元组中只包含一个元素时，需要在元素后面添加逗号
tuple5 = (50,) #元组中只包含一个元素时，需要在元素后面添加逗号 tuple6 = (50) #如果不加逗号，则定义的不是tuple，是50这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算。
购物车练习
1 #__author:Mr. Zhang 2 #date: 2018/6/30 3 LB=[ 4 ("iphone6s",5800), 5 ("mac_book",9000), 6 ("coffee",32), 7 ("python_book",80), 8 ("bicyle",1500), 9 ]#LB为商品列表 10 GMLB = []#GMLB为已购买的商品，待用 11 money = input("你有多少钱？")#引导用户输入自己拥有的钱 12 if money.isdigit():#判断是否是数字 13 money = int(money)#改变字符串为整数 14 while True: 15 for i,v in enumerate (LB,1):#注意enumerate用法 16 print(i,">>>>",v) 17 ids = input("你想要的商品编号：(输入q退出）")#打印出商品列表 18 if ids.isdigit():#判断输入的商品编码是否为数字 19 ids = int(ids)#如果是数字则将字符串转换为整数 20 if ids > 0 and ids <= len(LB):#len(list)判断列表的长度 21 idss = LB[ids-1]#取出商品在列表中的索引 22 if money >= idss[1]:#判断商品金额是否大于用户余额 23 money -=idss[1] 24 GMLB.append(idss)#将购买的加入购物车 25 else: 26 print("余额不足，还剩%s"%money) 27 print(idss) 28 else: 29 print("商品编码不存在") 30 elif ids == "q": 31 print("-----你已经购买了一下商品-----") 32 print(GMLB) 33 print("你还剩余%s"%money) 34 break 35 else: 36 print("输入错误") 37 else: 38 exit("输入的格式错误")#如果输入的格式不是数字则会提示输入的格式错误
三、字典
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素通过键来存取，键不可修改，值可进行修改。
创建字典
num={“name”：1。“name2”：2，name3：[4,5,6]}#字典可进行嵌套
num2= dict(((“ name”,1),("name2",2))) 通过dict创建
基本操作
增
1 num = {"名字":"小明","年龄":"36","职业":"学生"} 2 print(num)#输出为{'名字': '小明', '年龄': '36', '职业': '学生'} 3 #增加 4 num["工资"] = 3500 5 print(num)#{'名字': '小明', '年龄': '36', '职业': '学生', '工资': 3500} 6 num.setdefault("名字","小红") 7 print(num)#{'名字': '小明', '年龄': '36', '职业': '学生', '工资': 3500} 键存在怎不改动 8 a=num.setdefault("身高","一米八") 9 print(num)#输出{'名字': '小明', '年龄': '36', '职业': '学生', '工资': 3500, '身高': '一米八'} 键不存在在字典中中增加新的键值对 10 print(a)#一米八 setdefault 可返回相应的值
查
1 num = {"名字":"小明","年龄":"36","职业":"学生"} 2 print(num["名字"])#输出小明 通过键查找值 3 print(num.keys())#输出 dict_keys(['名字', '年龄', '职业']) keys输出为字典的键 4 print(num.items())#dict_items([('名字', '小明'), ('年龄', '36'), ('职业', '学生')]) items 为字典的键值对 5 print(num.values())#ict_values(['小明', '36', '学生']) valuse 输出为字典的值 6 print("名字" in num) #True 判断字典num中是否包含名字 7 print(list(num.values()))#['小明', '36', '学生'] list 列表
改
1 num = {"名字": "小明", "年龄": "36", "职业": "学生"} 2 num["名字"] = "小红" 3 print(num)# num = {"名字":"小明","年龄":"36","职业":"学生"} 4 mun2 ={"性别":"男士"} 5 num.update(mun2) 6 print(num)#{'名字': '小红', '年龄': '36', '职业': '学生', '性别': '男士'} 可覆盖值
删
num = {"名字": "小明", "年龄": "36", "职业": "学生"}
# num.clear()#清空列表
# print(num)#{}
# del num["名字"]
# print(num)#{'年龄': '36', '职业': '学生'}
# num.pop("名字")#返回该键值对的值
# print(num)#{'年龄': '36', '职业': '学生'} 返回该键值对的值
a=num.popitem()#随机删除某组键值对，并以元组方式返回值
print(num)#{'名字': '小明', '年龄': '36'}
print(a)#('职业', '学生')
字典的遍历
dic = {'name': '小明', 'age': 18}
for i in dic:
print(i, dic[i])
"""输出为name 小明
age 18"""
for items in dic.items():
print(items)
"""输出('name', '小明')
('age', 18)"""
for keys, values in dic.items():
print(keys, values)
"""输出为name 小明
age 18
"""
其他操作
1 dic=dict.fromkeys(['host1','host2','host3'],'test') 2 print(dic)#{'host3': 'test', 'host1': 'test', 'host2': 'test'} 3 dic=dict.fromkeys(['host1','host2','host3'],['test1','tets2']) 4 print(dic)#{'host2': ['test1', 'tets2'], 'host3': ['test1', 'tets2'], 'host1': ['test1', 'tets2']} 5 dic['host2'][1]='test3' 6 print(dic)#{'host3': ['test1', 'test3'], 'host2': ['test1', 'test3'], 'host1': ['test1', 'test3']}
#sorted(dict) : 返回一个有序的包含字典所有key的列表 dic={5:'555',2:'666',4:'444'} print(sorted(dic.items()))#输出[(2, '666'), (4, '444'), (5, '555')]
四，字符串（string）
字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"123"等等。
请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。
字符串创建
1 a = “123” 2 b = “abc”
操作
1 # 1 * 重复输出字符串 2 print('hello'*2) 3 4 # 2 [] ,[:] 通过索引获取字符串中字符,这里和列表的切片操作是相同的,具体内容见列表 5 print('helloworld'[2:]) 6 7 # 3 in 成员运算符 - 如果字符串中包含给定的字符返回 True 8 print('el' in 'hello') 9 10 # 4 % 格式字符串 11 print('alex is a good teacher') 12 print('%s is a good teacher'%'alex') 13 14 15 # 5 + 字符串拼接 16 a='123' 17 b='abc' 18 c='789' 19 d1=a+b+c 20 print(d1) 21 # +效率低,该用join 列表转换为字符串 22 d2='>>'.join(["a","b","c"])23 print(d2)#a>>b>>c
内置方法
1 # string.capitalize() 把字符串的第一个字符大写 2 # string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 3 # string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 4 # string.decode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除 非 errors 指 定 的 是 'ignore' 或 者'replace' 5 # string.encode(encoding='UTF-8', errors='strict') 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' 6 # string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. 7 # string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 8 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 9 # string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常. 10 # string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False 11 # string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False 12 # string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False. 13 # string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False. 14 # string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False 15 # string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False 16 # string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False. 17 # string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False 18 # string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False 19 # string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 20 # string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 21 # string.lower() 转换 string 中所有大写字符为小写. 22 # string.lstrip() 截掉 string 左边的空格 23 # string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 24 # max(str) 返回字符串 str 中最大的字母。 25 # min(str) 返回字符串 str 中最小的字母。 26 # string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. 27 # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. 28 # string.rfind(str, beg=0,end=len(string) ) 类似于 find()函数，不过是从右边开始查找. 29 # string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始. 30 # string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 31 # string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找. 32 # string.rstrip() 删除 string 字符串末尾的空格. 33 # string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 34 # string.splitlines(num=string.count(' ')) 按照行分隔，返回一个包含各行作为元素的列表，如果 num 指定则仅切片 num 个行. 35 # string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. 36 # string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() 37 # string.swapcase() 翻转 string 中的大小写 38 # string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) 39 # string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中 40 # string.upper() 转换 string 中的小写字母为大写
相对常用的内置
1 #string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 2 # string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 3 # string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. 4 # string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 5 # print(st.format(name='alex',age=37)) # 格式化输出的另一种方式 待定：?:{} 6 # string.lower() 转换 string 中所有大写字符为小写. 7 # string.upper() 转换 string 中的小写字母为大写 8 # string.strip([obj]) 在 string 上执行 lstrip()和 rstrip() 9 # string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. 10 # string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串
1 s = "name:xiao ming" 2 # capitakize 首字母大写 3 s1 = s.capitalize() 4 print(s1) # Name:xiao ming 5 # upper 全部大写 6 s2 = s.upper() 7 print(s2) # NAME:XIAO MING 8 #lower 全部小写 9 s3 = s.lower() 10 print(s3) # name:xiao ming 11 #swapcase大小写翻转 12 s4 = s.swapcase() 13 print(s4)#NAME:XIAO MING 14 # title 首字母大写 15 s5 = s.title() 16 print(s5)#Name:Xiao Ming 17 # center 居中填充 18 a = "wang" 19 s6 = a.center(8,"*") 20 print(s6) # center 21 # 公共方法 22 s7 = len(s) 23 print(s7) # 14 查看元素的个数 24 #以XXX开头 startswith 25 b = 'alexWUsir' 26 s8 = b.startswith('alex')#True 27 s81 = b.startswith('e',2,5)#True，可以切片查找 28 print(s8) 29 print(s81) 30 #find index 通过元素查看索引 31 c = 'alexWUsir' 32 s9 = c.find('a') 33 s91 = c.index('a') 34 print(s91,s9) # find 通过元素找索引，找不到返回-1 index通过元素找索引，找不到报错 35 #strip 删除前后空格 36 d= " liming " 37 s10 = d.strip() 38 print(s10) # liming 删除前面空格retrip lstrip 39 #count 元素出现的次数 40 s11 = d.count('li') 41 print(s11) # 1 42 #字符串转列表 分割 43 #split str ---->list 44 e = 'alex wusir taibai' 45 l = e.split() 46 print(l) # ['alex', 'wusir', 'taibai'] 47 48 #format的三种玩法 格式化输出 49 q = '我叫{}，今年{}，爱好{}，再说一下我叫{}'.format('小明',36,'读书','小明') 50 print(q) 51 q = '我叫{0}，今年{1}，爱好{2}，再说一下我叫{0}'.format('小明',36,'小明') #注意要从0开始 52 print(q) 53 name = input('请输入名字：') 54 q = '我叫{name}，今年{age}，爱好{hobby}，再说一下我叫{name}'.format(age=18,name=name,hobby='girl') 55 print(q)
五、集合
集合的定义：
集合是无序的，不重复的数据集合，集合本身不可哈希，里面的元素是可哈希的，所以无法做字典里的键
集合的作用：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
1、集合的创建。
1 set1 = set((1,2,3,4)) 2 set2 = {1,2,3,4} 3 print(set1,set2) # {1, 2, 3, 4} {1, 2, 3, 4} 4 print(type(set1),type(set2)) # <class 'set'> <class 'set'>
2、集合的增。
1 set1 = {1, 2, 3, 4, 5} 2 set1.add("sb") # {1, 2, 3, 4, 5, 'sb'} 3 print(set1) 4 set1.update("ad") 5 print(set1) # {1, 2, 3, 4, 5, 'a', '
3、集合的删
1 set1 = {1, 2, 3, 4, 5,6,7,8,8,9,10} 2 set1.pop() # pop 随机删除 3 print(set1) 4 set2 = {1, 2, 3, 4, 5,6,7,8,8,9,10} 5 set2.remove(5) 6 print(set2) # {1, 2, 3, 4, 6, 7, 8, 9, 10}
4、集合的查
set1 = {1, 2, 3, 4, 5,6,7,8,8,9,10}
for i in set1:
print(i) # 只能for循环查
5、集合的其他操作
5.1、交集（& 或者 intersection）
1 set1 = {1, 2, 3, 4, 5} 2 set2 = {1, 2, 3, 4, 6, 7, 8} 3 print(set1 & set2) # {1, 2, 3, 4} 4 print(set1.intersection(set2)) # {1, 2, 3, 4}
5.2 并集。（| 或者 union）
1 #两个集合合并到一起 2 set1 = {1,2,3,4,5} 3 set2 = {4,5,6,7,8} 4 print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7} 5 print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7}
5.3 差集。（- 或者 difference）
1 #取出set1中set2不包含的数 2 set1 = {1,2,3,4,5} 3 set2 = {4,5,6,7,8} 4 print(set1 - set2) # {1, 2, 3} 5 print(set1.difference(set2)) # {1, 2, 3}}
5.4反交集。 （^ 或者 symmetric_difference）
1 #取出相互不包含的数 2 set1 = {1,2,3,4,5} 3 set2 = {4,5,6,7,8} 4 print(set1 ^ set2) # {1, 2, 3, 6, 7, 8} 5 print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
5.5子集与超集
1 set1 = {1,2,3} 2 set2 = {1,2,3,4,5,6} 3 4 print(set1 < set2) # True 5 print(set1.issubset(set2)) # True 这两个相同，都是说明set1是set2子集。 6 7 print(set2 > set1) # True 8 print(set2.issuperset(set1)) # True 这两个相同，都是说明set2是set1超集。
六、深浅（copy）
浅copy
1 # 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。 2 l1 = [1, 2, 3, ['a', 'b']] 3 l2 = l1.copy() 4 5 print(l1, id(l1)) # [1, 2, 3, ['a', 'b']] 30171784 6 print(l2, id(l2)) # [1, 2, 3, ['a', 'b']] 31195656 7 8 l1[1] = 222 9 print(l1, id(l1)) # [1, 222, 3, ['a', 'b']] 30171784 10 print(l2, id(l2)) # [1, 2, 3, ['a', 'b']] 31195656 11 12 l1[3][0] = 'c' 13 print(l1, id(l1[3])) # [1, 222, 3, ['c', 'b']] 30171720 14 print(l2, id(l2[3])) # [1, 2, 3, ['c', 'b']] 30171720
深deepcopy
1 #对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。 2 import copy 3 l1 = [1,2,3,['a','b']] 4 l2 = copy.deepcopy(l1) 5 6 print(l1,id(l1)) # [1, 2, 3, ['a', 'b']] 35356232 7 print(l2,id(l2)) # [1, 2, 3, ['a', 'b']] 35354888 8 9 l1[1] = 222 10 print(l1,id(l1)) # [1, 222, 3, ['a', 'b']] 35356232 11 print(l2,id(l2)) # [1, 2, 3, ['a', 'b']] 35354888 12 13 l1[3][0] = 'c' 14 print(l1,id(l1[3])) # [1, 222, 3, ['c', 'b']] 35578376 15 print(l2,id(l2[3])) # [1, 2, 3, ['a', 'b']] 35578696
七、编码于解码
ascii
表示英文：八位一个字节（如00000001）
unicode
表示英文和表示英文一致为：三十二位四个字节（如00000000 00000001 00000010 00000100）
UTF-8
表示英文：八位一个字节（如00000001）
表示中文：二十四位三个字节（如00000001 00000010 00000110）
gbk：
表示英文：八位一个字节（如00000001）
表示中文：十六位两个字节（如00000010 00000110）
性质：
1，各个编码之间的二进制，是不能互相识别的，会产生乱码。
2，文件的储存，传输，不能是unicode（只能是utf-8 utf-16 gbk,gb2312,asciid等）
py3:
str 在内存中是用unicode编码。
bytes类型
对于英文：
str ：表现形式：s = 'alex'
编码方式： 010101010 unicode
bytes ：表现形式：s = b'alex'
编码方式： 000101010 utf-8 gbk。。。。
对于中文：
str ：表现形式：s = '中国'
编码方式： 010101010 unicode
bytes ：表现形式：s = b'xe91e91e01e21e31e32'
编码方式： 000101010 utf-8 gbk。。。。
encode 编码
1 #将str --> bytes, () 2 s1 = 'a' 3 s11 = s1.encode('utf-8') 4 s11 = s1.encode('gbk') 5 print(s11) 6 s2 = '中国' 7 s22 = s2.encode('utf-8') 8 # s22 = s2.encode('gbk') 9 print(s22)
decode 解码
#str --->byte encode 编码 s = "中国" b = s.encode('utf-8') print(b) #byte --->str decode 解码 s1 = b.decode('utf-8') print(s1) s = 'abf' b = s.encode('utf-8') print(b) # --->str decode 解码 s1 = b.decode #byte('gbk') print(s1)
练习三级菜单
缺点：重复代码较多
1 zone = { 2 '山东' : { 3 '青岛' : ['四方','黄岛','崂山','李沧','城阳'], 4 '济南' : ['历城','槐荫','高新','长青','章丘'], 5 '烟台' : ['龙口','莱山','牟平','蓬莱','招远'] 6 }, 7 '江苏' : { 8 '苏州' : ['沧浪','相城','平江','吴中','昆山'], 9 '南京' : ['白下','秦淮','浦口','栖霞','江宁'], 10 '无锡' : ['崇安','南长','北塘','锡山','江阴'] 11 }, 12 '浙江' : { 13 '杭州' : ['西湖','江干','下城','上城','滨江'], 14 '宁波' : ['海曙','江东','江北','镇海','余姚'], 15 '温州' : ['鹿城','龙湾','乐清','瑞安','永嘉'] 16 }, 17 '安徽' : { 18 '合肥' : ['蜀山','庐阳','包河','经开','新站'], 19 '芜湖' : ['镜湖','鸠江','无为','三山','南陵'], 20 '蚌埠' : ['蚌山','龙子湖','淮上','怀远','固镇'] 21 }, 22 '广东' : { 23 '深圳' : ['罗湖','福田','南山','宝安','布吉'], 24 '广州' : ['天河','珠海','越秀','白云','黄埔'], 25 '东莞' : ['莞城','长安','虎门','万江','大朗'] 26 } 27 } 28 LB = [] 29 while True: 30 for i in zone: 31 print(i) #打印省级菜单 32 choice = input(">>>(输入b退出程序)") 33 if choice in zone:#判断输入合法 34 LB.append(choice) # 如果合法将数值加入列表 35 while True:#将数值停留在第二层 36 for k in zone[choice]:print(k) #打印市级菜单 37 choice2 = input(">>>(输入q返回上一层，输入b退出程序) ") 38 if choice2 in zone[choice]:#判断输入合法 39 LB.append(choice2)# 如果合法将数值加入列表 40 while True: 41 for v in zone[choice][choice2]:print(v) 42 choice3 = input(">>>(输入q返回上一层，输入b退出程序)") 43 if choice3 in zone[choice][choice2]:#判断输入合法 44 LB.append(choice3)# 如果合法将数值加入列表 45 print(LB) #打印列表 46 exit("结束") 47 elif choice3 == "q": 48 LB.pop() #返回上一层时删除列表中的最后一个数值 49 break 50 elif choice3 == "b":exit(" 结束") 51 elif choice2 == "q": 52 LB.pop() 53 break 54 elif choice2 == "b":exit(" 结束") 55 elif choice == "b":exit(" 结束")
有问题待解决
1：最后打印列表问题
2：最后一层输入完后会报错
3：返回到第一层会报错
1 zone = { 2 '山东' : { 3 '青岛' : ['四方','黄岛','崂山','李沧','城阳'], 4 '济南' : ['历城','槐荫','高新','长青','章丘'], 5 '烟台' : ['龙口','莱山','牟平','蓬莱','招远'] 6 }, 7 '江苏' : { 8 '苏州' : ['沧浪','相城','平江','吴中','昆山'], 9 '南京' : ['白下','秦淮','浦口','栖霞','江宁'], 10 '无锡' : ['崇安','南长','北塘','锡山','江阴'] 11 }, 12 '浙江' : { 13 '杭州' : ['西湖','江干','下城','上城','滨江'], 14 '宁波' : ['海曙','江东','江北','镇海','余姚'], 15 '温州' : ['鹿城','龙湾','乐清','瑞安','永嘉'] 16 }, 17 '安徽' : { 18 '合肥' : ['蜀山','庐阳','包河','经开','新站'], 19 '芜湖' : ['镜湖','鸠江','无为','三山','南陵'], 20 '蚌埠' : ['蚌山','龙子湖','淮上','怀远','固镇'] 21 }, 22 '广东' : { 23 '深圳' : ['罗湖','福田','南山','宝安','布吉'], 24 '广州' : ['天河','珠海','越秀','白云','黄埔'], 25 '东莞' : ['莞城','长安','虎门','万江','大朗'] 26 } 27 } 28 num = zone 29 LB = [] 30 while True: 31 for a in num: 32 print(a) 33 choice=input("<<<(输入q返回上一层：输出b退出)") 34 if choice in num: 35 LB.append(num) 36 num = num[choice] 37 elif choice == "q": num = LB.pop() 38 elif choice == "b": 39 exit("结束") 40 else: 41 print("请从新输入")