python - 数据类型

python - 数据类型：

基本类型：
1.数字
整数int 长整型long 浮点型float
2.字符串
文本str 字节bytes
3.布尔
true false
数据集：
1.列表list
2.元祖tuple (数组)
3.字典dict
有序字典 无序字典
4.集合set
有序集合 无序集合
------------------------------------------------
一、基本类型：
1.数字：
1.1.int(整型)
32 -2**31 ~ 2**31-1 即：-2147483648 ~ 214748364
64 -2**63 ~ 2**63-1 即：-9223372036854775808 ~ 9223372036854775807
1.2.long(长整型)
python2.2起，整数发生溢出，python会自动转换为长整数
python3起，不在有long型，全部是int
1.3.
1.3.1浮点型：float
实数：有理数 无理数
有理数：正有理数 负有理数 零 （有限小数或无限循环小数）
正有理数：正整数 正分数
负有理数：负整数 负分数
无理数：正有理数 负无理数 （无限不循环）π= 3.1415926...

所以：一个浮点数一定是小数，一个小数不一定是浮点数，因为π不是浮点数

python中 浮点数能精确到17位。越往后越不准与存储有关
eg:1.323231232323232

一个浮点数所占的空间远大于整数的

**但是你非要显示小数点后多于17位的需要导入第三方的模块
from decimal import *
a='3.3123123123123213213232131233231'
Decimal(a)
decimal('3.32321323123231231232321323')
导入模块 就可以 高精度的得到小数
3.2
科学技术法：1.99*10的13次方 1.99E13=199000000 E表示遇到比较大的值
1399 1.399E3=1399.0 13.99E2 不能这样表示
3.3
复数：a+bi 实数+虚数
python 表示复数：(-5+4j) 复数用在 量子力学

----------------------------------------------------
2.字符串：
2.1.文本str

'' "" ''' ''' """ """ 都可 单引号=双引号适合单行 多引号写多行

msg="My name is alice，I'm 22 years old" //单双引号配合使用

msg='''my name is alice, //多句话，多行
i'm 22 years old '''
print(msg)

msg="my name is alice,\ //单行话， \表示还没结束，往下一行写
i'm 22 years old "
print(msg) //my name is alice,i'm 22 years old

注意：不加引号的字符串表示变量；name=jack 出错；

字符串 + 和 *
>>> name='alcie '
>>> age='12 '
>>> name+age
'alcie 12 '

>>> name='alice '
>>> name*10
'alice alice alice alice alice alice alice alice alice alice '

注意：只能字符串和字符串+ * 不能跨数据类型
-------------------------
字符串得方法：
1.创建： s='Hello world'
2.有序，不可变
>>> s="Hello World"
>>> s.swapcase() //swapcase()
'hELLO wORLD'
>>> s.capitalize() //capitalize()
'Hello world'
>>> s.casefold() //casefold()
'hello world'
>>> s.center(50,'*') //center()
'*******************Hello World********************'
>>> s.count('o') //count()
2
>>> s.count('o',0,5)
1
>>> s.encode() //encode()
b'Hello World'
>>> s.endswith('!') //endswith()
False
>>> s.expandtabs() //expandtabs()
'Hello World'
>>> s2='a\tb'
>>> s2
'a\tb'
>>> s2.expandtabs()
'a b'
>>> s2.expandtabs(20)
'a b'
>>> s.find('osdf') //find()
-1
>>> s.find('o')
4
>>> s.find('o',0,2)
-1
>>> s.find('o',0,5)
4
>>> s3='my name is {0}, i am {1} years old'
>>> s3
'my name is {0}, i am {1} years old'
>>> s3.format('alice',22) //format()
'my name is alice, i am 22 years old'
>>> s3='my name is {name}, i am {yaers} years old'
>>> s3
'my name is {name}, i am {yaers} years old'
>>> s3.format('alice',23)
Traceback (most recent call last):
File "<pyshell#467>", line 1, in <module>
s3.format('alice',23)
KeyError: 'name'
>>> s3
'my name is {name}, i am {yaers} years old'
>>> s3.format(name='alice',yaers=23)
'my name is alice, i am 23 years old'
>>>
>>> s
'Hello World'
>>> s.index('o')
4
>>> s.index('o',6,8)
7
>>> '22d'.isalnum()
True
>>> '22'.isalpha()
False
>>> 'ss'.isalpha()
True
>>> '2d'.isalpha()
False
>>> s.isdecimal()
False

>>> '23'.isdecimal()
True
>>> '23sd'.isdecimal()
False
>>> '232'.isdigit()
True
>>> 'sds222'.isdigit()
False
>>> '23d'.isidentifier()
False
>>> '_sds3'.isidentifier()
True
>>> 'sdsds'.islower()
True
>>> 'sdsdsAD'.islower()
False
>>> '122'.isnumeric()
True
>>> '122SS'.isnumeric()
False
>>> 'sds2'.isprintable()
True
>>> ' '.isspace()
True
>>> 'wew '.isspace()
False
>>> 'Helllo World'.istitle()
True
>>> 'Helllo world'.istitle()
False
>>> 'sds'.isupper()
False
>>> 'ADC'.isupper()
True
>>> 'SDds'.isupper()
False
>>> name=['alex','alcie']
>>> name
['alex', 'alcie']
>>> ''.join(name)
'alexalcie'
>>> ' '.join(name)
'alex alcie'
>>> ', '.join(name)
'alex, alcie'
>>> '-'.join(name)
'alex-alcie'

>>> s.ljust(50,'-')
'Hello World---------------------------------------'
>>> s
'Hello World'
>>> s.lower()
'hello world'
>>> s.upper()
'HELLO WORLD'
>>> s.lstrip()
'Hello World'
>>> s
'Hello World'
>>> s.strip()
'Hello World'
>>> s+=' '
>>> s
'Hello World '
>>> s='\n hello world '
>>> s.strip()
'hello world'
>>> s
'\n hello world '
>>> s.lstrip()
'hello world '
>>> s.rstrip()
'\n hello world'
>>> str_in = 'abcdef'
>>> str_out = '!@#$%^'
>>> str.maketrans(str_in,str_out)
{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}
>>> table=str.maketrans(str_in,str_out)
>>> table
{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}
>>> s
'\n hello world '
>>> s.translate(table)
'\n h%llo worl$ '
>>> 'abcdAlex'.translate(table)
'!@#$Al%x'
>>> s
'\n hello world '
>>> s.partition('o')
('\n hell', 'o', ' world ')
>>> s
'\n hello world '
>>> s.replace('o','-')
'\n hell- w-rld '
>>> s.replace('o','-',1)
'\n hell- world '
>>> s.rfind('o')
9
>>> s
'\n hello world '
>>> s=s.strip()
>>> s
'hello world'
>>> s.rfind('o')
7
>>> s.rfind('p')
-1
>>> s.rindex('o')
7

>>> s.rfind('psd')
-1
>>> s
'hello world'
>>> s.rpartition('o')
('hello w', 'o', 'rld')
>>> s
'hello world'
>>> s.split()
['hello', 'world']
>>> s.split('o')
['hell', ' w', 'rld']
>>> s.split('l')
['he', '', 'o wor', 'd']
>>> s.rsplit('o')
['hell', ' w', 'rld']
>>> s.rsplit('o',1)
['hello w', 'rld']
>>> s.splitlines()
['hello world']
>>> s
'hello world'
>>> s='a\nb\nalex\nc'
>>> s
'a\nb\nalex\nc'
>>> s.splitlines()
['a', 'b', 'alex', 'c']
>>> s
'a\nb\nalex\nc'
>>> s='hello world'
>>> s.startswith('he')
True
>>> s.startswith('helldds')
False
>>> s.endswith('ld')
True
>>> s.endswith('ss')
False
>>> s.endswith('world')
True
>>> s
'hello world'
>>> s.title()
'Hello World'
>>> s.zfill(30)
'0000000000000000000hello world'
>>>
字符串中所有得方法 // 字符串中 常用得方法
常用得：
1.isdigit
2.replace
3.find
4.count
5.strip
6.center
7.split
8.format
9.join
------------
>>> '23'.isdigit() //isdigit
True
>>> s='hello world'
>>> s
'hello world'
>>> s.replace('h','A') //replace
'Aello world'
>>> s.find('e') //find
1
>>> s.count('o') //count
2
>>> x='\n hello world '
>>> x
'\n hello world '
>>> x.strip() //strip
'hello world'
>>> s
'hello world'
>>> s.center(40,'-') //center
'--------------hello world---------------'
>>> s.split('o') //split
['hell', ' w', 'rld']
>>> "my name is {0}".format('alcie') //format
'my name is alcie'
>>> "my name is {name}".format(name='aclie')
'my name is aclie'
>>> name
['alex', 'alcie']
>>> ' '.join(name) //join
'alex alcie'
>>>

-------------------------
2.2.字节bytes
字符串与bytes得关系：
bytes通过编码表找到得字形就是字符串；

对于图片和视频没有字符编码 怎么办
图片到内存中 怎么表示图片 图片得二进制流 bytes

----------------------------------------------------
3.布尔
true false 逻辑判断
>>> a=10
>>> b=12
>>> a<b
True
>>> a>b
False

根据条件是否成立，决定走那条路；为了后面的逻辑
if a>b
print(a is bigger than b)
else
print(a is smaller than b)

----------------------------------------------------
二、数据集
1.列表list

如何通过一个变量存储所有员工的名字 -- 列表
列表是一个数据的集合，可以方便的增删改查

列表的功能：创建 查询 切片 增加 修改 删除 循环 排序

1.1.创建：
L1=[]
L2=['a','b','c','d']
L3=['abc',['def','ghi']]
L4=list()
print(L4)
[]

1.2.查询：
L2[0],L2[2] L2[-1] //列表是通过索引来操作的
>>> name=['a','b','c','d','e',1,2,3,4,5,2,3,4,2]
>>> name
['a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2]
name.index(2) //返回第一个索引
6
name.index('c')
2
>>> name[name.index('c')]
'c'
>>> name.count(2)
3
查询三种：name[2] name.index(2) name[name.index('c')] name.count(2)

1.3.切片：切片：顾头不顾尾，步长
>>> name=['a','b','c','d','e',1,2,3,4,5,2,3,4,2]
>>> name
['a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2]
>>> name[0:4]
['a', 'b', 'c', 'd']
>>> name[0:5]
['a', 'b', 'c', 'd', 'e']
>>> name[3:6]
['d', 'e', 1]
>>> name[-5:-1]
[5, 2, 3, 4] //最后一个没过来
>>> name[-5:]
[5, 2, 3, 4, 2]
>>> name[0:]
['a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2]
>>> name[3:]
['d', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2]
>>> name[:6]
['a', 'b', 'c', 'd', 'e', 1]
>>> name[:3]
['a', 'b', 'c']
>>> name[:]
['a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2]
>>> name[:7]
['a', 'b', 'c', 'd', 'e', 1, 2]
>>> name[:7:2] //步长
['a', 'c', 'e', 2]
>>> name[:7:1]
['a', 'b', 'c', 'd', 'e', 1, 2]
>>> name[::2]
['a', 'c', 'e', 2, 4, 2, 4]
>>>

1.4.增加 插入 修改
>>> name.append('women') //追加 append
>>> name
['a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2, 'women']
>>> name.insert(0,'he')
>>> name
['he', 'a', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2, 'women']
>>> name.insert(2,'she') //插入 insert
>>> name
['he', 'a', 'she', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2, 'women']
>>> name[2]
'she'
>>> name[2]='xi' //修改
>>> name
['he', 'a', 'xi', 'b', 'c', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2, 'women']
>>> name[2:5]
['xi', 'b', 'c']
>>> name[2:5]='123 456'
>>> name
['he', 'a', '1', '2', '3', ' ', '4', '5', '6', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2, 'women']

1.5.删除
>>> name.pop() //删除最后一个 pop()并返回删除得元素
'women'
>>> name
['he', 'a', 'a', 'l', 'i', 'c', 'e', ' ', 'a', 'l', 'e', 'x', '3', ' ', '4', '5', '6', 'd', 'e', 1, 2, 3, 4, 5, 2, 3, 4, 2]
>>> name.remove(4) //删除了出现的第一个元素 remove() 如果没有元素 会报错
>>> name
['he', 'a', 'l', 'i', 'c', 'e', ' ', 'a', 'l', 'e', 'x', '3', ' ', '4', '5', '6', 'd', 'e', 1, 2, 3, 5, 2, 3, 4, 2]
>>> del name[1] //全局的指令 del name[]
>>> name
['he', 'l', 'i', 'c', 'e', ' ', 'a', 'l', 'e', 'x', '3', ' ', '4', '5', '6', 'd', 'e', 1, 2, 3, 5, 2, 3, 4, 2]
>>> s=3232
>>> s
3232
>>> del s //全局删 删了变量 del
>>> name
['he', 'l', 'i', 'c', 'e', ' ', 'a', 'l', 'e', 'x', '3', ' ', '4', '5', '6', 'd', 'e', 1, 2, 3, 5, 2, 3, 4, 2]
>>> del name[1:6] //批量删
>>> name
['he', 'a', 'l', 'e', 'x', '3', ' ', '4', '5', '6', 'd', 'e', 1, 2, 3, 5, 2, 3, 4, 2]

1.6.循环
>>> for i in name: //循环列表 for
print(i)

he
a
6
d
e
1
2
3
5
2
3
4
2
>>>
>>> range(10)
range(0, 10)
>>> for i in range(10): //range(10)==[0,1,2,3,4,5,6,7,8,9]
print(i)

0
1
2
3
4
5
6
7
8
9
>>>
while与for的区别：
1.while可死循环；条件可以永远为真
2.for是有边界的；

1.7.排序
>>> n=[1,3,5,2,5,7,2]
>>> n.sort() //sort() 按ASCII码排序的
>>> n
[1, 2, 2, 3, 5, 5, 7]
>>> m=['f','a','h','c','B','S','a']
>>> m.sort()
>>> m
['B', 'S', 'a', 'a', 'c', 'f', 'h']
>>> m.insert(3,'#')
>>> m.insert(3,'*')
>>> m.insert(1,'!')
>>> m
['B', '!', 'S', 'a', '*', '#', 'a', 'c', 'f', 'h']
>>> m.sort()
>>> m
['!', '#', '*', 'B', 'S', 'a', 'a', 'c', 'f', 'h']
>>> m.reverse() //反转 reverse()
>>> m
['h', 'f', 'c', 'a', 'a', 'S', 'B', '*', '#', '!']
>>>

1.8.拼列表
>>> m
['h', 'f', 'c', 'a', 'a', 'S', 'B', '*', '#', '!']
>>> n
[1, 2, 2, 3, 5, 5, 7]
>>> m+n //两列表 拼接 m+n
['h', 'f', 'c', 'a', 'a', 'S', 'B', '*', '#', '!', 1, 2, 2, 3, 5, 5, 7]
>>> m
['h', 'f', 'c', 'a', 'a', 'S', 'B', '*', '#', '!']
>>> n
[1, 2, 2, 3, 5, 5, 7]
>>> m.extend(n) //两列表 拼接 extend()
>>> m
['h', 'f', 'c', 'a', 'a', 'S', 'B', '*', '#', '!', 1, 2, 2, 3, 5, 5, 7]
>>>

1.9.清空
>>> m
['h', 'f', 'c', 'a', 'a', 'S', 'B', '*', '#', '!', 1, 2, 2, 3, 5, 5, 7]
>>> n
[1, 2, 2, 3, 5, 5, 7]
>>> m.clear() //清空列表 clear
>>> m
[]
>>>

1.10.copy()
>>> n=[1,2,3,2]
>>> n1=n //赋值 不独立
>>> n
[1, 2, 3, 2]
>>> n1
[1, 2, 3, 2]
>>> n[2]='he'
>>> n
[1, 2, 'he', 2]
>>> n1
[1, 2, 'he', 2]
>>> m=[1,4,2]
>>> m1=m.copy() //copy 浅copy 独立 但在 列表里 套列表 就不行了 里面又不独立了
>>> m1
[1, 4, 2]
>>> m[2]="eh"
>>> m
[1, 4, 'eh']
>>> m1
[1, 4, 2]
>>>

//n=names.copy() //浅拷贝 列表里得数据会改 但列表里得列表 不会修改 浅拷贝 资源共享
浅copy 共享资源
//深copy 需要导入工具箱 import copy //深拷贝 完全克隆了一份 修改一份 不会影响下一次 资源共享
>>> import copy
>>> n2=copy.deepcopy(name) //copy.deepcopy()
>>> n2

1.11.枚举
>>> for index,i in enumerate(names): //enumerate() enumerate(1，names)
print(index,i)

1.12.判断是否是数字
>>> '222'.isdigit() //isdigit()
True
>>> 'sdsdse222'.isdigit()
False
>>>

1.13.得到列表长度
>>> len(names) //得到列表得长度 // len()
17

1.14.查看内存地址 //id()
>>> a=1
>>> b=a
>>> id(a)
1824419296
>>> id(b)
1824419296
>>> a=3
>>> id(a)
1824419360
>>> id(b)
1824419296
>>>
------------------------------------------------------------
2.元祖：
name=("alex","jack","eric")

1.特性：
不可变
元祖本身不可变，如果元祖中包含其他可变元素，这些可变元素可以改变
2.功能：
index count 切片
3.使用场景：
显示得告知别人，此处数据不可修改
数据库连接配置信息等

hash

"哈希" 翻译为 "散列" ；
将任意长度 通过散列得算法 变成 固定 长度得 值 输出得 叫散列值
压缩值，散列值
两个不同得输入 通过散列算法 有可能导致输出相同 叫 输出冲突
所以 不能通过 输出 判断 输入得

特征：
hash 被哈希得 值 是 不可变得

不可变：数字 字符串 元祖
可变：列表
>>> hash('alice')
3814747010261602999
>> hash((1,2,3))
2528502973977326415

哈希得算法 不能保证 每一个出来得 hash 值是唯一得 所以 就产生冲突的
//一定要解决冲突

用途：
1.文件签名
2.MD5加密 --- 无法反解
3.密码验证

//通过hash算法生成一段唯一得值

---------------------------------------------------------
3.字典
key - value

>>> info={
'龙婷':[24,'design','ui',12839231232],
'姗姗':[25,'pr','model',1321323]
}
3.1.特性：
1.key必须可哈希，必须唯一
2.可存放任意多个值，可修改，可以不唯一
3.无序
4.查找速度快

3.2.用法： 增 删 改 查
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323]}
>>> info["alice"]="绘图" //增加
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 'alice': '绘图'}
>>>
>>> info['alice']="这是绘图" //修改
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 'alice': '这是绘图'}
>>>
>>> info.get('alice') //查找 get()
'这是绘图'
>>>
>>> info['alice']
'这是绘图'
>>>
>>> print(info.get('sdsds')) //找不到 返回 None
None
>>> info['sdsds'] //找不到就报错 所以 一般用get
Traceback (most recent call last):
File "<pyshell#690>", line 1, in <module>
info['sdsds']
KeyError: 'sdsds'
>>>
>>> 'alice' in info //查找判断
True
>>> info.pop('alice') //删除 pop popitem del info[]
'这是绘图'
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323]}
>>>
>>> info[4]=2
>>> info[3]=2
>>> info[2]=2
>>> info[1]=2
>>> info.popitem() //随机删 popitem()
(2, 2)
>>>
>>> del info[3]
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 4: 2}

info.clear() //清空 clear()
info.copy() //深浅copy

>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 4: 2}
>>> info.keys() //.keys() 打印所有得keys
dict_keys(['龙婷', '姗姗', 4])
>>> info.values() //.values() 打印所有得values
dict_values([[24, '设计', 'ui', 12839231232], [25, 'pr', 'model', 1321323], 2])
>>>
>>> info.items() //.items() 把字典转成了列表
dict_items([('龙婷', [24, '设计', 'ui', 12839231232]), ('姗姗', [25, 'pr', 'model', 1321323]), (4, 2)])
>>>
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 4: 2, 1: 2, 2: 3, 'jack': [22, 'ali ceo']}
>>> dic3={2:3,'jack':22}
>>> dic3
{2: 3, 'jack': 22}
>>> info.update(dic3) //.update 如果key已经存在 它会替换掉 values值
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 4: 2, 1: 2, 2: 3, 'jack': 22}
>>> dic3
{2: 3, 'jack': 22}
>>>
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 4: 2, 1: 2, 2: 3, 'jack': 22}
>>> info.setdefault(2,'new 2') //.setdefault() 如果key存在 就拿到value值 如果没有key得值 就加进去
3
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 4: 2, 1: 2, 2: 3, 'jack': 22}
>>> info.setdefault('test','new 2')
'new 2'
>>> info
{'龙婷': [24, '设计', 'ui', 12839231232], '姗姗': [25, 'pr', 'model', 1321323], 4: 2, 1: 2, 2: 3, 'jack': 22, 'test': 'new 2'}
>>>
>>> info.fromkeys(['A','B','C'],'ALEX') //.fromkeys()批量生成 values值
{'A': 'ALEX', 'B': 'ALEX', 'C': 'ALEX'}
--------------------------------------------
3.3.字典得循环： //循环字典
>>> for k in info:
print(k,info[k]) //高效 因为从字典里拿数据 因为hash

龙婷 [24, '设计', 'ui', 12839231232]
姗姗 [25, 'pr', 'model', 1321323]
4 2
1 2
2 3
jack 22
test new 2
>>>

>>> info.items()
dict_items([('龙婷', [24, '设计', 'ui', 12839231232]), ('姗姗', [25, 'pr', 'model', 1321323]), (4, 2), (1, 2), (2, 3), ('jack', 22), ('test', 'new 2')])
>>> for k,v in info.items(): //低效 不用 因为 将字典转成了列表 ，在取值
print(k,v)

龙婷 [24, '设计', 'ui', 12839231232]
姗姗 [25, 'pr', 'model', 1321323]
4 2
1 2
2 3
jack 22
test new 2
>>>

多级字典嵌套：
字典里面嵌套字典 多级字典 嵌套

---------------------------------------------------------
4.集合

集合：无序，不重复得数据组合
作用：
1.去重，把一个列表变成集合，就自动去重了
2.关系测试，测试两组数据之间得交集，差集，并集

>>> s={2,3,4,3,2,2}
>>> s
{2, 3, 4}
>>>

>>> l=[2,3,2,2,23,4,4,2,1] //列表转集合，列表和元祖可以转集合
>>> l
[2, 3, 2, 2, 23, 4, 4, 2, 1]
>>> set(l)
{1, 2, 3, 4, 23}
>>>

增删改查：
add pop remove（没有得报错） discard(没有得不报错) update clear

4.1.交集： intersection &

>>> s={1,2,3,4}
>>> q={3,4,5}
>>> s.intersection(q)
{3, 4}
>>> s & q
{3, 4}
>>>

4.2.差集： difference -

>>> s.difference(q)
{1, 2}
>>> s-q
{1, 2}

4.3.并集： union |

>>> s.union(q)
{1, 2, 3, 4, 5}
>>> s | q
{1, 2, 3, 4, 5}
>>>

4.4.对称差集 symmetric_diffenence ^

>>> s
{1, 2, 3, 4}
>>> q
{3, 4, 5}
>>> s.symmetric_difference(q)
{1, 2, 5}
>>>

4.5.超级子集 issubset <= issuperset >=

>>> s
{1, 2, 3, 4}
>>> s1={1,2,3,4,5,6}
>>> s1
{1, 2, 3, 4, 5, 6}
>>> s.issubset(s1)
True
>>> s1.issubset(s)
False
>>> s.issuperset(s1)
False
>>> s1.issuperset(s)
True
>>>

4.6.判断两个集合 是不是 不相交

>>> s.isdisjoint(s1)
False
>>>

>>> s.difference_update(s1)
>>> s
{-2, -1}

---------------------------------------------------
总结：
1.python数据类型
基本类型：
1.数字
整数int 长整型long 浮点型float
2.字符串
文本str 字节bytes
3.布尔
true false
数据集：
1.列表list
2.元祖tuple (数组)
3.字典dict
4.集合set