字符串：数据类型的学习
#======================================基本使用====================================== #1、用途 #2、定义方式 #3、常用操作+内置的方法 #======================================该类型总结==================================== #存一个值or存多个值 #有序or无序 #可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）
- 一、字符串索引
s2 = 'abc123嘿嘿' # 正向索引，从0开始编号 print(s2[3]) # 反向索引，从-1开始编号 print(s2[-3])
- 二、字符串切片
切片：(获取子字符串):
语法[开始索引:结束索引:步长]
i) 步长省略，默认为1
ii) 起始索引省略，默认为从头开始
iii) 结束索引省略，默认到最后结束
# 顾头不顾尾[6:8]，从索引6截取到索引8之前 ss2 = 'hello world' new_ss2 = ss2[6:8:] print(new_ss2)
>wo # 结束索引:-1代表截取到最后一位之前，省略代表截取到最后 # 开始索引省略代表从头开始截取 print(ss2[6:-1:])
>worl # 截取一次只截取一个字符，但是截取后迈2步截取下一个hlowrd print(ss2[::2])
>hlowrd # 打印'dlrow olleh'，翻转字符串 # 步长为负数时，从后往前截取(开始索引建议使用负值) print(ss2[-1::-1])
>dlrow olleh
#作用：名字，性别，国籍，地址等描述信息 #定义：在单引号\双引号\三引号内，由一串字符组成 name='egon' #优先掌握的操作： #1、按索引取值(正向取+反向取) ：只能取 #2、切片(顾头不顾尾，步长) #3、长度len #4、成员运算in和not in #5、移除空白strip #6、切分split #7、循环
需要掌握：
#1、strip,lstrip,rstrip #2、lower,upper #3、startswith,endswith #4、format的三种玩法 #5、split,rsplit #6、join #7、replace #8、isdigit
# 1.获取字符串长度 s3 = 'abcdef' print(len(s3)) # len(s) 获取s的字符长度 >6 # 2.成员运算 #语法：in | not in：子字符串是否在父字符串中 s5 = 'abc123嘿嘿' # in | not in: 子字符串 in 父字符串 print('abcd' in s5) print('abc' not in s5) print('呵呵' not in s5) >False >False >True # not in要同步出现 # print('>>>', '呵呵' not in s5) # 3.首尾去白 #语法：strip() print(' hello wolrd '.strip()) >hello wolrd print('===login success==='.strip('=')) >login success # 4.拆分 #语法：split(拆分规则, 拆分次数) print('D:\\python36\\python3.exe'.split('\\', 1)) >['D:', 'python36\\python3.exe'] s4 = "D:\\pathon36\\python3.exe" # 需求：1.获取python的安装盘符；2.获取python的执行文件 s4_list = s4.split('\\') # 拆分：就是将字符串转化为列表 print(s4_list) >['D:', 'pathon36', 'python3.exe'] print(s4_list[0]) >D: print(s4_list[-1]) >python3.exe # 完成以上需求还要保证拆分得到的结果尽可能短 ## 注：拆分的依据，拆分的次数 s4_list = s4.split('\\', 1) print(s4_list[0])
#strip,lstrip,rstrip name='*egon**' print(name.strip('*')) # *全部去掉 print(name.lstrip('*')) # 去掉左边的* leftstrip=lstrip print(name.rstrip('*')) # 去掉右边的* rightstrip=rstrip #lower,upper name='simoN' print(name.lower()) # name内容全部小写 print(name.upper()) # name内容全部大写 #startswith,endswith name='alex_SB' print(name.endswith('SB')) #以SB结尾为真：True print(name.startswith('alex')) #以alex开头为真：True #format的三种玩法 res='{} {} {}'.format('egon',18,'male') >egon 18 male res='{1} {0} {1}'.format('egon',18,'male') >18 egon 18 res='{name} {age}{sex}'.format(sex='male',name='egon',age=18) >egon 18 male #split name='root:x:0:0::/root:/bin/bash' print(name.split(':')) #默认分隔符为空格 name='C:/a/b/c/d.txt' #只想拿到顶级目录 print(name.split('/',1)) name='a|b|c' print(name.rsplit('|',1)) #从右开始切分 >['a|b', 'c'] #join tag=' ' print(tag.join(['egon','say','hello','world'])) #可迭代对象必须都是字符串 >egon say hello world #replace name='alex say :i have one tesla,my name is alex' print(name.replace('alex','SB',1)) >SB say :i have one tesla,my name is alex #isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法 age=input('>>: ') print(age.isdigit())
参数
# rsplit：从右开始拆分 s4 = "D:\\pathon36\\python3.exe" s4_list = s4.rsplit('\\', 1) print(s4_list) # startswith | endswith：以某某开头 | 结尾：返回值为bool类型 print("http://www.baidu.com".startswith('https://')) print("http://www.baidu.com".endswith('com')) # 思考：自学正则：re # format：格式化 print('name:%s，age:%s' % ('owen', 18)) # 占位与实际数据要进行个数与位置的匹配 print('name:{}，age:{}'.format('Liuxx', 8)) # 指定位置要数据：{0}要0号位数据 print('name:{0}，age:{1}, name:{0}'.format('Linoo', 58)) # 指定名字要数据 print('name:{usr}，age:{age}, name:{usr}'.format(age=58, usr='Linoo')) # replace：替换 # 语法：replace(oldS, newS, count) s6 = 'abcabcabc' newS6 = s6.replace('a', 'A', 2) print(newS6)
参数补充
# 1. find | rfind：查找子字符串索引，无结果返回-1 s1 = 'abcabc' print(s1.rfind('ab')) # 返回第一次查询到的（目标字符串首位）正向索引 # 2. index | rindex：查找子字符串索引，无结果抛出异常 print(s1.index('cb')) # 崩溃 # # 3. count：计算子字符串个数 print(s1.count('abc')) # # 4. center | ljust | rjust | zfill：按位填充,一般在进制时使用，不足填0 # 语法：center(所占位数, '填充符号') # 使用： 调用者.center(参数) print("华丽分割线".center(30, '-')) print("华丽分割线".ljust(30, '-')) print("1240".zfill(5)) print("9010".zfill(5)) print("59000".zfill(5)) # # # 5. expandtabs：规定\t所占空格数 print('hello\tworld'.expandtabs(8)) # # # 6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转 print("hello world".capitalize()) print("hello world".title()) print("hello WORLD".swapcase()) # # # 7. isdigit | isdecimal | isnumeric：数字判断 s7 = b'123' # isdigit来判断是否可以转换为数字 print(b'123'.isdigit()) # 三个方法均有 print(u'123'.isdigit()) print(u'123'.isdecimal()) print(u'123'.isnumeric()) print('肆'.isdigit()) print('肆'.isdecimal()) print('肆'.isnumeric()) # 可以判断中文数字 print('Ⅳ'.isdigit()) print('Ⅳ'.isdecimal()) # 不用管 print('Ⅳ'.isnumeric()) # 可以判断罗马数字 # # # 8. isalnum | isalpha：是否由字母数字组成 | 由字母组成 print('abc123_'.isalnum()) print('abc'.isalpha()) # # # 9. isidentifier：是否为合法变量名 print('>>>', 'a_123'.isidentifier()) # # # 10. islower | isupper：是否全小 | 大写 print("aBc".islower()) print("ABC".isupper()) # # # 11. isspace：是否是空白字符 print(" ".isspace()) # # 12. istitle：是否为单词首字母大写格式 print("Hello World".istitle())
- 三、字符串循环
s = 'hello world' # 字符串循环（遍历） i = 0 while i < len(s): print(s[i]) i += 1 # 迭代 for c in s: print(c) # 总结： # 1.循环迭代s，一次在s中取出一个字符，存放到c中 # 2.下一次取出会覆盖上一次c # 3.当s中所有字符取出后，循环自动停止 # 哪些变量是可以被迭代的：str、list、dict、tuple、set、range生产的对象 print(range(5)) # 从什么数字开始，到什么数字前结束，步长是多少 for i in range(1, 5, 2): print(i) for i in range(10, 16): print(i)
# 写代码,有如下变量,请按照要求实现每个功能 （共6分，每小题各0.5分） name = " aleX" # 1) 移除 name 变量对应的值两边的空格,并输出处理结果 # 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果 # 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果 # 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果 # 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。 # 6) 将 name 变量对应的值变大写,并输出结果 # 7) 将 name 变量对应的值变小写,并输出结果 # 8) 请输出 name 变量对应的值的第 2 个字符 # 9) 请输出 name 变量对应的值的前 3 个字符 # 10) 请输出 name 变量对应的值的后 2 个字符 # 11) 请输出 name 变量对应的值中 “e” 所在索引位置? # 12) 获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
name = " aleX" # 1) print(name.strip()) # >aleX # 2) print(name.startswith("al")) # >False # 3) print(name.endswith("X")) # >True # 4) print(name.replace('l','p')) #> apeX #5) print(name.split("l")) # >[' a', 'eX'] # 6) print(name.lower()) # > alex # 7) print(name.upper()) # > ALEX # 8) print(name[2]) #> l # 9) print(name[:3]) # > al # 10) print(name[3:]) # >eX print(name[-2:]) #步长为正数时从前往后取值，为负数时从后往前取值 #11) print(name.index("e")) # >3 #12) print(name[:4]) #> ale print(name[:-1]) #> ale
- 四、可变和不可变类型
# 数字 # 1.只能存放一个值 # 2.数字为不可变类型: 值改变了id一定改变（值一旦确定，就不能再修改） a = 10 print(id(a)) # a = 11 a += 1 print(id(a)) # 字符串 # 1.只能存放一个值 # 2.字符串为不可变类型 s = '123' print(id(s)) s = s * 2 print(id(s)) # 列表: 为可变类型，在id不改变的情况下，还可以修改内部数据 l = [1, 2, 3] print(id(l)) # print(l[0]) l[0] = 10 print(id(l)) l.append(20) print(id(l))
- 五、列表
介绍：
#作用：多个装备，多个爱好，多门课程，多个女朋友等 #定义：[]内可以有多个任意类型的值，逗号分隔 my_girl_friends=['alex','wupeiqi','yuanhao',4,5] #本质my_girl_friends=list([...]) 或 l=list('abc')
l1 = [1, 3.14, 5 + 4j, True, 'abc', [[1]]]
print(l1)
l2 = list([1, 3.14, 5 + 4j, True, 'abc', [[1]]])
print(l2)
#优先掌握的操作： #1、按索引存取值(正向存取+反向存取)：即可存也可以取 #2、切片(顾头不顾尾，步长) #3、长度 #4、成员运算in和not in #5、追加 #6、删除 #7、循环
#ps:反向步长 l=[1,2,3,4,5,6] #正向步长 l[0:3:1] #[1, 2, 3] #反向步长 l[2::-1] #[3, 2, 1] #列表翻转 l[::-1] #[6, 5, 4, 3, 2, 1]
1.字符串转换为列表
# 将字符串转换为列表: 字符串方法 l3 = 'hello world'.split(' ') print(l3) # 将列表转换为字符串: 字符串方法，调用方法的字符串为拼接字符串的依据 # 将列表中的所有数据，从前往后，安装拼接符进行拼接 newStr = '@'.join(l3) # hello@world print(newStr)
列表转换为字符串：
l = ["hi","hello","world"]
print(" ".join(l))
2.列表切片
list3 = [1, 2, 3, 4, 5] print(list3[1:-1:2]) # [2, 4]
3.列表的增删改查
#1. 删除普通变量 a = 10 del a print(a) #2. 增：append(obj) 在末尾添加对象 list4 = [] print(id(list4)) #id:35656200 list4.append(1) list4.append(5) list4.append(2) print(list4) #[1, 5, 2] print(id(list4)) # id:35656200 #3. 插入(对应位置插入数据) list4.insert(0, 10) print(list4) #[10, 1, 5, 2] print(id(list4)) #35656200 #4. 删 # 删除指定索引 del list4[0] print(list4) # [1, 5, 2] # 删除指定对象 list4.remove(5) print(list4) #[1, 2] #5. 改： list4[0] = 10000 print(list4) #[10000, 2] #6. 查 print(list4[1]) # 2 #7.长度 print(list4) list4.append(88888) print(len(list4)) # list4: [10000, 2, 88888] 共3个值 #8. 成员运算 print(2 in list4) #True # 9. 循环：迭代 list7 = [1, 3, 5, 7, 0] for obj in list7: print(obj, end=',') # 1,3,5,7,0, # 需求：打印1,3,5,7,0 sss = "" for obj in list7: sss += str(obj) + ',' # obj是int类型，不能直接做字符串拼接，转化成字符串 print('>>>', sss[:-1]) # >>> 1,3,5,7,0
# 翻转 a = [1, 3, 2] a.reverse() print(a) # [2, 3, 1] # 排序: # 前提：1.数据之间全部具有可比性；2：数据要统一类型 b = [1, 3, 2, 5, 4] b.sort() print(b) # [1, 2, 3, 4, 5] # 倒序 b.reverse() print(b) # [4, 5, 2, 3, 1] b.sort(reverse=True) print(b) # [5, 4, 3, 2, 1]
''' *** 1. copy：复制 2. clear：清空 3. count：计算成员个数 4. extend：添加多个值(参数为可迭代对象) 5. index：查找索引 ''' x = [1, 3, 5, 3] y = x print(x, id(x)) # [1, 3, 5, 3] 32117256 print(y, id(y)) # [1, 3, 5, 3] 32117256 z = x.copy() print(z, id(z)) # [1, 3, 5, 3] 32091976 #copy复制,id会变,x值被修改，但copy出来的z却不会 x[0] = 10000 print(x[0]) # 10000 print(y[0]) # 10000 print(z[0]) # 1 #清空列表 z.clear() print(z) # [] #统计成员个数 # # [10000, 3, 5, 3] print(x.count(3)) # 2 3在列表中的总数量 #extend添加多个值 list1 = [] list1.extend('abc') print(list1) # ['a', 'b', 'c'] # list2 = ['abc', 'xyz'] list1.extend(list2) print(list1) # ['a', 'b', 'c', 'abc', 'xyz']
max(list)：返回列表元素最大值
min(list)：返回列表元素最小值
list(seq)：将元组转换为列表
总结： 1. 列表中可以存放多个值 2. 列表为可变类型：id不变的情况下，可以发生值变化 3. 列表为有序存储结构：可以通过索引取值
""" #zip dict index list enumerate（取下标） len s为字符串 s.isalnum() 所有字符都是数字或者字母 s.isalpha() 所有字符都是字母 s.isdigit() 所有字符都是数字 s.islower() 所有字符都是小写 s.isupper() 所有字符都是大写 s.istitle() 所有单词都是首字母大写，像标题 s.isspace() 所有字符都是空白字符、\t、\n、\r """ """ name = "my \tname is {name} and I am {year} yearold" print(name.capitalize()) #首字母大写 print(name.count("o")) #统计出现o的次数 print(name.center(10,"-")) print(name.endswith("on")) #判断以什么结尾，True print(name.expandtabs(tabsize=10)) #转换空格，很少用 print(name.find("name")) #列表中以什么开头 print(name[name.find("name"):]) #字符串切片 print(name.format(name='alex',year=23)) print(name.format_map( {'name':'alex','year':12} )) print(name.isalnum()) #isalnum判断是不是阿拉伯数字，不能有特殊字符 print(name.isalpha()) #纯因为字符 print('1'.isdecimal()) # print('11'.isdigit()) #是不是整数 print('_1A'.isidentifier()) #判断是不是一个合法的标识符或合法的变量名 print('11'.isnumeric()) #是不是一个整数字 print(' '.isspace()) #是不是空格 print('My Name Is'.istitle()) #每个首字母是否大写 print('My Name Is'.isprintable()) #pty、drive文件 print('MY'.isupper()) #是不是都是大写 print('+'.join(['1','2','3'])) #列表转换为字符串 print(name.ljust(50,'*')) #末尾补齐50个字符 print(name.rjust(50,'*')) #开头补齐 print('Simon'.lower()) #转换为小写 print('Simon'.upper()) #转换为大写 print('\nSimon'.lstrip()) #从左边去掉空格和回车 print('\nSimon\n'.rstrip()) #从右边去掉空格和回车 print(' Simon\n'.strip()) #2变空格和换行都去掉 p = str.maketrans("abcdefmn",'1234567$') print("simon xiong".translate(p)) #将内容进行对应转换，感觉加密的时候也许可以使用 print('simon'.replace('s','S')) #小写s替换为大写 print('simons'.replace('s','S',1)) #只替换1个 print("simon xiong".rfind('n')) #找到最后边值的下标 print("simon".rsplit()) print("simon".split('m')) #将字符串按空格进行分隔 print('1=2\n+3+4'.splitlines()) #识别不同系统的换行 print('Simon Xiong'.swapcase()) #大小写转换 print('Simon Xiong'.title()) #首字母大写 print("Simon xiong".zfill(50)) #16进制补位
练习：
# 1. 有列表data=['alex',49,[1970,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量 data=['alex',49,[1970,3,18]] name = data[0] age = data[1] born1 = [str(i) for i in data[2]] born = '-'.join(born1) print(name,age,born) # 2. 用列表模拟队列 #队列的特点：先进先出、后进后出 #用列表insert、pop模拟进队出队: >>> l = [] >>> l.insert(0,'s1') >>> l.insert(0,'s2') >>> l.insert(0,'s3') >>> l ['s3', 's2', 's1'] >>> l.pop() 's1' >>> l ['s3', 's2'] >>> l.pop() 's2' >>> l ['s3'] >>> l.pop() 's3' >>> l [] # 用列表append、pop模拟进队出队 >>> l [] >>> l.append('s4') >>> l.append('s5') >>> l.append('s6') >>> l ['s4', 's5', 's6'] >>> l.pop(0) 's4' >>> l ['s5', 's6'] >>> l.pop(0) 's5' >>> l ['s6'] >>> l.pop(0) 's6' >>> l [] # 3. 用列表模拟堆栈 # 堆栈特点：先进后出、后进先出 # 用列表insert、pop方法模拟进栈出栈: >>> l = [] >>> l.insert(0,'a1') >>> l.insert(0,'a2') >>> l.insert(0,'a3') >>> l ['a3', 'a2', 'a1'] >>> l.pop() 'a1' >>> l ['a3', 'a2'] >>> l.pop() 'a2' >>> l ['a3'] >>> l.pop() 'a3' >>> l [] # 用列表append、pop方法模式进栈出栈: >>> l = [] >>> l.append('a1') >>> l.append('a2') >>> l.append('a3') >>> l ['a1', 'a2', 'a3'] >>> l.pop() 'a3' >>> l ['a1', 'a2'] >>> l.pop() 'a2' >>> l ['a1'] >>> l.pop() 'a1' >>> l [] # 4. 有如下列表，请按照年龄排序（涉及到匿名函数） l=[ {'name':'alex','age':84}, {'name':'oldboy','age':73}, {'name':'egon','age':18}, ] # 答案： l.sort(key=lambda item:item['age']) print(l)
- 六、元组
# 元组：可以理解为，不可变的列表
# 1.元组的长度不可以变化
# 2.元组中的值可以变化，但是变化其实是存放了可变的数据类型，元组本质没有改变
#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读 #定义：与列表类型比，只不过[]换成() age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55)) #优先掌握的操作： #1、按索引取值(正向取+反向取)：只能取 #2、切片(顾头不顾尾，步长) #3、长度 #4、成员运算in和not in #5、循环
# 一、定义 t1 = (1, 2, 3, 4, 5) print(t1) # (1, 2, 3, 4, 5) t2 = tuple((1, 2, 3, 4, 5)) print(t2) # (1, 2, 3, 4, 5) # 空元组 t3 = () print(t3) #() t4 = tuple() print(t4) # () # 含义一个值的元组 t5 = (1, ) print(t5) # 元组取值 t7 = (5, 3, 2, 1, 6) print(t7[0]) print(t7[-1])
# 不可改变: 但一个列表需要对其进行限制，让其无法发生改变，可以将其转化为元组 list1 = [1, 2, 3] tuple1 = tuple(list1) print(tuple1) # (1, 2, 3) # 如果重新想更改，可以转化回去 list2 = list(tuple1) print(list2) # [1, 2, 3] # 注：元组中存放了可变类型数据，可以发生形式上的值改变，本质值未发生改变 t1 = (1, 'abc', [10, 'xyz']) print(t1, id(t1)) >(1, 'abc', [10, 'xyz']) 41766776 # 成立：元组中列表值发生改变，列表自身id不变，所以元组中的中未发生改变 t1[2][1] = 'XYZ' print(t1, id(t1)) >(1, 'abc', [10, 'XYZ']) 41766776
总结： 1. 可以存放多个值：t = (1, 2, 3) 2. 为不可变类型 3. 有序存储：按索引取值
练习：
#简单购物车,要求如下： # 实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入 msg_dic={ 'appale':10, 'tesla':100000, 'mac':3000, 'lenovo':30000, 'chicken':10, } shop_cart=[] while True: for item, value in msg_dic.items(): print(item, value) #print('name:{name} price:{price}'.format(price=item,name=key)) product_name = input('please input product name:').strip() if not product_name or product_name not in msg_dic:continue count = input('please input amount:').strip() if not count.isdigit():continue shop_cart.append((product_name,msg_dic[product_name],count)) print(shop_cart) #break
- 七、字典
# 一、声明 dic1 = {'name': 'Owen', 'age': 18} dic1 = {'name': None, 'age': None} print(dic1) >{'name': None, 'age': None} dic2 = dict([('name', 'Egon'), ('age', 58)]) print(dic2) >{'name': 'Egon', 'age': 58} dic3 = dict(name='Zero', age=18) print(dic3) >{'name': 'Zero', 'age': 18} dic4 = {}.fromkeys(['name', 'age'], None) print(dic4) >{'name': None, 'age': None} # 二、get：有默认值的取值 dic = {'name': 'Owen', 'age': 18} print(dic.get('name', "该key不存在")) # 存在就会打印实际的值 >Owen print(dic.get('name123', "该key不存在")) # 不存在，未规定默认值，打印None，规定就打印规定的默认值 >该key不存在 # 三、字典的key可以为唯一不可变类型，value可以为任意类型 # 原因：字典的key是取值的唯一途径，所以一定要保证唯一性(一旦确定值，就不会再更改) d1 = {}.fromkeys([1, 3.14, (1,), '123', True], None) print(d1) >{1: None, 3.14: None, (1,): None, '123': None} # 四、增删改查 dic = {'name': 'Hou', 'age': 3} print(dic) # 增 dic['gender'] = '哇塞' print(dic) # 删 del dic['age'] print(dic) # 改 dic['name'] = 'DaHou' print(dic) # 查 print(dic['name'])
#字典的循环
# 多值更新 dic = {'name': 'Engo', 'salary': 100} dic.update({'name': "Egon", 'age': 58, 'gender': '未知'}) print(dic) # 类列表类型，不能直接通过index取值，但可以被for循环迭代取值 print(dic.keys()) print(dic.values()) print(dic.items()) for k in dic.keys(): print(k, ":", dic[k]) print('------------------------------------') for v in dic.values(): print(v) print('------------------------------------') for k, v in dic.items(): # ***** print(k, v) a, b, c = [1, 2, 3] print(c) a, b, _ = (1, 2, 3) print(a) # 嵌套: JSON dic = { 'students': [ { 'name': 'Bob', 'id': 1, 'gender': '男' }, { 'name': 'Tom', 'id': 2, 'gender': '女' } ], 'teachers': [] } stus = dic['students'] # list tom_stu = stus[1] # dic name = tom_stu['name'] print(name) print(dic['students'][1]['name']) print('======================') for k, v in dic.items(): # 只遍历学生 if k == 'students': for stu in v: for s_k, s_v in stu.items(): print(s_k, ":", s_v) print('--------------') if k == 'teachers': pass
# 总结： # 1. 字典可以存放多个值 # 2. 字典为可变类型 # 3. 字典是无序存储，用key进行取值
练习1
# 1 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中 # 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值} a={'k1':[],'k2':[]} c=[11,22,33,44,55,66,77,88,99,90] for i in c: if i>66: a['k1'].append(i) else: a['k2'].append(i) print(a)
# 2 统计s='hello alex alex say hello sb sb'中每个单词的个数 #结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2} s='hello alex alex say hello sb sb' s1 = s.split() dic = {} for i in s1: if i in dic: dic[i] += 1 else: dic[i]=1 print(dic)
s='hello alex alex say hello sb sb' dic={} words=s.split() print(words) for word in words: #word='alex' dic[word]=s.count(word) print(dic) #利用setdefault解决重复赋值 ''' setdefault的功能 1：key存在，则不赋值，key不存在则设置默认值 2：key存在，返回的是key对应的已有的值，key不存在，返回的则是要设置的默认值 d={} print(d.setdefault('a',1)) #返回1 d={'a':2222} print(d.setdefault('a',1)) #返回2222 ''' s='hello alex alex say hello sb sb' dic={} words=s.split() for word in words: #word='alex' dic.setdefault(word,s.count(word)) print(dic) #利用集合，去掉重复，减少循环次数 s='hello alex alex say hello sb sb' dic={} words=s.split() words_set=set(words) for word in words_set: dic[word]=s.count(word) print(dic) 其他做法（重点看setdefault的用法）
- 八、集合
#作用：去重，关系运算， #定义： 知识点回顾 可变类型是不可hash类型 不可变类型是可hash类型 #定义集合: 集合：可以包含多个元素，用逗号分割， 集合的元素遵循三个原则： 1：每个元素必须是不可变类型(可hash，可作为字典的key) 2:没有重复的元素 3：无序 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值 #优先掌握的操作： #1、长度len #2、成员运算in和not in #3、|合集 #4、&交集 #5、-差集 #6、^对称差集 #7、== #8、父集：>,>= #9、子集：<,<=
# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'} linuxs={'wupeiqi','oldboy','gangdan'} # 求出即报名python又报名linux课程的学员名字集合 print(pythons & linuxs) # 求出所有报名的学生名字集合 print(pythons | linuxs) # 求出只报名python课程的学员名字 print(pythons - linuxs) # 求出没有同时这两门课程的学员名字集合 print(pythons ^ linuxs)
作业
#作业一: 三级菜单 #要求: 打印省、市、县三级菜单 可返回上一级 可随时退出程序
menue = { '湖北省':{ '黄冈市':{ '罗田县':{ '大别山':'板栗', '薄刀峰':'风景区', '錾字石村':'柿子', }, '錾字石':{ '杨梅冲':'渡桥', '夏家铺':'水库', '雷家塆':'道观', }, }, '黄梅':{}, '黄石':{}, }, '上海市':{ '徐汇区':{ '徐家汇':{ '徐家汇': '美罗城', '漕河泾': '开发区', '华山路': '交通大学', }, '浦东区':{ '陆家嘴':'金融区', '淮海中路':'酒吧', '人民广场':'南京东路步行街', }, }, }, '山东省':{ '青岛市':{ '崂山区':{ '风景':'崂山风景区', '道观':'崂山太清宫', '海边':'海边浴场', }, }, }, } tag = True while tag: for key in menue: print(key) choice = input("请输入省份,退出输入q>>").strip() if choice == "q": break if not choice or choice not in menue:continue #二级菜单 while tag: menue2 = menue[choice] for key2 in menue2: print(key2) choice_2 = input("请输入市,退出输入q,返回上级菜单输入b>>").strip() if choice_2 == "b": # print("返回上一层") break if choice_2 == "q": tag = False #continue if choice_2 not in menue2:continue #三级菜单 while tag: menue3 =menue2[choice_2] for key3 in menue3: print(key3) choice_3 = input("请输入县,退出输入q,返回上级菜单输入b>>").strip() if choice_3 == "b": # print("返回上一层") break if choice_3 == "q": tag = False if not choice_3 or choice_3 not in menue3:continue #四级详细菜单 while tag: menue4 = menue3[choice_3] for key4,value in menue4.items(): print(key4,value) choice_4 = input("请看列出风景,退出输入q,返回上级菜单输入b>>").strip() if choice_4 == "b": break if choice_4 == "q": tag = False if not choice_4 or choice_4 not in menue4: continue
# 作业一优化答案
#part1（初步实现）：能够一层一层进入 layers = [menue, ] while True: current_layer = layers[-1] for key in current_layer: print(key) choice = input('>>: ').strip() if choice not in current_layer: continue layers.append(current_layer[choice])
#part2（改进）：加上退出机制 layers=[menue,] while True: if len(layers) == 0: break current_layer=layers[-1] for key in current_layer: print(key) choice=input('>>: ').strip() if choice == 'b': layers.pop(-1) continue if choice == 'q':break if choice not in current_layer:continue layers.append(current_layer[choice])
- 九、数据类型总结
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改
按存值个数区分：
| 标量／原子类型 | 数字，字符串 |
| 容器类型 | 列表，元组，字典 |
按可变不可变区分：
| 可变 | 列表，字典 |
| 不可变 | 数字，字符串，元组 |
按访问顺序区分：
| 直接访问 | 数字 |
| 顺序访问（序列类型） | 字符串，列表，元组 |
| key值访问（映射类型） | 字典 |
# 1.统计元组中所有数据属于字符串串的个数，提示：isinstance() # 数据：t1 = (1, 2, '3', '4', 5, '6') # 结果：3 # 2.将以下数据存储为字典类型 # 数据：info = "name:Owen|age:18|gender:男" # 结果：{'name': 'Owen', 'age': 18, 'gender': '男'} # 注：年年龄存储为数字类型 # 3.完成数据的去重 # 数据：t3 = (1, 2, 1, 2, 3, 5, 9) # 结果：t3 = (1, 2, 3, 5, 9) # 注：从不不考虑顺序、考虑顺序两⽅方⾯面完成 # 4.计算元组中所有可以转换为数字的数据的总和 # 数据：t4 = (10, 'abc', '100', '3') # 运算结果：113 # 5.将数据转换类型存储 # 原数据：dic = {'name': 'Owen', 'age': 18, 'gender': '男'} # 处理理后：info = [('name', 'Owen'), ('age', 18), ('gender', '男')] # 拓拓展：选做 # 1.计算元组中所有可以转换为数字的数据的总和 # 数据：t4 = (10, 'abc', '100', '3', '壹', '肆', [1000], (10000,)) # 运算结果：11118 # 提示： # -- 利利⽤用字符串串isnumeric()判断汉字 # -- 利利⽤用字典{'壹': 1 ...}将汉字转换为数字 # -- 利利⽤用isinstance()将list和tuple中数据取出来 # -- 先将所有转化为数字的数据存放在⼀一个单列列集合中，在做运算 # 2.完成录⼊入电话本 # 需求： ''' -- 从键盘中录⼊入姓名(不不区分⼤大⼩小写)： -- 姓名必须是全英⽂文组成，不不是则重新录⼊入姓名，如果是q，代表退出 -- 从键盘中再录⼊入电话： -- 电话必须为数字且⻓长度必须是11位(不不能转换为数字) -- 如果出现姓名相同，则保留留最后⼀一次电话号码 -- 形成的数据是有电话分组的，如：第⼀一次录⼊入Owen，13355667788，则会形成 -- { 'O': { 'Owen': '13355667788' } } 最终数据，分组名⼀一定⼤大写： { 'E': { 'egon': '17788990000', 'engo': '16633445566' }, 'O': { 'Owen': '13355667788' } }
# 作业3： #需求: 用户名和密码存放于文件中，格式为：egon|egon123 启动程序后，先登录，登录成功则让用户输入工资,然后打印商品列表，失败则重新登录，超过三次则退出程序 允许用户根据商品编号购买商品 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒 可随时退出，退出时，打印已购买商品和余额
