python基础三（数据类型）

一 引子

1 什么是数据？

　　x=10，10是我们要存储的数据

2 为何数据要分不同的类型

　　数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

3 数据类型

　　数字（整形，长整形，浮点型，复数）

　　字符串

　　字节串：在介绍字符编码时介绍字节bytes类型

　　列表

　　元组

　　字典

　　集合

4 按照以下几个点展开数据类型的学习

#======================================基本使用======================================
#1、用途

#2、定义方式

#3、常用操作+内置的方法

#======================================该类型总结====================================
#存一个值or存多个值

#有序or无序

#可变or不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

二 数字

整型与浮点型

#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制

其他数字类型（了解）

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解，推荐视频：https://www.bilibili.com/video/av26786159）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0　　

三 字符串

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号\双引号\三引号内，由一串字符组成
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

# strip 默认移除空格
name = '*egon**'
print(name.strip('*'))    # 移除字符串两边的*     egon
print(name.lstrip('*'))   # 移除字符串左边的*     egon**
print(name.rstrip('*'))   # 移除字符串右边的*     *egon

# lower,upper 字母小写和大写
name = 'egon'
print(name.lower())  # 字符串字母小写 egon
print(name.upper())  # 字符串字母大写 EGON

# startswith,endswith   字符串判断是否以什么开头和结尾，返回结果布尔类型
name = 'alex_SB'
print(name.endswith('SB'))  # True
print(name.startswith('alex'))  # True

# format的三种玩法
res = '{} {} {}'.format('egon', 18, 'male')
res1 = '{1} {0} {1}'.format('egon', 18, 'male')
res2 = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res)
print(res1)
print(res2)

# split     以什么为切片，返回结果列表
name = 'root:x:0:0::/root:/bin/bash'
print(name.split(':'))  # 默认分隔符为空格 ['root', 'x', '0', '0', '', '/root', '/bin/bash']
name = 'C:/a/b/c/d.txt'  # 只想拿到顶级目录
print(name.split('/', 1))  # ['C:', 'a/b/c/d.txt']
print(name.split('/', 2))  # ['C:', 'a', 'b/c/d.txt']
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
print(name.replace('alex', 'SB', 3))    # SB say :i have one tesla,my name is SB

# isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法
age = input('>>: ')
print(age.isdigit())

其他操作（了解即可）

#1、find,rfind,index,rindex,count
#2、center,ljust,rjust,zfill
#3、expandtabs
#4、captalize,swapcase,title
#5、is数字系列
#6、is其他

# find,rfind,index,rindex,count
name = 'egon say hello'
print(name.find('o', 1, 3))  # 顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
# print(name.index('e',2,4)) #同上,但是找不到会报错
print(name.count('e', 1, 3))  # 顾头不顾尾,如果不指定范围则查找所有

# center,ljust,rjust,zfill
name = 'egon'
print(name.center(30, '-')) # -------------egon-------------
print(name.ljust(30, '*'))  # egon**************************
print(name.rjust(30, '*'))  # **************************egon
print(name.zfill(50))  # 用0填充   # 0000000000000000000000000000000000000000000000egon

# expandtabs
name = 'egon\thello'
print(name)  # egon    hello
print(name.expandtabs(1))  # egon hello

# captalize,swapcase,title
name = 'egon'
print(name.capitalize())  # 首字母大写 Egon
print(name.swapcase())  # 大小写翻转 EGON
msg = 'egon say hi'
print(msg.title())  # 每个单词的首字母大写 Egon Say Hi

# is数字系列
# 在python3中
num1 = b'4'  # bytes
num2 = u'4'  # unicode,python3中无需加u就是unicode
num3 = '四'  # 中文数字
num4 = 'Ⅳ'  # 罗马数字

# isdigt:bytes,unicode
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

# isdecimal:uncicode
# bytes类型无isdecimal方法
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

# isnumberic:unicode,中文数字,罗马数字
# bytes类型无isnumberic方法
print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True

# 三者不能判断浮点数
num5 = '4.3'
print(num5.isdigit())  # False
print(num5.isdecimal())  # False
print(num5.isnumeric())  # False
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''
# is其他
print('===>')
name = 'egon123'
print(name.isalnum())  # 字符串由字母或数字组成 True
print(name.isalpha())  # 字符串只由字母组成 False

print(name.isidentifier())  # True
print(name.islower())  # True
print(name.isupper())  # False
print(name.isspace())  # False
print(name.istitle())  # False

练习

name = " aleX"
# 1)    移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())
# 2)    判断 name 变量对应的值是否以 "al" 开头,并输出结果

print(name.startswith('al'))
# 3)    判断 name 变量对应的值是否以 "X" 结尾,并输出结果

print(name.endswith('X'))
# 4)    将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l', 'p'))
# 5)    将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split('l'))
# 6)    将 name 变量对应的值变大写,并输出结果

print(name.upper())
# 7)    将 name 变量对应的值变小写,并输出结果

print(name.lower())
# 8)    请输出 name 变量对应的值的第 2 个字符?
print(name[1])
# 9)    请输出 name 变量对应的值的前 3 个字符?
print(name[:3])
# 10)    请输出 name 变量对应的值的后 2 个字符?

print(name[-2:])
# 11)    请输出 name 变量对应的值中 “e” 所在索引位置?

print(name.find('e'))
# 12)    获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
a=name[:-1]
print(a)

四 列表

# 基本数据类型
# list
1、作用：按位置存放多个值
2、定义：在[]内,用逗号分隔开多个任意数据类型的值
# l1 = [1,'a',[1,2]]  # 本质:l1 = list([1,'a',[1,2]])

3、类型转换

# 但凡能被for循环遍历的数据类型都可以传给list()转换成列表类型，list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中
# >>> list('wdad') # 结果：['w', 'd', 'a', 'd']
# >>> list([1,2,3]) # 结果：[1, 2, 3]
# >>> list({"name":"jason","age":18}) #结果：['name', 'age']
# >>> list((1,2,3)) # 结果：[1, 2, 3]
# >>> list({1,2,3,4}) # 结果：[1, 2, 3, 4]

4、内置方法

# 1.按索引存取值(正向存取+反向存取)：即可存也可以取
# 1.1 正向取(从左往右)
>>> my_friends=['tony','jason','tom',4,5]
>>> my_friends[0]
tony
# 1.2 反向取(负号表示从右往左)
>>> my_friends[-1]
5
# 1.3 对于list来说，既可以按照索引取值，又可以按照索引修改指定位置的值，但如果索引不存在则报错
>>> my_friends = ['tony','jack','jason',4,5]
>>> my_friends[1] = 'martthow'
>>> my_friends
['tony', 'martthow', 'jason', 4, 5]

# 2.切片(顾头不顾尾，步长)
# 2.1 顾头不顾尾：取出索引为0到3的元素
>>> my_friends[0:4]
['tony', 'jason', 'tom', 4]
# 2.2 步长：0:4:2,第三个参数2代表步长，会从0开始，每次累加一个2即可，所以会取出索引0、2的元素
>>> my_friends[0:4:2]
['tony', 'tom']
# 2.3 my_friends[:] #切片等同于拷贝行为，而且相当于浅拷贝。
# 2.4 my_friends[::-1]  #整个列表取反，倒过来。

# 3.长度
>>> len(my_friends)
5

# 4.成员运算in和not in
>>> 'tony' in my_friends
True
>>> 'xxx' not in my_friends
True

# 5.添加
# 5.1 append()列表尾部追加元素
>>> l1 = ['a','b.txt','c']
>>> l1.append('d')
>>> l1
['a', 'b.txt', 'c', 'd']
# 5.2 extend()一次性在列表尾部添加多个元素(拼接作用）
>>> l1.extend(['a','b.txt','c'])
>>> l1
['a', 'b.txt', 'c', 'd', 'a', 'b.txt', 'c']
# 5.3 insert()在指定位置插入元素
>>> l1.insert(0,"first")  # 0表示按索引位置插值
>>> l1
['first', 'a', 'b.txt', 'c', 'alisa', 'a', 'b.txt', 'c']

# 6.删除
# 6.1 del :通用的删除方法，只是单纯的删除、没有返回值。
>>> l = [11,22,33,44]
>>> del l[2]  # 删除索引为2的元素,不支持赋值语法
>>> l
[11,22,44]
# 6.2 pop()默认删除列表最后一个元素，并将删除的值返回，括号内可以通过加索引值来指定删除元素
>>> l = [11,22,33,22,44]
>>> res=l.pop()
>>> res
44
>>> res=l.pop(1)
>>> res
22
# 6.3 remove()括号内指名道姓表示要删除哪个元素，返回None
>>> l = [11,22,33,22,44]
>>> res=l.remove(22) # 从左往右查找第一个括号内需要删除的元素
>>> print(res)
None

# 7.循环
# 循环遍历my_friends列表里面的值
for line in my_friends:
    print(line)
'tony'
'jack'
'jason'
4

# 8.reverse()颠倒列表内元素顺序，不是排序，列表倒过来。
>>> l = [11,22,33,44]
>>> l.reverse()
>>> l
[44,33,22,11]

# 8.sort()给列表内所有元素排序
# 8.1 排序时列表元素之间必须是相同数据类型，不可混搭，否则报错
>>> l = [11,22,3,42,7,55]
>>> l.sort()
>>> l
[3, 7, 11, 22, 42, 55]  # 默认从小到大排序
>>> l = [11,22,3,42,7,55]
>>> l.sort(reverse=True)  # reverse用来指定是否跌倒排序，默认为False
>>> l
[55, 42, 22, 11, 7, 3]
# 8.2 了解知识：
# 我们常用的数字类型直接比较大小，但其实，字符串、列表等都可以比较大小，
  原理相同：都是依次比较对应位置的元素的大小，如果分出大小，则无需比较下一个元素，比如
>>> l1=[1,2,3]
>>> l2=[2,]
>>> l2 > l1
True
# 字符之间的大小取决于它们在ASCII表中的先后顺序，越往后越大
>>> s1='abc'
>>> s2='az'
>>> s2 > s1 # s1与s2的第一个字符没有分出胜负，但第二个字符'z'>'b.txt',所以s2>s1成立
True
了解：列表也可以比大小，原理同字符串一样，必须同种类型
# 所以我们也可以对下面这个列表排序
>>> l = ['A','z','adjk','hello','hea']
>>> l.sort()
>>> l
['A', 'adjk', 'hea', 'hello','z']

# 9、count index clear
# l = [1, 1, 22, 1, 24]
# # res1 = l.count(1)    # 1有几个  3 [1, 1, 22, 1, 24]
# # res2 = l.index(22)  # 找索引,找不到报错 2 [1, 1, 22, 1, 24]
# res3 = l.clear()  # 清除列表，返回一个None  None []
# # print(res1,l)
# # print(res2,l)
# print(res3,l)

# 补充
# 1、队列：FIFO，先进先出（商场自动扶梯，先站上去的人，先出去）
l=[]
# 入队操作
l.append('first')
l.append('second')
l.append('third')
print(l)
# 出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))

# 2、堆栈：LIFO,后进后出（向衣柜里叠衣服，后叠进去的，先拿出来）
l = []
# 入栈操作
l.append('first')
l.append('second')
l.append('third')
print(l)
# 出栈操作
print(l.pop())
print(l.pop())
print(l.pop())

练习

# 1. 有列表data=['alex',49,[1900,3,18]]，分别取出列表中的名字，年龄，出生的年，月，日赋值给不同的变量
data = ['alex', 49, [1900, 3, 18]]
name = data[0]
age = data[1]
year = data[2][0]
month = data[2][1]
day = data[2][2]
# 2. 用列表模拟队列
l = []
l.append('a')
l.append('b')
l.append('c')
l.pop(0)
l.pop(0)
l.pop(0)
# 3. 用列表模拟堆栈
l1 = []
l1.append('a')
l1.append('b')
l1.append('c')
l1.pop()
l1.pop()
l1.pop()
# 4. 有如下列表，请按照年龄排序（涉及到匿名函数）
l2 = [
    {'name': 'alex', 'age': 84},
    {'name': 'oldboy', 'age': 73},
    {'name': 'egon', 'age': 18},
]
l2.sort(key=lambda item: item['age'])
print(l2)

五 元组

1、元组与列表类似("一个不可变的列表”），也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改。
#  即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取，只用于读不用于改
2、定义：
在()内用逗号分隔开多个任意类型的值
# >>> countries = ("中国"，"美国"，"英国")  # 本质:countries = tuple("中国"，"美国"，"英国")
强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
# >>> countries = ("中国"，)  # 本质:countries = tuple("中国")
强调，元组不能改，是指元组对应内存地址不能改，元组里含有列表等可变类型数据，在列表内的内容可以改变

3、类型转换

# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
>>> tuple('wdad') # 结果：('w', 'd', 'a', 'd')
>>> tuple([1,2,3]) # 结果：(1, 2, 3)
>>> tuple({"name":"jason","age":18}) # 结果：('name', 'age')
>>> tuple((1,2,3)) # 结果：(1, 2, 3)
>>> tuple({1,2,3,4}) # 结果：(1, 2, 3, 4)
# tuple()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到元组中

4、使用

>>> tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
4.1 按索引取值(正向取+反向取)：只能取，不能改否则报错！
>>> tuple1[0]
1
>>> tuple1[-2]
22
>>> tuple1[0] = 'hehe'  # 报错：TypeError:
4.2 切片(顾头不顾尾，步长)
>>> tuple1[0:6:2]
(1, 15000.0, 22)
4.3 长度
>>> len(tuple1)
6
4.4 成员运算 in 和 not in
>>> 'hhaha' in tuple1
True
>>> 'hhaha' not in tuple1
False 

5、循环

>>> for line in tuple1:
...     print(line)
1
hhaha
15000.0
11
22
33

6、内置方法(两种）

t = (1, 2, 34, 5)
t1 = t.count(1)
t2 = t.index(34)
print(t1, type(t1))
print(t2, type(t2))

练习

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

l = []
while True:
    for key, item in msg_dic.items():
        print('商品名：{}, 价格：{}元！'.format(key, item))
    product_name = input('请输入商品名：').strip()
    if not product_name or product_name not in msg_dic:continue
    count = input('购买个数：').strip()
    if not count.isdigit():continue
    l.append((product_name, msg_dic[product_name], count))
    print(l)

六 字典

1、作用
2、定义：在{}内用逗号分隔开多元素，每一个元素都是key:value的形式，其中value可以是任意类型
#   而key则必须是不可变类型，key不重复，详见第八小节，通常key应该是str类型，因为str类型会对value有描述性的功能

info={'name':'tony','age':18,'sex':'male'} #本质info=dict({....})
# 也可以这么定义字典
info=dict(name='tony',age=18,sex='male') # info={'age': 18, 'sex': 'male', 'name': 'tony'}

d={}    #默认定义出来的是空字典
d1=dict()   #也定义空字典
print(d,d1)

3、数据类型转换

转换1：
info = [['name', 'tony'], ('age', 18), ['sex', 'male']]
d = {}
for item in info:
    d[item[0]] = item[1]
print(d)    # {'name': 'tony', 'age': 18, 'sex': 'male'}

res = dict(info)
print(res)  # {'name': 'tony', 'age': 18, 'sex': 'male'}

转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中
>>> {}.fromkeys(('name','age','sex'),None)
{'age': None, 'sex': None, 'name': None}

4、内置方法

# 1.1 取
>>> dic = {
...     'name': 'xxx',
...     'age': 18,
...     'hobbies': ['play game', 'basketball']
... }
>>> dic['name']
'xxx'
>>> dic['hobbies'][1]
'basketball'
# 1.2 对于赋值操作，如果key原先不存在于字典，则会新增key:value
>>> dic['gender'] = 'male'  #列表对没有的索引赋值，会报错；类似与列表的append,insert
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball'],'gender':'male'}
# 1.3 对于赋值操作，如果key原先存在于字典，则会修改对应value的值
>>> dic['name'] = 'tony'
>>> dic
{'name': 'tony', 'age': 18, 'hobbies': ['play game', 'basketball']}

# 2、长度len
>>> len(dic)
3

# 3、成员运算in和not in
>>> 'name' in dic  # 判断某个值是否是字典的key
True

# 4、删除
# 4.1 通用删除
dic={'name':'tony','age':18,'sex':'male'}
del dic['name']
print(dic）
# 4.2
>>>  res=dic.pop('name')  # 通过指定字典的key来删除字典的键值对，返回删除key对应的那个Value。
>>> dic
{'age': 18, 'hobbies': ['play game', 'basketball']}
>>> res
'tony'
# 4.3 popitem删除：随机删除，返回元组（删除的Key,删除Value)
res = dic.popitem()
print(res)  # ('sex', 'male')

# 5、键keys()，值values()，键值对items()    --》在python3中得到的是老母鸡,跟range一样的道理，节约内存
>>> dic = {'age': 18, 'hobbies': ['play game', 'basketball'], 'name': 'xxx'}
# 获取字典所有的key
>>> dic.keys()  #python2中输出是--》['name', 'age', 'hobbies']
dict_keys(['name', 'age', 'hobbies'])
# 获取字典所有的value
>>> dic.values()
dict_values(['xxx', 18, ['play game', 'basketball']])
# 获取字典所有的键值对
>>> dic.items()
dict_items([('name', 'xxx'), ('age', 18), ('hobbies', ['play game', 'basketball'])])

需要掌握得

1.get()
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}   #根据key取值，容错性好
>>> dic.get('k1')
'jason'  # key存在，则获取key对应的value值
>>> res=dic.get('xxx') # key不存在，不会报错而是默认返回None
>>> print(res)
None
>>> res=dic.get('xxx',666) # key不存在时，可以设置默认返回的值
>>> print(res)
666

ps:字典取值建议使用get方法

# 2.update()
# 用新字典更新旧字典，有则修改，无则添加
>>> dic= {'k1':'jason','k2':'Tony','k3':'JY'}
>>> dic.update({'k1':'JN','k4':'xxx'})
>>> dic
{'k1': 'JN', 'k3': 'JY', 'k2': 'Tony', 'k4': 'xxx'}

# 3.setdefault()
# key不存在则新增键值对，并将新增的value返回
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k3',333)
>>> res
333
>>> dic # 字典中新增了键值对
{'k1': 111, 'k3': 333, 'k2': 222}

# key存在则不做任何修改，并返回已存在key对应的value值
>>> dic={'k1':111,'k2':222}
>>> res=dic.setdefault('k1',666)
>>> res
111
>>> dic # 字典不变
{'k1': 111, 'k2': 222}

练习

# 1 有如下值集合 [11,22,33,44,55,66,77,88,99,90]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中
# 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
l = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
l1 = []
l2 = []
for i in l:
    if i > 60:
        l1.append(i)
    if i < 60:
        l2.append(i)
dic = {}
dic['k1'] = l1
dic['k2'] = l2
print(dic)

# 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'
l3 = s.split(' ')
print(l3)
dic = {}
for i in l3:
    dic[i] = l3.count(i)  # 字典给键赋值，就是给字典增加键值对
print(dic)

七 集合

1、作用
 集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算

2、定义

定义：在{}内用逗号分隔开多个元素，集合具备以下三个特点：

     1：每个元素必须是不可变类型
     2：集合内没有重复的元素
     3：集合内元素无序

s = {1,2,3,4}  # 本质 s = set({1,2,3,4})

# 注意1：列表类型是索引对应值，字典是key对应值，均可以取得单个指定的值，
        而集合类型既没有索引也没有key与值对应，所以无法取得单个的值，而且对于集合来说，主要用于去重与关系运算，
        根本没有取出单个指定值这种需求。
# 注意2:{}既可以用于定义dict，也可以用于定义集合，但是字典内的元素必须是key:value的格式，
       现在我们想定义一个空字典和空集合，该如何准确去定义两者?
d = {} # 默认是空字典
s = set() # 这才是定义空集合

3、类型转换
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
# >>> s = set([1,2,3,4])
# >>> s1 = set((1,2,3,4))
# >>> s2 = set({'name':'jason',})
# >>> s3 = set('egon')
# >>> s,s1,s2,s3
{1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'e', 'o', 'g', 'n'}

4、使用
关系运算(类似于数学集合运算）
我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算
friends1 = {"zero", "kevin", "jason", "egon"}   # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "egon"}     # 用户2的好友们
 1）合集/并集(|)：求两个用户所有的好友（重复好友只留一个）
# print(friends1|friends2)    #无序得
# print(friends1.union(friends2))
 2）交集(&)：求两个用户的共同好友
print(friends1&friends2)
print(friends1.intersection(friends2))  #等价
 3）差集(-)：
# print(friends1 - friends2)  # 求用户1独有的好友
# print(friends1.difference(friends2))
# print(friends2 - friends1)  # 求用户2独有的好友
# print(friends2.difference(friends1))
 4）对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
 5）值是否相等(==)
# >>> friends1 == friends2
# False

 6）父集：一个集合是否包含另外一个集合
 6.1 包含则返回True
>>> {1,2,3} > {1,2}
True
print({1,2,3}.issuperset({1,2})
print({1,2}.issubset({1,2,3})
>>> {1,2,3} >= {1,2}
True
 6.2 不存在包含关系，则返回False
>>> {1,2,3} > {1,3,4,5}
False
>>> {1,2,3} >= {1,3,4,5}
False

 7）子集
>>> {1,2} < {1,2,3}
True
>>> {1,2} <= {1,2,3}
True
 8）长度
>>> s={'a','b.txt','c'}
>>> len(s)
3

 9）成员运算
>>> 'c' in s
True

 10）循环
>>> for item in s:
...     print(item)
... 
c
a
b.txt

5 去重（局限性）
# 1. 只能针对不可变类型
# 2. 集合本身是无序的，去重之后无法保留原来的顺序
>>> l=['a','b.txt',1,'a','a']
>>> s=set(l)
>>> s   # 将列表转成了集合
{'b.txt', 'a', 1}
>>> l_new=list(s) # 再将集合转回列表
>>> l_new
['b.txt', 'a', 1] # 去除了重复，但是打乱了顺序

# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
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)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
    {'age': 18, 'sex': 'male', 'name': 'lili'}, 
    {'age': 73, 'sex': 'male', 'name': 'jack'}, 
    {'age': 20, 'sex': 'female', 'name': 'tom'}
]

6 其他内置方法
# 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)
# print(s)

4）add
# s.add(4)
# print(s)

练习

一.关系运算
　　有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
　　pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
　　linuxs={'wupeiqi','oldboy','gangdan'}
　　1. 求出即报名python又报名linux课程的学员名字集合
　　2. 求出所有报名的学生名字集合
　　3. 求出只报名python课程的学员名字
　　4. 求出没有同时这两门课程的学员名字集合

# 有如下两个集合，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)

二.去重

　　 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序

　　 2.在上题的基础上，保存列表原来的顺序

　　 3.去除文件中重复的行，肯定要保持文件内容的顺序不变
　　 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序

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=['a','b',1,'a','a']
print(set(l))

#去重,并保持原来的顺序
#方法一:不用集合
l=[1,'a','b',1,'a']

l1=[]
for i in l:
    if i not in l1:
        l1.append(i)
print(l1)

#方法二:借助集合
l1=[]
s=set()
for i in l:
    if i not in s:
        s.add(i)
        l1.append(i)
print(l1)

# 同上方法二,去除文件中重复的行
import os
with open('db.txt','r',encoding='utf-8') as read_f,\
        open('.db.txt.swap','w',encoding='utf-8') as write_f:
    s=set()
    for line in read_f:
        if line not in s:
            s.add(line)
            write_f.write(line)
os.remove('db.txt')
os.rename('.db.txt.swap','db.txt')

# 列表中元素为可变类型时,去重,并且保持原来顺序
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'},
]
# print(set(l)) #报错:unhashable type: 'dict'
s=set()
l1=[]
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        l1.append(item)
print(l1)

# 定义函数,既可以针对可以hash类型又可以针对不可hash类型
def func(items,key=None):
    s=set()
    for item in items:
        val=item if key is None else key(item)
        if val not in s:
            s.add(val)
            yield item

print(list(func(l,key=lambda dic:(dic['name'],dic['age'],dic['sex']))))

八 数据类型总结

按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量／原子类型	数字，字符串
容器类型	列表，元组，字典

 按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组

按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

九、 作业

#作业一: 三级菜单
#要求:
打印省、市、县三级菜单
可返回上一级
可随时退出程序

menu = {
    '北京':{
        '海淀':{
            '五道口':{
                'soho':{},
                '网易':{},
                'google':{}
            },
            '中关村':{
                '爱奇艺':{},
                '汽车之家':{},
                'youku':{},
            },
            '上地':{
                '百度':{},
            },
        },
        '昌平':{
            '沙河':{
                '老男孩':{},
                '北航':{},
            },
            '天通苑':{},
            '回龙观':{},
        },
        '朝阳':{},
        '东城':{},
    },
    '上海':{
        '闵行':{
            "人民广场":{
                '炸鸡店':{}
            }
        },
        '闸北':{
            '火车战':{
                '携程':{}
            }
        },
        '浦东':{},
    },
    '山东':{},
}

# 方法一
tag=True
while tag:
    menu1=menu
    for key in menu1: # 打印第一层
        print(key)

    choice1=input('第一层>>: ').strip() # 选择第一层

    if choice1 == 'b': # 输入b，则返回上一级
        break
    if choice1 == 'q': # 输入q，则退出整体
        tag=False
        continue
    if choice1 not in menu1: # 输入内容不在menu1内，则继续输入
        continue

    while tag:
        menu_2=menu1[choice1] # 拿到choice1对应的一层字典
        for key in menu_2:
            print(key)

        choice2 = input('第二层>>: ').strip()

        if choice2 == 'b':
            break
        if choice2 == 'q':
            tag = False
            continue
        if choice2 not in menu_2:
            continue

        while tag:
            menu_3=menu_2[choice2]
            for key in menu_3:
                print(key)

            choice3 = input('第三层>>: ').strip()
            if choice3 == 'b':
                break
            if choice3 == 'q':
                tag = False
                continue
            if choice3 not in menu_3:
                continue

            while tag:
                menu_4=menu_3[choice3]
                for key in menu_4:
                    print(key)

                choice4 = input('第四层>>: ').strip()
                if choice4 == 'b':
                    break
                if choice4 == 'q':
                    tag = False
                    continue
                if choice4 not in menu_4:
                    continue

                # 第四层内没数据了，无需进入下一层

# 方法二
#part1（初步实现）：能够一层一层进入
layers = [menu, ]

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=[menu,]

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])