python字典键值可以是元组吗_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))#

t= tuple(1) #报错，内部基于for循环，必须传容器类型

print(type(t))#定义元组时如果只有一个元素，也得加上 , 逗号 不然会被python 解释成 其他类型

t = (1)print(type(t))#

t= (1, )print(type(t))#

t= ('a')print(type(t))#

t= ('a', )print(type(t))#

验证是否可变类型  --->不可变类型

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 int)print(3 not int)print(13 int)print(13 not int)#True#False#False#True

作为循环的迭代器对象 for in

#作为循环的迭代器对象 for in

t = (1, 3, 5, 8, 10)for i int: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'))##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): '到底行不行呢？'}# # 没错，它也是一个合法的字典类型

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] =vprint(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' ind3)print('password' ind3)#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 ind1.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 ind1.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 ind1.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))#

#尝试定义空集合

s = {} #如果仅仅只写了 {} .那么python 会默认把它当成字典类型

print(type(s))#

#定义空集合 只能用关键字 set

s =set()print(type(s))#

#定义空元组 就是本身的元组

t =()print(type(t))#

#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 inpythons:if name inlinux: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}delmy_set#print(my_set) # 直接报错，引用被删除了

补充知识点

enumerate() ： #enumerate枚举：给可迭代对象(列表、字典)等类型添加序号

good_list =[

['mac', 555],

['apple', 333]

]for index, good inenumerate(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 inraw_infos:

key, value= raw_info.split('：')

dic[key]=valueprint(dic)for key, value indic.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 ins: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=0whileTrue:print("欢迎光临 online 商城".center(40, '-'))print("本店商品信息如下，欢迎抢购".center(35, '-'))for key, value inmsg_dic.items():print(f"商品：{key}， 单价：{value}".ljust(40, '-'))print(''.center(46, '-'))

shop_name= ""shop_count= ""shop_name= input("请输入您要购买的商品>>>：")#判断商品是否存在

if shop_name.strip().lower() not inmsg_dic:#输入有误要求重新输入

print("您输入商品不存在或输入非法，请重新输入")#输入的商品在商品列表中

else:#在购物车就更新数量，不在就加入

shop_count = input("请输入您要购买商品数量>>>：")if notshop_count.strip().isdigit():#暂时是重新输入商品 + 数量， 应该是只需要重新输入数量就行了

print("您的输入有误，请重新输入！")continue

#上面的if 已经确定 输入的是数字了，现在给他转成数字方便运算

shop_count =int(shop_count)#输入完毕将商品加入购物车(商品名、价格和个数)

is_in_car=False#判断这个商品在不在购物车里

for shop_info inshop_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 notis_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 inshop_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 ins_list:if word ins_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 inl:if l2.count(i) ==0:

l2.append(i)print(l2)#['a', 'b', 1]

#方式二，通过成员方法 in / not in

l2 =[]for dic inl:if dic not inl2:

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 inl: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'}]

实现代码