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('
')
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'}]