集合与编码

# 1、作用
# 1.1 关系运算
# friends1 = ["zero","kevin","jason","egon"]
# friends2 = ["Jy","ricky","jason","egon"]
#
# l=[]
# for x in friends1:
#     if x in friends2:
#         l.append(x)
# print(l)


# 1.2、去重


# 2、定义: 在{}内用逗号分隔开多个元素，多个元素满足以下三个条件
#            1. 集合内元素必须为不可变类型
#            2. 集合内元素无序
#            3. 集合内元素没有重复

# s={1,2} # s=set({1,2})

# s={1,[1,2]} # 集合内元素必须为不可变类型
# s={1,'a','z','b',4,7} # 集合内元素无序
# s={1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
# print(s)

# 了解
# s={} # 默认是空字典
# print(type(s))
# 定义空集合
# s=set()
# print(s,type(s))

# 3、类型转换
# set({1,2,3})
# res=set('hellolllll')
# print(res)

# print(set([1,1,1,1,1,1]))
# print(set([1,1,1,1,1,1,[11,222]]) # 报错

# print(set({'k1':1,'k2':2}))

# 4、内置方法
# =========================关系运算符=========================
friends1 = {"zero","kevin","jason","egon"}
friends2 = {"Jy","ricky","jason","egon"}

# 4.1 取交集：两者共同的好友
# res=friends1 & friends2
# print(res)
# print(friends1.intersection(friends2))
# 4.2 取并集/合集：两者所有的好友
# print(friends1 | friends2)
# print(friends1.union(friends2))

# 4.3 取差集：取friends1独有的好友
# print(friends1 - friends2)
# print(friends1.difference(friends2))

# 取friends2独有的好友
# print(friends2 - friends1)
# print(friends2.difference(friends1))

# 4.4 对称差集: 求两个用户独有的好友们（即去掉共有的好友）
# print(friends1 ^ friends2)
# print(friends1.symmetric_difference(friends2))

# 4.5 父子集：包含的关系
# s1={1,2,3}
# s2={1,2,4}
# 不存在包含关系，下面比较均为False
# print(s1 > s2)
# print(s1 < s2)

# s1={1,2,3}
# s2={1,2}
# print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2他爹
# print(s1.issuperset(s2))
# print(s2.issubset(s1)) # s2 < s2  =>True

# s1={1,2,3}
# s2={1,2,3}
# print(s1 == s2) # s1与s2互为父子
# print(s1.issuperset(s2))
# print(s2.issuperset(s1))


# =========================去重=========================
# 1、只能针对不可变类型去重
# print(set([1,1,1,1,2]))

# 2、无法保证原来的顺序
# l=[1,'a','b','z',1,1,1,2]
# l=list(set(l))
# print(l)


l=[
    {'name':'lili','age':18,'sex':'male'},
    {'name':'jack','age':73,'sex':'male'},
    {'name':'tom','age':20,'sex':'female'},
    {'name':'lili','age':18,'sex':'male'},
    {'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic)

# print(new_l)

# 其他操作
'''
# 1.长度
>>> s={'a','b','c'}
>>> len(s)
3

# 2.成员运算
>>> 'c' in s
True

# 3.循环
>>> for item in s:
...     print(item)
... 
c
a
b
'''

# 其他内置方法
s={1,2,3}
# 需要掌握的内置方法1：discard
# s.discard(4) # 删除元素不存在do nothing
# print(s)
# s.remove(4) # 删除元素不存在则报错


# 需要掌握的内置方法2：update
# s.update({1,3,5})
# print(s)

# 需要掌握的内置方法3：pop
# res=s.pop()
# print(res)

# 需要掌握的内置方法4：add
# s.add(4)
# print(s)



# 其余方法全为了解
res=s.isdisjoint({3,4,5,6}) # 两个集合完全独立、没有共同部分，返回True
print(res)

# 了解
# s.difference_update({3,4,5}) # s=s.difference({3,4,5})
# print(s)

# 1、有列表['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
name, age, birth = ['alex', 49, [1900, 3, 18]]
year, month, day = birth

# 2、用列表的insert与pop方法模拟队列
list1 = []
list1.insert(0, 1)
list1.insert(1, 2)
list1.insert(2, 3)
list1.insert(3, 4)
print(list1)
for line in range(len(list1)):
    list1.pop(0)

print(list1)

# 3. 用列表的insert与pop方法模拟堆栈
list2 = []
list2.insert(0, 1)
list2.insert(1, 2)
list2.insert(2, 3)
list2.insert(3, 4)
print(list2)
for line in range(len(list2)):
    list2.pop()

print(list2)

# 4、简单购物车,要求如下：
# 实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，
# 购买个数以三元组形式加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　
msg_dic = {
    'apple': 10,
    'tesla': 100000,
    'mac': 3000,
    'lenovo': 30000,
    'chicken': 10,
}
good_list = []

while True:
    good_name = input('请输入购买的商品名称: ').strip()

    if good_name not in msg_dic:
        print("没有该商品")
        continue

    good_count = input('请输入商品数量: ').strip()

    if good_count.isdigit():

        good_count = int(good_count)

        good_price = msg_dic.get(good_name)

        good_tuple = (good_name, good_price, good_count)

        good_list.append(good_tuple)

    else:
        print('请输入数字')

    print('商品菜单: ', good_list)

# 5、有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，
# 将所有大于 66 的值保存至字典的第一个key中，
# 将小于 66 的值保存至第二个key的值中
# 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
list1 = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dict1 = {'k1': [], 'k2': []}

for number in list1:
    if number > 66:
        dict1['k1'].append(number)

    else:
        dict1['k2'].append(number)

print(dict1)

# 6、统计s='hello alex alex say hello sb sb'中每个单词的个数
s = 'hello alex alex say hello sb sb'
s_list = s.split(' ')
count_dic = {}

for i in s_list:
    if i not in count_dic:
        count_dic.update({i: 1})

    else:
        count = count_dic.get(i)
        count_dic.update({i: count + 1})

print(count_dic)

考试15分钟：
1、用列表模拟队列的入队与出队操作,FIFO
2、用列表模拟堆栈的入队与出队操作,LIFO
3、有列表l=['egon','alex_sb','lxx']从列表中取走/剪切走傻逼，并赋值给新变量
res=l.pop(1)
4、什么是元组？它用在何处
5、元组不可变指的是元组内的什么不可改变
6、t=(1,2,['AA']) # 针对改元组能够把'aa'改成'AA'，这与元组不可变是否冲突
7、在我无法确定key是否存在的情况下，如何从字典中取值才能保持程序不会出错
>>> res=d.get('name',None)
>>> print(res)
None
8、列表能否通过不存在索引增加元素，字典能否通过不存在key增加元素，
9、简述python3中dict.keys()、dict.values()、dict.items()包含的内容及
与python2的区别
10、用代码分别示范：for循环遍历我们所学过的所有可遍历的类型

上节课复习：
一：列表类型
list(可以被for循环遍历的类型)
#优先掌握的操作：
#1、按索引存取值(正向存取+反向存取)：即可改也可以取
l=[111,222]
# 超过索引范围就会报错
l[2]
l[2]=333

#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in

#5、追加
#6、删除
#7、循环
for x,y,z in ['abc','def','hba']: # x,y,z=1
...

for x,y,z in [('a',1,2),'def',['bbb',12,3]]: # x,y,z=('a',1,2)
...

二：元组类型
tuple()
如果元组中只有一个元素,记住加逗号:t=(1,)
#优先掌握的操作：
#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
#3、长度
#4、成员运算in和not in

#5、循环

三：字典类型
注意：字典key必须是不可变的，而且不能重复

dict(x=1,y=2,z=3)
dict([('k1',1),('k2',2)])
{}.fromkeys(['k1','k2'],None)

#优先掌握的操作：
#1、按key存取值：可存可取
d={'k1':1}
d['k2']=2
#2、长度len
#3、成员运算in和not in

#4、删除
#5、键keys()，值values()，键值对items() # [('k1',111)]
for
list(dic.keys())
tuple(dic.values())

#6、循环

今日内容：
1、集合类型
关系运算
去重（有局限性）

2、总结与分类
有序or无序：有序又称之为序列类型

存一个值or多个值：存一个值称为原子类型，存多个值称为容器类型

可变or不可变

3、字符编码（理论多，结论少）
文本文件
x='上'

4、文件处理基本基础