一 int 类型
1、作用
2、定义
int( ) ：调用创建整型数据功能
age=10 # 本质age = int(10)
补充：
res = print（‘xxx’） #print不生产产品
print(res) #None
3、类型转换
3.1 出数字的字符串转成 int
int('1010') #1010
3.2 了解
十进制 ——>二进制
print(bin(11)) #0b1011
十进制——>八进制
print(oct(11)) # 0o13
十进制——>十六进制
print(hex(11)) # 0xb
print(hex(123)) # 0x7b
二进制——>十进制
print(int('0b1011',2)) # 11
八进制——>十进制
print(int('0o13',8)) # 11
十六进制——>十进制
print(int('0xb',16)) # 11
二 float 类型
1、作用
2、定义
float（）:调用创建浮点型数据的功能
salary=1.1 # 本质salary=float(1.1)
3、类型转换
res=float("3.1")
print(res,type(res)) #3.1 <class 'float'>
4、使用：
使用的就是数学运算 + 比较运算
三 字符串类型
1、作用
用于记录一些描述性的信息。
字符串是一个值，它是有序的（有索引），不可变类型。
有虚类型=>序列类型
字符串的修改操作都是在原字符串的基础上新建一个字符串，并不是直接对原字符串进行修改
2、定义
字符串定义：在单引号/双引号/三引号内包含一串字符
只要在引号内，空格也算字符
name1 = 'han' # 本质:name = str('任意形式内容')
name2 = "zhang" # 本质:name = str("任意形式内容")
name3 = """kang""" # 本质:name = str("""任意形式内容""")
3、类型转换
str可以把任意其他类型都转为字符串
res=str({'a':1})
print(res,type(res)) #{'a': 1} <class 'str'>
4、使用：内置方法
4.1 按索引取值（正向取+反向取）：只能取（不能改）
通过索引不能修改字符串
msg='hello world'
# 正向取
print(msg[0]) #h
print(msg[4]) #o
# 反向取
print(msg[-1]) #d
msg[0] = H
print(msg) #报错， 不能通过索引改
4.2 切片：索引的扩展应用，从一个大字符串中拷贝出一个子字符串(顾头不顾尾，步长)
msg = 'hello world'
print(msg[0:4]) #hell
print(msg[0:5:2]) #hlo
print(msg[-1]) #d
print(msg[:]) #hello world 正着取所有
print(msg[0: -1]) #hello worl
print(msg[4:0:-1]) #olle
print(msg[4:0:-2]) #ol
print(msg[::-1]) #dlrow olleh 倒着取所有
4.3 统计长度 len
msg = 'hello world'
print(len(msg)) #11
4.4 成员运算 in 和 not in
判断一个子字符串是否在一个大字符串里
print("alex" in "alex is sb") #True
print("alex" not in "alex is sb") #False
print(not "alex" in "alex is sb") # False
4.5 移除字符串左右两侧的符号 strip
如果想要去掉字符串中所有符号 即 ’字符串‘.strip（’添加想要去掉的符号‘）
msg='**/*=-**egon**-=()**'
print(msg.strip('*/-=()')) #egon
默认去掉两侧的空格
# msg=' egon '
# res=msg.strip()
# print(msg) # 不会改变原值
# print(res) # 是产生了新值
了解：strip 之去掉两边，不能去掉中间
msg='****egon****'
print(msg.strip('*')) #egon
msg1='****e*****gon****'
print(msg1.strip('*')) #e*****gon
strip lstrip rstrip比较
strip:去掉左右两侧的符号
lstrip：去掉左侧的符号
rstrip：去掉右侧的符号
msg='***egon****'
print(msg.strip('*')) #egon
print(msg.lstrip('*')) #egon****
print(msg.rstrip('*')) #***egon
4.6 切分 split
切分：把一个字符串按照某种分隔符进行切分，得到一个列表
1）默认分隔符是空格
info='egon 18 male'
res=info.split()
print(res) #['egon', '18', 'male']
2）指定分隔符
info='egon:18:male'
res=info.split(':')
print(res) #['egon', '18', 'male']
3）指定分隔次数
info='egon:18:male'
res=info.split(':',1)
print(res) #['egon', '18:male']
4）split 与 rsplit比较
split ：从左切
rsplit : 从右切
info="egon:18:male"
print(info.split(':',1)) # ["egon","18:male"]
print(info.rsplit(':',1)) # ["egon:18","male"]
循环
info='egon:18:male'
for x in info:
print(x)
结果展示：
e g o n : 1 8 : m a l e
**4.7 lower upper**
msg='AbbbCCCC'
print(msg.lower()) #abbbcccc 全改为小写
print(msg.upper()) #ABBBCCCC 全改为大写
4.8 startswith endwith
print("alex is sb".startswith("alex")) #True
print("alex is sb".endswith('sb')) #True
4.9 format
cmd = input('请输入命令：').strip()
print('{}正在执行。。。'.format(cmd))
4.10 join：把列表（元素全为字符串的）拼接成字符串
按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
l = ['egon', '18', 'male']
res =":".join(l) # 按照某个分隔符号，把元素全为字符串的列表拼接成一个大字符串
print(res) #egon:18:male
注：如果列表中有元素不是字符串的话，拼接会报错
l1=[1,"2",'aaa']
res = ":".join(l1)
print(res) #报错
4.11 替换 replace
msg="you can you up no can no bb"
print(msg.replace("you","YOU",)) #YOU can YOU up no can no bb
print(msg.replace("you","YOU",1))#YOU can you up no can no bb
4.12 isdigit
判断字符串是否由纯数字组成
只能识别 bytes（如：b'4'） 及 unicode(如:u'4') 类型数字
print('123'.isdigit()) #True
print('12.3'.isdigit()) #False
补充：
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
# isdigit只能识别：num1、num2
print(num1.isdigit()) # True
print(num2.isdigit()) # True
print(num3.isdigit()) # False
print(num4.isdigit()) # False
# isnumberic可以识别：num2、num3、num4
print(num2.isnumeric()) # True
print(num3.isnumeric()) # True
print(num4.isnumeric()) # True
# isdecimal只能识别：num2
print(num2.isdecimal()) # True
print(num3.isdecimal()) # False
print(num4.isdecimal()) # False
4.13 find rfind index rindex
1）find(' 字符串'): 返回要查找的字符串在大字符串中的起始索引，如果没有，则会返回 -1
2）rfind(' 字符串'): 返回要查找(从右开始查找)的字符串在大字符串中的起始索引
3）index('字符串’):返回要查找的字符串在大字符串中的起始索引，如果没有会报错
4）rindex('字符串'): 返回要查找(从右开始查找)的字符串在大字符串中的起始索引
msg='hello egon hahaha'
print(msg.find('e')) #1 返回要查找的字符串在大字符串中的起始索引
print(msg.find('egon')) #6
print(msg.index('e')) #1
print(msg.index('egon')) #6
print(msg.find('xxx')) #返-1 代表找不到
print(msg.index('xxx')) #找不到，报错
**4.14 count**
count:查找字符串在整个大的字符串中的个数
msg='hello egon hahaha egon、 egon'
print(msg.count('egon')) #3
**4.15 center,ljust,rjust,zfill**
#总宽度为20，字符串居中，不够用 * 补全
print('egon'.center(20,'*')) #********egon********
#总宽度为50，字符串居左，不够用 * 补全
print('egon'.ljust(20,'*')) #egon****************
#总宽度为50，字符串居右，不够用 * 补全
print('egon'.rjust(20,'*')) #****************egon
#总宽度为 10，字符串居右，
print('egon'.zfill(10)) #000000egon
4.16 captalize,swapcase,title
#captalize：首字母大写
print('hello world egon'.capitalize()) #Hello world egon
#swapcase：大小写翻转
print('Hello WorLd EGon'.swapcase())#hELLO wORlD egON
# title：每个单词的首字母大写
print('hello world egon'.title()) #Hello World Egon
4.17 is的用法
#isupper 判断是否为大写
print('abc'.isupper()) #False
#islower 判断是否为小写
print('abc'.islower()) #True
#istitle 判断字符串的单词首字母是否为大写
print('Hello World'.istitle()) #True
#isalnum():判断是否由数字，字母或者数字加字母组成
print('123aab'.isalnum()) #True
print('123'.isalnum()) #True
print('abc'.isalnum()) #True
print('123#abc'.isalnum())#False
#isalpha 判断是否全为字母
print('abc'.isalpha()) #True
print('abc1'.isalpha()) #False
#isspace 判断字符串是否全为空格
print(' '.isspace()) #True
print('ab '.isspace()) #False
#isidentifier 判断字符串命名是否规范
print('print'.isidentifier()) #True python
print('age_of_egon'.isidentifier()) #True
print('1age_of_egon'.isidentifier()) #False
4.18 expandtabs
expandtabs() 方法把字符串中的 tab 符号(' ')转为空格，tab 符号(' ')默认的空格数是 8。
默认以 8 个空格数为一个 制表符
name ='tony hello'
msg ='hlelo world'
awp = 'withswitch'
# 设置制表符代表的空格数，默认为 8
print(msg) #hello world 用3个空格扩展
print(awp.expandtabs(4))#withswitch 没有扩展
print(name.expandtabs(1)) #tony hello 用一个空格扩展
print(name.expandtabs(2)) #tony hello 用两个空格扩展
print(name.expandtabs(3)) #tony hello 用两个空格扩展
print(name.expandtabs(4)) #tony hello 用四个空格扩展
print(name.expandtabs(5))#tony hello 用一个空格扩展
四 列表
1、作用
按位置存多个值，一般用于存同种类型
列表是有序的，可变类型 存多个值
2、定义
list1 = [1, 1.2, 'a'] #list1= list([1, 1.2, 'a'] )
3、类型转换
但凡能够被 for 循环遍历的类型都可以当做参数传给 list( )转成列表
lsit( )底层就相当于调用了一个 for 循环
res = list('hello') #[’h','e','l','l','o']
4、内置方法
4.1 按索引取值（正向存取+反向存取）：即可以取也可以改
l=[111,'egon','hello']
print(l[0]) #111
print(l[-1]) #hello
l[0]=222
print(l) #[222, 'egon', 'hello']
l[3]=333 #索引不存在会报错
4.2 切片（顾头不顾尾，步长）[ 0 : 5 : 2]
切片是一种拷贝行为，新建一个列表而且相当于浅copy
l=[111,'egon','hello']
print(l[0:3]) #[111, 'egon', 'hello']
print(l[0:5:2]) # [[111, 'hello']
print(id(l)) #4502840840
new_l = l[:]
print(id(new_l)) #4502996616
print(l[0:len(l)]) #[111, 'egon', 'hello']
print(l[:]) #[111, 'egon', 'hello']
补充：
对于不可变类型，通过完整切片得到的新数据指向同一个内存地址
a = '123123'
b = a[:]
print(a,id(a)) #123123 4439713248
print(b,id(b)) #123123 4439713248
c = ('han', 1)
d = c[:]
print(c,id(c)) #('han', 1) 4307222088
print(d,id(d)) #('han', 1) 4307222088
4.3 成员运算 in 和 not in
print('aaa' in ['aaa', 1, 2]) #True
print(1 in ['aaa', 1, 2]) #True
4.4 在指定位置插入值 insert(索引, 元素)
insert：按索引插入值
l=[111,'egon','hello']
l.insert(0,'alex')
print(l) ##['alex', 111, 'egon', 'hello']
4.5 追加元素 append (元素 )
l=[111,'egon','hello']
l.append(3333)
l.append(4444)
print(l) #[111, 'egon', 'hello', 3333, 4444]
4.6 追加多个值 extend( 可迭代对象或字符串)
extend（参数） #参数为可迭代对象或字符串
它是将可迭代对象（或字符串）中的元素（或字母）取出再追加到调用该方法的列表中
new_l=[1,2,3]
l=[111,'egon','hello']
l.extend(new_l)
print(l) #[111, 'egon', 'hello', 1, 2, 3]
l.extend('abc')
print(l) #[111, 'egon', 'hello', 1, 2, 3, 'a', 'b', 'c']
4.7 删除 del（ 索引或切片） pop(索引) remove( 元素)
方式一：del（索引或切片） ：通用的删除方法，不是列表独有的，只是单纯的删除，没有返回值。
l = [111, 'egon', 'hello']
del l[1]
x =del l[1] # 抛出异常，不支持赋值语法
方式二：pop( 索引)：根据索引删除（不指定索引默认从最后删），有返回值（返回的删除的值）
l = [111, 'egon', 'hello']
l.pop() # 不指定索引默认删除最后一个
res = l.pop()
print(res) #egon
print(l) #[111]
方式三：remove(元素 ):根据元素删除，返回 None值
l = [111, 'egon', [1,2,3],'hello']
l.remove([1,2,3])
print(l) #[111, 'egon', 'hello']
res=l.remove('egon')
print(res) # None
4.8 统计长度 len( )
a = [1,'1vc', '123']
print(len(a)) #3
4.9 循环
l=[1,'aaa','bbb']
for x in l:
l.pop()
print(x)
结果展示：
1
aaa
4.10 统计个数 count（元素）
l = [1, 'aaa', 'bbb','aaa','aaa']
print(l.count('aaa')) #3
4.11 返回索引 index('元素')
l = [1, 'aaa', 'bbb','aaa','aaa']
print(l.index('aaa')) #1 返回找到的第一个元素索引
print(l.index('aaaaaaaaa')) # 找不到报错
4.12 清空所有 clear（）
a1 = [1,4,5,7,2,3]
a1.clear()
print(a1) #[]
4.13 reverse( )：将列表倒过来
reverse修改的是原列表
a1 = [1,4,5,7,2,3]
a1.reverse()
print(a1) #[3, 2, 7, 5, 4, 1]
4.14 sort( ):排序
sort用法：列表内必须全是同一种类型才可以排序，修改的是原列表
默认是升序：从小到大排,修改的是原列表
l.sort( reverse = True) 降序：从大到小排
a = [1,4,5,7,2,3]
a.sort()
print(a) #[1, 2, 3, 4, 5, 7] 升序
a1 = [1,4,5,7,2,3]
a1.sort(reverse=True)
print(a1) #[7, 5, 4, 3, 2, 1] 降序
l=[11,'a',12]
l.sort() #报错，元素不是同种类型
l1=['11','a','12']
l1.sort()
print(l1) #['11', '12', 'a']
了解知识点：
元素全为字符串可以比大小，按照 ASCIl码表的先后顺序加以区分，表中排在后面的字符大于前面的
a = 'abdc'
b = 'abcfd'
print(a > b) #True
列表也可以比大小,原理同字符串一样（按对应位置，依次 pk）注：对应的位置必须为同种类型,如果不是，比较会报错
a = [1,'ab']
b = [2]
print(b > a) True
补充
队列：FIFO，先进先出
l = []
#入队操作
l.append('first')
l.append('second')
l.append('third')
print(l) #['first', 'second', 'third']
#出队操作
print(l.pop(0)) #first
print(l.pop(0)) #second
print(l.pop(0)) #third
堆栈：LIFO：先进后出
l = []
#入栈操作
l.append('first')
l.append('second')
l.append('third')
print(l) #['first', 'second', 'third']
#出栈操作
print(l.pop()) #third
print(l.pop()) #second
print(l.pop()) #first
五 元组
元组就是‘一个不可变的列表’，有索引，有序的， 存多个值
元组不能改:指的是不能改变元组内元素的内存地址
1、作用
按照 索引/位置存放多个值，只用于读不用取
当我有多个值，只有读的操作，没有取的操作就可以用元组存储，元组占的内存空间小（列表还提供取的机制，因此需要额外的内存空间存取的机制）
2、 定义
（）内用逗号分隔多个任意类型的元素，如果元组中没有一个元素，必须加逗号（如： ( 元素 1,) ）
t = (1, 2, 'aa') #t = tuple((1,2,'aa'))
print(t, type(t)) #(1, 2, 'aa') <class 'tuple'>
x=(10) # 单独一个括号只代表包含的意思，不是元组
print(x,type(x)) #10 <class 'int'>
t1=(10,) # 如果元组中只有一个元素，必须加逗号
print(t1,type(t1)) #(10,) <class 'tuple'>
t=(1,1.3,'aa') # t=(0->值1的内存地址,1->值1.3的内存地址,2->值'aaa'的内存地址，)
t[0]=11111 #报错
t=(1,[11,22]) # t=(0->值1的内存地址,1->值[1,2]的内存地址，)
print(id(t[0]),id(t[1]))
t[0]=111111111 # 不能改，报错
t[1]=222222222 # 不能改，报错
t[1][0]=11111111111111111 #可以改，改动是可变类型元素的子元素，可变类型元素 id 不变
# print(t)
print(id(t[0]),id(t[1]))
3、类型转换
将字符串、列表、字典转换为元组类型，相当于 for 循环取值后再用元组包含。
print(tuple('hello')) #('h', 'e', 'l', 'l', 'o')
print(tuple([1,2,3])) #(1, 2, 3)
print(tuple({'a1':111,'a2':333})) #('a1', 'a2')
4、内置方法
优先掌握：
4.1 按索引取值（正向取+反向取）:只能取
t=('aa','bbb','cc')
print(t[0]) #aa
print(t[-1]) #cc
4.2 切片（顾头不顾尾， 步长）
t=('aa','bbb','cc','dd','eee')
print(t[0:3]) #('aa', 'bbb', 'cc')
print(t[::-1]) #('eee', 'dd', 'cc', 'bbb', 'aa')
4.3 统计长度
t=('aa','bbb','cc','dd','eee')
print(len(t)) #5
4.4 成员运算 in 和 not in
t=('aa','bbb','cc','dd','eee')
print('aa' in t) #True
4.5 循环
t=('aa','bbb','cc','dd','eee')
for x in t:
print(x, end=' ') #aa bbb cc dd eee
4.6 索引取值 index
t=(2,3,111,111,111,111)
print(t.index(111)) #t=('aa','bbb','cc','dd','eee')
print(t.index(1111111111)) # 不存在会报错
4.7 统计元素个数 count
t=(2,3,111,111,111,111)
print(t.count(t)) #4
六 字典
1、作用
用途：储存多个不同类型的值
2、定义
{ 内用逗号分隔多个 key：value， 其中 value可以是可变型，key 必须是不可变类型
字典没有索引，无序，可变类型，存多个值
Info = { } #info = dict( )
3、类型转换
造字典方式一：
d={'k1':111,(1,2,3):222} # d=dict(...)
print(d['k1']) #111
print(d[(1,2,3)]) #222
print(type(d)) #<class 'dict'>
d1={} # 默认定义出来的是空字典
print(d,type(d1)) #{} <class 'dict'>
造字典方式二：
d = dict(x=1, y=2 , z=3)
print(d) #{'x': 1, 'y': 2, 'z': 3}
造字典方式三：
a = [['name', 'han'],['age', 18]] #列表中的元素内的子元素个数必须为2
print(dict(a)) #{'name': 'han', 'age': 18}
a1 = [('name', 'han1'),['age', 17]]
print(dict(a1)) #{'name': 'han1', 'age': 17}
a2 = (('name', 'han2'),['age', 16])
print(dict(a2)) #{'name': 'han2', 'age': 16}
a4 = (('name', 'han3'),('age', 20))
print(dict(a4)) #{'name': 'han3', 'age': 20}
造字典方式四：快速初始化一个字典
d= { }.fromkeys([ 元素 1， 元素 2 ], 参数 ) :会将列表中的每个元素当做 字典的 key，参数会被当做 值 传给每个 key 对应的 value。
list1 = ['name', 'age', 'gender']
d = {}.fromkeys(list1, None)
print(d) #{'name': None, 'age': None, 'gender': None}
4、内置方法
优先掌握：
1 按 key 存取值：可存可取
d={'k1':111}
# 针对赋值操作：key存在，则修改
d['k1']=222
# 针对赋值操作：key不存在，则创建新值
d['k2']=3333
print(d) #{'k1': 222, 'k2': 3333}
2 统计长度 len
d={'k1':111,'k2':2222,'k3':3333,'k4':4444}
print(len(d)) #4
3 成员运算 in 和 not in ：根据 key
字典的成员运算判断的是否在字典中keys中
d={'k1':111,'k2':2222}
print('k1' in d) # True
print(111 in d) #False
4 删除
4.1 del 通用删除
d={'k1':111,'k2':2222}
del d['k1']
print(d) #{'k2': 2222}
4.2 pop 删除
pop(key):根据 key 删除元素，有返回值，返回删除 key 对应的 value 值
必须指定 key，因为字典是无序的，没有索引
d={'k1':111,'k2':2222}
res=d.pop('k2')
print(d) #{'k1': 111}
print(res) #2222
4.3 popitem 删除
它是随机删除，没有参数，返回的是元组（key，value）
d={'k1':111,'k2':2222}
res=d.popitem()
print(res) #('k2', 2222)
print(d) #{'k1': 111}
5 键 keys( )、值 values( )、items( )
在 python2 中，一般返回的都是列表（相当于鸡蛋）
items() :返回的值是列表套元组的方式：[ (key1， value1), (key2， value2 ) ]
在python2中
>>> d={'k1':111,'k2':2222}
>>>
>>> d.keys()
['k2', 'k1']
>>> d.values()
[2222, 111]
>>> d.items()
[('k2', 2222), ('k1', 111)]
>>> dict(d.items())
{'k2': 2222, 'k1': 111}
>>>
在 python3 中，一般返回的都是可迭代对象（相当于老母鸡），它是 python3 中的一种在内存中存取的优化，占用的内存空间非常少
>>> d={'k1':111,'k2':222}
>>> d.keys()
dict_keys(['k1', 'k2'])
>>> print(d.keys())
dict_keys(['k1', 'k2'])
>>> print(type(d.keys()))
<class 'dict_keys'>
>>> d.values()
dict_values([111, 222])
>>> d.items()
dict_items([('k1', 111), ('k2', 222)])
>>> dict(d.items())
{'k1': 111, 'k2': 222}
>>>
6 for循环
d={'k1':111,'k2':222}
for k,v in d.items():
print(k,v)
结果展示：
k1 111
k2 2222
d={'k1':111,'k2':222}
print(d.items()) #dict_items([('k1', 111), ('k2', 2222)])
pirnt(list(d.items)) #[('k1', 111), ('k2', 2222)]
d={'k1':111,'k2':2222}
res1 = dict(d.items())
print(d,id(d)) #{'k1': 111, 'k2': 2222} 4420553104
print(res1, id(res1)) #{'k1': 111, 'k2': 2222} 4422053960
需要掌握的:
1 clear 全部清除
d={'k1':111}
d.clear()
print(d) #{}
2、update（参数：字典类型）
用新字典替换旧字典，有 key 则改对应的值，无 key 则添加键值对
d={'k1':111}
d.update({'k2':222,'k3':333,'k1':111111})
print(d) #{'k1': 111111, 'k2': 222, 'k3': 333}
3、get( ) 根据 key 取值，容错性好
get( ):可以指定返回值，不指定默认返回 None
d={'k1':111}
print(d['k2']) # key不存在则报错
print(d.get('k2')) #None key 不存在返回 None
print(d.get('k1')) # 111
print(d.get('k2', '目标不存在'))#目标不存在，返回指定值
4、setdefault(key, value )
1）有 key 则不添加，返回字典中对应value 值
info={'name':'egon'}
res=info.setdefault('name','alex')
print(res) #egon
print(info) #{'name': 'egon'}
2）key 不存在时则添加，返回新增的value值 ，且字典新增键值对
info={'name':'egon'}
res=info.setdefault( 'age', 18)
print(res) #18
print(info) #{'name': 'egon', 'age': 18}
七 集合
1、什么是集合
可以存多个值，不是用来取单个值使用的，它是将所有值放到一起，整体去使用，主要用于：去重和运算。
它是无序的，可变类型（不可修改，可增删），存多个值
1.1 关系运算
l1 = ['han','egon','tank']
l2 = ['han', 'alex', 'sean']
l3 = []
for i in l1:
if i in l2:
l3.append(i)
print(l3) #['han']
2、定义
在{ }内用多个逗号分隔来多个元素，多个元素满足以下三个条件
1、集合内元素必须为不可变类型（指的是被去重对象取出的元素必须为不可变类型）
2、集合内元素无序
3、集合元素没有重复
注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
s = set（）#空集合
s = {1,[1,23] }#报错，集合内元素必须为不可变类型
s = {1,1,'a','b'}
print(s) #{1,'a','b'} 去重了
s = {1,'c',2,'b'}
print(s,type(s)) #{1, 2, 'c', 'b'} <class 'set'> #无序的
l = [{'name':'egon'}, {'name':'alex'}]
print(set(l))# 报错
3、类型转换
res = set('hello world')
print(res) #{'e', 'o', ' ', 'w', 'h', 'r', 'l', 'd'}
res1 = [1,1,2,[22,11]]
print(set(res1)) #报错
res2 = {'name':'han','age':18}
print(set(res2))#{'age', 'name'}
res3 = ('han','123','egon','123')
print(set(res3))#{'123', 'egon', 'han'}
4、内置方法
关系运算
l1 = {'han','egon','tank','jason'}
l2 = {'han', 'alex', 'sean','jason'}
1、取交集
res = l1 & l2
print(res) #{'han', 'jason'}
print(l1.intersection(l2))
2、取并集/合集:两者所有的好友
print(l1 | l2) #{'egon', 'sean', 'tank', 'han', 'jason', 'alex'}
print(l1.union(l2))
3、取差集:取l1 独有的好友
取差集:取l2 独有的好友
print(l1-l2) #{'tank', 'egon'}
print(l1.different(l2))
print(l2 - l1) #{'sean', 'alex}
print(l2.difference(l1))
4、对称差集: 两个集合独有的元素（即去掉共同元素）
print(l1 ^ l2) #{'tank', 'alex', 'egon', 'sean'}
print(l1.symmetric_difference(l2))
5、父子集：包含关系
s1 = {'a', 'b', 'c'}
s2 = {'a', 'b', 'd'}
s3 = {'a', 'b'}
print(s1 >= s2) #False 当s1大于或等于s2时，才能说是s1是s2他爹
print(s1.issuperset(s2))
print(s1 >= s3) #True
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))
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'},
]
# 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)
其他内置方法
需要掌握：
1 discard 删除
1）当元素不存在时，不做动作
3）当元素存在时，删除 元素，无返回值
s={1,2,3}
s.discard(4) # 删除元素不存在do nothing
print(s) #{1, 2, 3}
s.discard(3)
print(s) #{1, 2}
s.remove(4) # 删除元素不存在则报错
2 update 取两个集合的并集重新赋给该集合
s={1,2,3}
print(s.update({1,3,5})) #None
print(s) #{1, 2, 3, 5}
3 pop 随机删除
s={1,2,3}
res=s.pop()
print(res) #{1,2}
4 add 添加元素
s={1,2,3}
s.add(4)
print(s) #{1,2,3,4}
了解：
1 isdisjoint ( )
判断两个集合是否有交集部分
当两个集合完全独立，没有交集，返回 True
s = {1,2,3}
res=s.isdisjoint({4,5,6}) # 两个集合完全独立、没有共同部分，返回True
print(res) #True
res= s.isdisjoint({3,4,6})#False
2 difference（ ） difference_update( )
difference：取该集合独有的部分（减去两集合的交集）
s = {1,'aa',4, 6}
print(s.difference({'aa',4,5})) #{1, 6}
print(s) #{1,4,6,'aa'}
difference_update:取该集合的(减去两个集合相交的部分)的独有部分重新赋值给该集合。
s = {1,'aa',4, 6}
print(s.difference_update({4, 5})) #None
print(s)#{1, 'aa', 6}
八 总结与分类
有序 or 无序：有序 又称之为序列类型
存一个值 or 多个值：存一个值称之为原子类型，存多个值称之容器类型
可变 or 不可变
1 按存值个数区分
只能存一个值：可称为标量/原子类型 如：数字、字符串
可以存放多个值：可以称为容器类型 如：列表、元组、字典
2 按照访问方式区分
直接访问：只能通过变量访问整个值 如：数字
顺序访问：可以索引访问指定的值，索引代表顺序、又称为序列类型 如字符串、列表、元组
key 访问:可以用 key 访问指定的值、又称映射类型 如：字典
3 按照可变不可变区分
可变类型 如：列表、字典 、集合
不可变类型 如：字符串 、元组
按存储空间的占用分（从低到高）
数字
字符串
集合：无序，即无需存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改