python元组-字典-集合及其内置方法（下）
列表补充
补充方法
清空列表 clear
# clear 清空列表 l = [1, 2, 3, 4, 4] print(l.clear()) # clear没有返回值（None） print(l) # None # []
统计列表中指定元素出现的次数 count
# count 统计一个元素在列表中出现了几次 l = [1, 2, 3, 4, 4] print(l.count(4)) # 2
列表反向、排序 reverse sort（带参数，可指定按正序/ 反序排）
# reverse 将列表翻转 l = [1, 2, 3, 4, 4, 2] print(l.reverse()) # reverse没有返回值（None） print(l) # None # [2, 4, 4, 3, 2, 1] # sort 排序，默认从小到大排序 l = [1, 2, 3, 4, 4, 2] print(l.sort()) # sort没有返回值（None） print(l) # None # [1, 2, 2, 3, 4, 4] l = [1, 2, 3, 4, 4, 2] print(l.sort(reverse=True)) # sort可以指定参数来确定排序规则 print(l) # None # [4, 4, 3, 2, 2, 1] l = list('dasb41564s5.*/-^&#$84') print(l.sort()) # sort方法排序字符时按ASCII码排序 print(l) # None # ['#', '$', '&', '*', '-', '.', '/', '1', '4', '4', '4', '5', '5', '6', '8', '^', 'a', 'b', 'd', 's', 's']
总结
# ------- 列表总结 --------- # 能存多个值 # 有序的 # 可变类型
# 队列:先进先出 (排队)
# 堆栈:先进后出 (叠书、叠衣服 拿出来)
元组
简介
# 作用：能存储多个元素 # 定义：与列表一致，只不过把 [] 变成了 () # 特点： # 能存多个值 # 有序（能用索引取值） # 不可变：不可以修改元素的值，不可以增加元素个数，删除元素个数 # 只能看不能改的场景，推荐用元组 # 存相同的数据，元组比列表占用的资源会更少（列表多出来的那堆方法也会占很多空间）
内置方法
定义元组
t = (1, 2, 3, 4) # tuple((1, 2, 3, 4)) print(type(t)) # <class 'tuple'> t = tuple(1) # 报错，内部基于for循环，必须传容器类型 print(type(t)) # 定义元组时如果只有一个元素，也得加上 , 逗号 不然会被python 解释成 其他类型 t = (1) print(type(t)) # <class 'int'> t = (1, ) print(type(t)) # <class 'tuple'> t = ('a') print(type(t)) # <class 'str'> t = ('a', ) print(type(t)) # <class 'tuple'>
验证是否可变类型 --->不可变类型
t2 = (1, 2, 3, [1, 2, 3]) print(id(t2)) # 2270010972424 t2[3][0] = 666666 print(t2) print(id(t2)) # (1, 2, 3, [666666, 2, 3]) # 注意这里改的是元组内部的列表的值，不是在改动元组（元组的第四个元素（索引为3），存的是个内存地址） # 2270010972424 # ---> 内存地址不变，所以他是不可变类型
索引取值
# 索引取值 可取不可改 t = (2, 3, 4) print(t[0]) # t[0] = 4 # 会直接报错，TypeError: 'tuple' object does not support item assignment 元组的元素不可以改（如果元素是可变类型，那么可以改） t = (2, 3, 4, [5, 6, 7]) t[3][0] = '我改了' # 不报错，因为改的是列表（具体看原理图（内存指向，实际元组没有改动）） print(t) # (2, 3, 4, ['我改了', 6, 7])
切片
# 切片 与列表字符串的用法一致，这里就不过多举例了 t = (1, 3, 5, 8, 10) print(t[-1:-5:-1]) # (10, 8, 5, 3)
元组中的元素个数 len
# 元组中的元素个数 len t = (1, 3, 5, 8, 10) print(len(t)) # 5
成员运算 in / not in
# 成员运算 in / not in t = (1, 3, 5, 8, 10) print(3 in t) print(3 not in t) print(13 in t) print(13 not in t) # True # False # False # True
作为循环的迭代器对象 for in
# 作为循环的迭代器对象 for in t = (1, 3, 5, 8, 10) for i in t: print(i, end=' ') # 1 3 5 8 10
统计某个元素在元组中出现的次数 count
# count 统计某个元素在元组中出现的次数 t = ('hello', 'thank', 'you', 1, 1.1, ['hello', 3, 'thank'], 'thank', 'you', 'very', 'much') print(type(t)) print(t.count('hello')) # 元素内部不管，只管第一层 print(t.count('thank')) # <class 'tuple'> # 1 # 2
获取元素的索引 index （找不到会报错）
# index 获取元素的索引（试试字符串类型的？） print(t.index('thank')) # 1 # print(t.index('your')) # 找不到值会报错 ValueError: tuple.index(x): x not in tuple # 可以用count 判断在不在里面(为0 则不在里面，为其他值则在)，再用index 找该元素的索引
字典
简介
# 能存储多组 key: value 这样的键值对，可存可取 # key是对value的描述，并且key 通常情况下都是字符串，其实这个key 只能是不可变类型，value可以是任意数据类型 # 字典的key 是唯一性标识，同一个字典中key 不能重复 # 如果重复了，只会按照最后一组键值对存储（即覆盖了前一组同名的 key） #
# 字典是无序的，它是按 key 取值，不是索引 # 字典是可变类型：键值对发生改变，字典的内存地址不会改变
# 数字类型（int、float），字符串，元组 都可以作为字典的 key
内置函数
定义字典
d = {'name': 'jason', 'password': 123} # d = dict({'name': 'jason', 'password': 123})
d1 = {1: '1', 0: '0', 1.1: '1.1', 'string': 'string', (1, 2): '到底行不行呢？'}
print(d1)
print(type(d1))
# {1: '1', 0: '0', 1.1: '1.1', 'string': 'string', (1, 2): '到底行不行呢？'}
# <class 'dict'> # 没错，它也是一个合法的字典类型
print(d1[1])
print(d1[1.1])
print(d1['string'])
print(d1[(1, 2)])
# 1
# 1.1
# string
# 到底行不行呢？
# 定义字典的三种方式
# 1 直接定义
d1 = {'name': 'jason', 'password': '123'}
# 2 ----> 通过关键字传参来定义 ***重点掌握（后期面向对象的时候好用）***
d2 = dict(name='jason', password=123, age=18)
# 3 直接dict 类型转换
l = [
['name', 'jason'],
['age', 18],
['hobby', 'read']
]
# 简便写法
d3 = {}
d3 = dict(l)
print(d3)
# {'name': 'jason', 'age': 18, 'hobby': 'read'}
# 上面写法的原理
d3 = {}
for k, v in l: # ['name', 'jason'],['age', 18]....
# 这里的 k,v 利用了解压赋值
d3[k] = v
print(d3)
# {'name': 'jason', 'age': 18, 'hobby': 'read'}
创建字典的其他方式 fromkeys (不怎么好用)
# fromkeys() 用来创造字典 d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.fromkeys('name')) # {'n': None, 'a': None, 'm': None, 'e': None} # 扩展用法 l = ['name', 'password', 'age', 'hobby'] dic = {} print(dic.fromkeys(l, 123)) # 快速创建字典，后续再去更改 # {'name': 123, 'password': 123, 'age': 123, 'hobby': 123} dic = {} l = ['name', 'password', 'age', 'hobby'] l2 = ["swb", 18, ["study", "cooking"]] print(dic.fromkeys(l, l2)) print(dic) # {'name': ['swb', 18, ['study', 'cooking']], 'password': ['swb', 18, ['study', 'cooking']], 'age': ['swb', 18, ['study', 'cooking']], 'hobby': ['swb', 18, ['study', 'cooking']]} # {}
给字典中的指定键值对指定默认值 setdefault
# setdefault() d1 = {'name': 'jaoon', 'password': '123'} print(d1.setdefault('name', 'xxoo')) # 当键存在的情况下会返回该键的值，并且不会改变该键的值 print(d1) print(d1.setdefault('age', 18)) # 当键不存在的情况下会给字典添加一个键值对（两个参数），并且会把新增的键值对的值返回 print(d1) # jaoon # {'name': 'jaoon', 'password': '123'} # 18 # {'name': 'jaoon', 'password': '123', 'age': 18}
更新字典的值：1.字典的 update 方法，2.直接通过 不存在的key 赋值的方式添加键值对（具体看下方例子）
# 1.update() # 1.1 d1 = {'name': 'jaoon', 'password': '123'} d2 = {'age': 18} print(d1.update(d2)) print(d1) # None # {'name': 'jaoon', 'password': '123', 'age': 18} # 1.2 d1 = {'name': 'jaoon', 'password': '123'} print(d1.update(age=18)) print(d1) # None # {'name': 'jaoon', 'password': '123', 'age': 18} # 2 推荐直接这样写 -----------> !!!! 上面写法太麻烦，不如这个好用 d1 = {'name': 'jaoon', 'password': '123'} print(d1) d1['age'] = 18 print(d1) # {'name': 'jaoon', 'password': '123'} # {'name': 'jaoon', 'password': '123', 'age': 18}
获取字符串中键值对个数 len
dit2 = {'name': 'egon', 'name': 'jason', 'name': 'alex', 'age': 18}
print(dit2)
print(len(dit2))
# {'name': 'alex', 'age': 18} # 重复的键会覆盖前面的键
# 2
成员运算 in / not in （只能取到key 值）
# 成员运算 in/ not in 字典在for循环只暴露出 key， value无法取到，不能做成员运算 d3 = {'name': 'jaoon', 'password': '123'} print('123' in d3) print('password' in d3) # False # True
按key 取值 （类似列表中的索引取值 ---> 字典是无序的，字典中没有索引取值）
# 按key 存取值：可存可取 d3 = {'name': 'jaoon', 'password': '123'} print(id(d3)) # 2364215340992 print(d3['name']) # jaoon d3['name'] = 'egon' # 改的是指向，不是索引， 字典是无序的， key 重复了是替换的意思 d3['age'] = 18 # 赋值语句当key 不存在的情况下，会自动新增一个键值对 print(d3, id(d3)) # {'name': 'egon', 'password': '123', 'age': 18} 2364215340992
取值的其他方法 keys values items get
# 获取字典value的方法 ----》 keys values items 在 python2.x 产生的是列表，而 python3.x 是生成器对象 # 1. 粗暴的循环获取（通过key ） # 字典的 keys() values() items() 方法在 python 2.x 和 3.x 中有区别，像老母猪 # 2. keys() d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.keys()) # dict_keys(['name', 'password', 'sex', 'salary']) ，像老母猪 for k in d1.keys(): print(k) # name # password # sex # salary # 3. values() 与上面类似 d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.values()) # dict_values(['jaoon', '123', 'gender', 16000]) for i in d1.values(): print(i) # jaoon # 123 # gender # 16000 # 4. items() 列表套元组，元组的第一个元素是字典的key ， 第二个元素是字典的value d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.items()) # dict_items([('name', 'jaoon'), ('password', '123'), ('sex', 'gender'), ('salary', 16000)]) for i in d1.items(): print(i) # ('name', 'jaoon') # ('password', '123') # ('sex', 'gender') # ('salary', 16000) # 作为迭代器对象循环取值 # for i in ... # get() 根据key 获取 value， 可以传第二个参数，当传入的key 不存在，会返回（提示信息）该参数， 存在则会返回该key 对应的值， 第二个参数不写的话，key 不存在会返回None ,如果存在则会返回该key 对应的value # 推荐字典取值统一用 get ********** d1 = {'name': 'jaoon', 'password': '123', 'sex': 'gender', 'salary': 16000} print(d1.get('name')) # jaoon print(d1.get('hahah')) # 当key 不存在时不会报错，返回None， 用 []取不存在的会直接报错 # None print(d1.get('name', '你给我的name 不在字典的key 中')) print(d1.get('hahah', '你给我的hahah 不在字典的key 中')) # jaoon # 你给我的hahah 不在字典的key 中
删除字典中的键值对或清空字典 del pop popitem clear
# 删除 # del d3 = {'name': 'jaoon', 'password': '123'} del d3['name'] print(d3) # {'password': '123'} # pop 传key， key 不存在会直接报错 d3 = {'name': 'jaoon', 'password': '123'} print(d3.pop('name')) # pop 返回的是value print(d3) # jaoon # {'password': '123'} # print(d3.pop('age')) # 当键不存在的时候，直接报错，KeyError: 'age' # popitem 不需要参数，弹出"最后"一个键值对（字典是无序的，不存在什么第几个、最后一个） d3 = {'name': 'jaoon', 'password': '123'} print(d3.popitem()) print(d3) # ('password', '123') # {'name': 'jaoon'} print(d3.popitem()) # ('name', 'jaoon') # print(d3.popitem()) # 会报错，弹空了 # clear 清空字典 d3 = {'name': 'jaoon', 'password': '123'} print(d3.clear()) print(d3) # None # {}
集合
简介
# 群体之间作比较，不涉及单个元素 --> 推荐用集合 （见关系图，整理到博客里去） # 作用： 做关系运算： 共同好友、共同粉丝 ---> 涉及到共同，两个群体之间作比较 # 去重，把重复元素剔除掉 # 可以定义多个元素，元素之间用逗号分隔 # 集合的元素必须遵循的三个原则 # 1：每个元素必须是不可变类型（元素值改变后，内存地址是否会随之改变） # 可变： 不可hash # 不可变： 可hash ''' d = {[1, 2]: 'name'} # 会报错，不可hash，并且元素之间 , 间隔 TypeError: unhashable type: 'list' s = {1, 2, 1.1, 'string', (1, 2)} print('-----------', s) # ----------- {(1, 2), 1, 2, 1.1, 'string'} ''' # 2：没有重复的元素 ''' s = {1, 2, 3, 3, 4, 3} # 自动将重复的元素去除 print(s) # {1, 2, 3, 4} 将其他类型去重成集合，再想办法转回去 l = ['jason', 'egon', 'jason'] s = set() print(s.update(l)) print(s) # None # {'egon', 'jason'} ''' # 3：无序 ''' s = {1, 2, 3, 4, 5} print(s[1]) # 会直接报错,集合不支持索引取值 TypeError: 'set' object does not support indexing '''
内置函数
定义集合
# 定义集合 (跟字典很像，但它内部不是键值对) s = {1, 2, 3} # s = set({1, 2, 3}) print(type(s)) # <class 'set'> # 尝试定义空集合 s = {} # 如果仅仅只写了 {} .那么python 会默认把它当成字典类型 print(type(s)) # <class 'dict'> # 定义空集合 只能用关键字 set s = set() print(type(s)) # <class 'set'> # 定义空元组 就是本身的元组 t = () print(type(t)) # <class 'tuple'> # print(set(1)) # 会报错，set也是迭代对象 TypeError: 'int' object is not iterable print(set((1,))) # {1}
向集合中添加元素 add
# 集合添加元素 # add s = {1, 2, 3, 4, 5} print(s.add(666)) print(s) print(s.add((1, 2, 3, 4))) print(s) # None # {1, 2, 3, 4, 5, 666} # None # {1, 2, 3, 4, 5, (1, 2, 3, 4), 666} # 集合是无序的
获取集合元素个数 len
# len 长度 s = {1, 2, 3, 4, 5} print(len(s)) # 5
集合在交集并集关系处理中的运用 & | ^ - < <= > >= == 以及他们的英语方法写法（后续补充一下）
# 交集并集等集合关系的运用 pythons = ['jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'] linux = ['frank', 'jerry', 'tank', 'egon', 'alex'] # 求既在python 又在linux 的同学 # 普通循环写法 for name in pythons: if name in linux: print(name) # tank # egon # alex pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'} linux = {'frank', 'jerry', 'tank', 'egon', 'alex'} # & 交集 # pythons 和 linux中都有的 print(pythons & linux) # {'tank', 'alex', 'egon'} # - 差集 ----------------- # 只在 pythons 中的 print(pythons - linux) # {'kevin', 'nick', 'jason', 'owen'} # 只在 linux 中的 print(linux - pythons) # {'frank', 'jerry'} # ^ 对称差集 # 没有同时在 pythons 和 linux 中的 print(pythons ^ linux) # {'kevin', 'nick', 'jerry', 'owen', 'jason', 'frank'} # | 合集 # pythons 和 linux 所有的元素（不重复） print(pythons | linux) # {'kevin', 'frank', 'alex', 'egon', 'jason', 'tank', 'jerry', 'nick', 'owen'} # == 判断两个集合是否相等 print(pythons == linux) # False # 父级子级 s = {1, 2, 3, 4} s2 = {2, 4} # > >= 是否包含 （父级） issuperset print(s >= s2) # True # < <= 是否被包含 （子级） issubset # 父级自己反过来一样的
删除集合中的元素 pop remove clear discard 通用del
# pop 会返回删除元素的值（集合是无序的---虽然看起来存进去的元素都是从小到大排序，但它不能索引取值，没有参数） my_set = {2, 15, 13, 1} print(my_set.pop()) print(my_set.pop()) print(my_set) # 1 # 2 # {13, 15} # remove 删除指定元素，没有返回值，指定元素若不存在会报错 my_set = {2, 15, 13, 1} print(my_set.remove(13)) print(my_set) # None # {1, 2, 15} # print(my_set.remove(22)) # 元素不存在，直接报错 # discard 删除指定元素，没有返回值，指定元素不存在不报错 my_set = {2, 15, 13, 1} print(my_set.discard(13)) print(my_set) print(my_set.discard(22)) print(my_set) # None # {1, 2, 15} # None # {1, 2, 15} # clear my_set = {2, 15, 13, 1} print(my_set) print(my_set.clear()) print(my_set) # {1, 2, 13, 15} # None # set() # del 通用删除大法 my_set = {2, 15, 13, 1} del my_set # print(my_set) # 直接报错，引用被删除了
补充知识点
enumerate() ： # enumerate枚举：给可迭代对象（列表、字典）等类型添加序号
good_list = [ ['mac', 555], ['apple', 333] ] for index, good in enumerate(good_list): print(index, good) # 0 ['mac', 555] # 1 ['apple', 333]
区分类型
# 必须分清楚下面这几种类型分别长啥样！！！别写混了 # 列表 list # [1, 2, 3, 4] # 元组 tuple # (1, 2, 3, 4) # 集合 set # {1, 2, 3, 4}
个人扩展案例及练习
# 处理省份之间突然有格式不对的东西（本来 、 隔开的，后来有些地方用 ， , 隔开） # 目标数据格式：{'市名': ['各个市'], '市名': ['各个市']} # 南充市：顺庆区、高坪区、嘉陵区、阆中市、南部县、营山县、蓬安县、仪陇县、西充县 # 宜宾市：翠屏区、宜宾县,南溪县、江安县、长宁县、高县、珙县、筠连县、兴文县、屏山县 # 广安市：广安区、华蓥市、岳池县、武胜县,邻水县
region_info = '''南充市：顺庆区、高坪区、嘉陵区、阆中市、南部县、营山县、蓬安县、仪陇县、西充县 宜宾市：翠屏区、宜宾县,南溪县、江安县、长宁县、高县、珙县、筠连县、兴文县、屏山县 广安市：广安区，华蓥市,岳池县、武胜县,邻水县''' print(region_info) raw_infos = region_info.split('\n') print(raw_infos) dic = {} for raw_info in raw_infos: key, value = raw_info.split('：') dic[key] = value print(dic) for key, value in dic.items(): r_value = value.replace('，', '、') target_value = r_value.replace(',', '、') print(target_value) item = target_value.split('、') dic[key] = item # 南充市：顺庆区、高坪区、嘉陵区、阆中市、南部县、营山县、蓬安县、仪陇县、西充县 # 宜宾市：翠屏区、宜宾县,南溪县、江安县、长宁县、高县、珙县、筠连县、兴文县、屏山县 # 广安市：广安区，华蓥市,岳池县、武胜县,邻水县 # ['南充市：顺庆区、高坪区、嘉陵区、阆中市、南部县、营山县、蓬安县、仪陇县、西充县', '宜宾市：翠屏区、宜宾县,南溪县、江安县、长宁县、高县、珙县、筠连县、兴文县、屏山县', '广安市：广安区，华蓥市,岳池县、武胜县,邻水县'] # {'南充市': '顺庆区、高坪区、嘉陵区、阆中市、南部县、营山县、蓬安县、仪陇县、西充县', '宜宾市': '翠屏区、宜宾县,南溪县、江安县、长宁县、高县、珙县、筠连县、兴文县、屏山县', '广安市': '广安区，华蓥市,岳池县、武胜县,邻水县'} # 顺庆区、高坪区、嘉陵区、阆中市、南部县、营山县、蓬安县、仪陇县、西充县 # 翠屏区、宜宾县、南溪县、江安县、长宁县、高县、珙县、筠连县、兴文县、屏山县 # 广安区、华蓥市、岳池县、武胜县、邻水县 print(dic) # {'南充市': ['顺庆区', '高坪区', '嘉陵区', '阆中市', '南部县', '营山县', '蓬安县', '仪陇县', '西充县'], '宜宾市': ['翠屏区', '宜宾县', '南溪县', '江安县', '长宁县', '高县', '珙县', '筠连县', '兴文县', '屏山县'], '广安市': ['广安区', '华蓥市', '岳池县', '武胜县', '邻水县']}
''' 1.有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值} 小提示:按照题意这里的k1和k2对应的value必须能存多个值 '''
s = {11, 22, 33, 44, 55, 66, 77, 88, 99, 90}
d = {'k1': [], 'k2': []}
for value in s:
if value >= 66:
d['k1'].append(value)
else:
d['k2'].append(value)
print(d)
# {'k1': [66, 99, 77, 88, 90], 'k2': [33, 11, 44, 22, 55]}
# 2.简单购物车,要求如下： # 实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入 # msg_dic={ # 'apple':10, # 'tesla':100000, # 'mac':3000, # 'lenovo':30000, # 'chicken':10, # } # 小提示:打印的时候即需要拿到字典的key也需要拿到对应的value
# 逻辑还是有点混乱（Q/ y 输错了直接就重新购买商品了。。。） msg_dic = { 'apple': 10, 'tesla': 100000, 'mac': 3000, 'lenovo': 30000, 'chicken': 10, } shop_name = "" shop_count = "" choice = "" shop_car = [] total_price = 0 while True: print("欢迎光临 online 商城".center(40, '-')) print("本店商品信息如下，欢迎抢购".center(35, '-')) for key, value in msg_dic.items(): print(f"商品：{key}， 单价：{value} ".ljust(40, '-')) print(''.center(46, '-')) shop_name = "" shop_count = "" shop_name = input("请输入您要购买的商品>>>：") # 判断商品是否存在 if shop_name.strip().lower() not in msg_dic: # 输入有误要求重新输入 print("您输入商品不存在或输入非法，请重新输入") # 输入的商品在商品列表中 else: # 在购物车就更新数量，不在就加入 shop_count = input("请输入您要购买商品数量>>>：") if not shop_count.strip().isdigit(): # 暂时是重新输入商品 + 数量， 应该是只需要重新输入数量就行了 print("您的输入有误，请重新输入！") continue # 上面的if 已经确定 输入的是数字了，现在给他转成数字方便运算 shop_count = int(shop_count) # 输入完毕将商品加入购物车（商品名、价格和个数） is_in_car = False # 判断这个商品在不在购物车里 for shop_info in shop_car: # 在，那就给他更新个数 if shop_info.get('shop_name') == shop_name: shop_info['shop_count'] += shop_count # print(shop_info.setdefault(shop_price, msg_dic.get(shop_name))) is_in_car = True # 不是购物车里的商品，那就添加到购物车 if not is_in_car: # print(shop_car) # 新增一个字典，给它的值设 # new_shop = dict() new_shop = dict(shop_name=shop_name, shop_count=shop_count, shop_price=msg_dic.get(shop_name)) # new_shop['shop_name'] = shop_name # new_shop['shop_count'] = shop_count # new_shop['shop_price'] = msg_dic.get(shop_name) # print(new_shop) # 可以打印出来，添加商品成功 shop_car.append(new_shop) # 同样的商品应该是数量累加 choice = input("商品已加入购物车，输入Q / E 查看购物车（退出程序）， 输入C / Y 继续购买>>>：").strip().lower() if choice in ['q', 'quit', 'e', 'exit']: # 输出购买信息 print('您的购物车信息如下：') # 循环输出购物车每个商品 print("购物车清单".center(40, '-')) for single_shop_info in shop_car: from_car_shop_name = single_shop_info.get('shop_name') from_car_shop_count = single_shop_info.get('shop_count') from_car_shop_price = single_shop_info.get('shop_price') # print(type(total_price), type(from_car_shop_count), type(from_car_shop_price)) total_price += int(from_car_shop_count) * int(from_car_shop_price) print(f"商品：{from_car_shop_name}，数量：{from_car_shop_count}，单价为：{from_car_shop_price}".center(40, ' ')) print("清单结束".center(40, '-')) print(f'共： {total_price} 元'.ljust(40, ' ')) break elif choice in ['c', 'continue', 'y', 'yes']: print(f"您输入的 {shop_name}: {shop_count} 已加入购物车~") # 已经加入购物车了
''' 3.统计s='hello alex alex say hello sb sb'中每个单词的个数 结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2} '''
s = 'hello alex alex say hello sb sb' s_list = s.split(' ') s_dict = {} for word in s_list: if word in s_dict.keys(): s_dict[word] += 1 else: s_dict[word] = 1 print(s_dict) # {'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
# 4.关系运算 # 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合 # pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'} # linuxs={'wupeiqi','oldboy','gangdan'} # 1. 求出即报名python又报名linux课程的学员名字集合 # 2. 求出所有报名的学生名字集合 # 3. 求出只报名python课程的学员名字 # 4. 求出没有同时这两门课程的学员名字集合
pythons = {'alex', 'egon', 'yuanhao', 'wupeiqi', 'gangdan', 'biubiu'}
linuxs = {'wupeiqi', 'oldboy', 'gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# {'wupeiqi', 'gangdan'}
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 'egon', 'wupeiqi', 'yuanhao', 'biubiu', 'gangdan', 'alex', 'oldboy'}
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# {'alex', 'biubiu', 'yuanhao', 'egon'}
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)
# {'biubiu', 'oldboy', 'alex', 'yuanhao', 'egon'}
''' 5. 对列表l=['a','b',1,'a','a']内的元素完成去重得到新列表. 拔高:如果想去重并且想保持列表原来的顺序该如何做? '''
# 1. 仅去重 l = ['a', 'b', 1, 'a', 'a'] l2 = list(set(l)) print(l2) # ['a', 1, 'b'] # 2.保持原来顺序的去重 # 方式一，通过 .count 方法 l = ['a', 'b', 1, 'a', 'a'] l2 = [] for i in l: if l2.count(i) == 0: l2.append(i) print(l2) # ['a', 'b', 1] # 方式二，通过成员方法 in / not in l2 = [] for dic in l: if dic not in l2: l2.append(dic) print(l2)
# 6.对如下列表中的元素去重()，得到新列表，且新列表一定要保持列表原来的顺序 # l=[ # {'name':'egon','age':18,'sex':'male'}, # {'name':'alex','age':73,'sex':'male'}, # {'name':'egon','age':20,'sex':'female'}, # {'name':'egon','age':18,'sex':'male'}, # {'name':'egon','age':18,'sex':'male'}, # ] # 小提示:去重不一定非要用集合
l = [ {'name': 'egon', 'age': 18, 'sex': 'male'}, {'name': 'alex', 'age': 73, 'sex': 'male'}, {'name': 'egon', 'age': 20, 'sex': 'female'}, {'name': 'egon', 'age': 18, 'sex': 'male'}, {'name': 'egon', 'age': 18, 'sex': 'male'}, ] l2 = [] for dic in l: if l2.count(dic) == 0: # if dic not in l2: # 方式二 l2.append(dic) print(l2) # [{'name': 'egon', 'age': 18, 'sex': 'male'}, {'name': 'alex', 'age': 73, 'sex': 'male'}, {'name': 'egon', 'age': 20, 'sex': 'female'}]
