Python基础之四：Python3 基础数据类型
Python基础之四：Python3 基础数据类型
一、数据类型简介
我们人类作为高级生物，可以很容易区分数据类型，但是计算机不能，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，什么是数字，什么是字符串，否则它是分不清数据之间的区别的，因此，在每个编程语言里都会有一个叫数据类型的东西，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给它。
二、Python3中的基础数据类型简介
Python3中的基础数据类型共6种，分别是：
1.Number（数字）： int（整数）、float（浮点数）、bool（布尔值）、complex（复数）
2.String（字符串）：用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符
3.List（列表）：写在方括号 [] 之间、用逗号分隔开
4.Tuple（元组）：写在方括号 （）之间、用逗号分隔开
5.Set（集合）：由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员，写在大括号{ }之间、用逗号分隔开
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
6.Dictionary（字典）：是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
三、Python3中的基础数据类型详解
1.Number（数字）
Python3 支持 int、float、bool、complex（复数）
1.int（整数类型）
通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
1.1 十进制数转换为二进制数
十进制整数转换为二进制整数：采用"除2取余，逆序排列"法。
具体做法是：
用2整除十进制整数，可以得到一个商和余数；再用2去除商，又会得到一个商和余数，如此进行，直到商为小于1时为止，然后把先得到的余数作为二进制数的低位有效位，后得到的余数作为二进制数的高位有效位，依次排列起来。
# 将十进制数25转换成二进制数：
# 25/2=12---余数1
# 12/2=6---余数0
# 6/2=3---余数0
# 3/2=1---余数1
# 1/2=0---余数1
# 最终结果：10011
十进制小数转换为二进制小数：采用"乘2取整，顺序排列"法。
具体做法是：
用2乘十进制小数，可以得到积，将积的整数部分取出，再用2乘余下的小数部分，又得到一个积，再将积的整数部分取出，如此进行，直到积中的小数部分为零，此时0或1为二进制的最后一位。或者达到所要求的精度为止；
然后把取出的整数部分按顺序排列起来，先取的整数作为二进制小数的高位有效位，后取的整数作为低位有效位。
#将十进制数0.625转换成二进制数：
#0.625*2=1.25======取出整数部分1
#0.25*2=0.5========取出整数部分0
#0.5*2=1==========取出整数部分1
#结果：（0.101）B
1.2 二进制数转换为十进制数
要从右到左用二进制的每个数去乘以2的相应次方,小数点后则是从左往右
例如：二进制数1101.01转化成十进制
1101.01（2）=1*2^0+0*2^1+1*2^2+1*2^3 +0*2^-1+1*2^-2=1+0+4+8+0+0.25=13.25（十进制数）
所以总结起来通用公式为：
abcd.efg(2)=d*2^0+c*2^1+b*2^2+a*2^3+e*2^-1+f*2^-2+g*2^-3（十进制数）
1.3 int操作
计算整数在内存中占用的二进制码的长度，使用bit_length()方法：
# 将十进制数25转换成二进制数：
# 25/2=12---余数1
# 12/2=6---余数0
# 6/2=3---余数0
# 3/2=1---余数1
# 1/2=0---余数1
# 最终结果：10011
m = 25
print(m.bit_length())
#运行结果：5
2.bool（布尔类型）
布尔值只有两个：True（1）、False（0）
2.1 int str bool 三者数据类型之间的转换
str => int int(str)
int => str str(int)
int => bool bool(int) 0是 False， 非0 就是 True
str = > bool bool(str) 空字符串 就是 False ， 非空就是 True
bool => str str(bool) 把 bool 值转换成相对应的 “值”
# int ---> bool
i = 100
print(bool(i)) # True # 非零即True(1)
i1 = 0
print(bool(i1)) # False 零即False(0)
# bool ---> int
t = True
print(int(t)) # 1 True --> 1
t = False
print(int(t)) # 0 False --> 0
# int ---> str
i1 = 100
print(str(i1)) # '100'
# str ---> int # 全部由数字组成的字符串才可以转化成数字
s1 = '90'
print(int(s1)) # 90
# str ---> bool
s1 = '晴朗'
s2 = ''
print(bool(s1)) # True 非空即True
print(bool(s2)) # False
# bool ---> str
t1 = True
print(str(True)) # 'True'
3.float（浮点数类型）
浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
m = 55.7
print(float(m))#55.5
print(int(m))#55
4.complex（复数）
复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
5.数字类型转换
int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
5.数字相关函数
5.1 数学函数
import math
print(abs(-10)) #返回数字的绝对值,结果：10
print(math.ceil(3.2)) #返回数字的上入整数,结果：4
print(math.exp(1)) #返回e的x次幂(ex),结果：2.718281828459045
print(math.fabs(-10)) #返回数字的绝对值，结果：10.0
print(math.floor(4.9)) #返回数字的下舍整数，结果：4
print(math.log(100, 10))# log函数，结果：2.0
print(math.log10(100))# 返回以10为基数的x的对数，结果： 2.0
print(max(1,5,3,6,4,8)) #返回给定参数的最大值，结果：8。
print(min(1,5,3,6,4,8)) #返回给定参数的最小值，结果：1。
print(math.modf(3.88)) #返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。，结果：(0.8799999999999999, 3.0)
print(pow(2, 4)) #x**y 运算后的值,即x的y次幂。结果：16
print(round(10.8765,2))#返回浮点数 x 的四舍五入值，如给出n值，则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。结果：10.88
print(math.sqrt(16)) #返回数字x的平方根。结果：4.0
5.2 随机数函数
import random
print(random.choice(range(10)))#从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
print(random.randrange(1, 100, 2))#从指定范围内，按指定基数递增的集合中获取一个随机数。1-100随机一个奇数
print(random.random()) #随机生成下一个实数，它在[0,1)范围内。
random.seed(10) #改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
print(random.shuffle([])) #将序列的所有元素随机排序
print(random.uniform(0, 10)) #随机生成下一个实数，它在[0,10]范围内。
5.3三角函数
# acos(x) 返回x的反余弦弧度值。
# asin(x) 返回x的反正弦弧度值。
# atan(x) 返回x的反正切弧度值。
# atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
# cos(x) 返回x的弧度的余弦值。
# hypot(x, y) 返回欧几里德范数 sqrt(x*x + y*y)。
# sin(x) 返回的x弧度的正弦值。
# tan(x) 返回x弧度的正切值。
# degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
# radians(x) 将角度转换为弧度
5.3数字常量
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）
2.String（字符串）
凡是用引号引起来的数据可以称为字符串类型，组成字符串的每个元素称之为字符，将这些字符一个一个连接起来，然后在用引号起来就是字符串。
2.1 字符串的索引与切片
索引：即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推
st = 'ABCDEFG'
print(st[0])#A
print(st[2])#C
print(st[6])#G
切片：就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）
2.2 字符串的访问
按索引：s1[index]
按照切片： s1[start_index: end_index+1]
按照切片步长： s1[start_index: end_index+1:2]
反向按照切片步长： s1[start_index: end_index后延一位:2]
st = 'ABCDEFG'
print(st[0:6:2])#ACE，A到F范围内(不包括F)，每隔2取一个值
print(st[0:6:3])#AD，A到F范围内(不包括F)，每隔3取一个值
print(st[:7])#ABCDEFG，A到G范围内（包括G），每隔1取一个值
print(st[-2:1:-1])#FEDC，F到B范围内（不包括B），每隔-1取一个值
print(st[-3:0:-2])#EC，E到A范围内（不包括A），每隔-2取一个值
1 str = '0123456789′
2 print str[0:3] #截取第一位到第三位的字符
3 print str[:] #截取字符串的全部字符
4 print str[6:] #截取第七个字符到结尾
5 print str[:-3] #截取从头开始到倒数第三个字符之前
6 print str[2] #截取第三个字符
7 print str[-1] #截取倒数第一个字符
8 print str[::-1] #创造一个与原字符串顺序相反的字符串
9 print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
10 print str[-3:] #截取倒数第三位到结尾
11 print str[:-5:-3] #逆序截取，截取倒数第五位数与倒数第三位数之间
2.3 转义字符
在需要在字符中使用特殊字符时，python用反斜杠()转义字符
| 转义字符 | 描述 |
|---|---|
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| ’ | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy 代表的字符，例如：\o12 代表换行，其中 o 是字母，不是数字 0。 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
2.4 字符串运算符
| 操作符 | 描述 实例 |
|---|---|
| + | 字符串连接 |
| * | 重复输出字符串 |
2.5 字符串格式化
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
| 符 号 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
f-string： python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法
name = '小明'
age = 18
print (f"我叫{name}，今年{age}岁!" )
#我叫小明，今年18岁!
2.6 字符串常用方法
1.字符串大小写变换
st = 'aBcDe'
print(st.upper())#将字符串转换成大写，结果：ABCDE
print(st.lower())#将字符串转换成小写，结果：abcde
print(st.title())#返回字符串的标题式样（即首字母大写）
print(st.swapcase())#返回字符串大小写交换
2.字符串元素内容检查
st = 'aBcDe'
print(st.startswith('a'))#字符串是否以a开头，结果：True
print(st.endswith('m'))#将字符是否以m结尾，结果：False
print(st.isalnum()) #检查所有字符串是否只有数字和字母
print(st.isalpha())# 检查字符串中是否只有字母
print(st.isdigit())# 检查字符串字符是否全为数字
print(st.islower())#检查字符串字符是否全为小写
print(st.isupper())#检查字符串字符是否全为大写
print(st.istitle())# 检查字符串字符是否为标题式样
3.字符串分隔、剥离与连接
s = " www.jianchi-jiushi-shengli.com "
print('1:', s.split('.')) #以"."进行字符串分割，返回结果为列表。以split()括号里的参数为标准进行字符串分割
print('2:', s.strip(' ')) #剥离字符串两端空格。 不指定参数时默认剥离首尾空格和换行
print('3:', s.lstrip(' w')) #剥离字符串左端空格和w
print('4:', s.rstrip(' om')) #剥离字符串右端空格及字符o和m
print('5:', "-".join(s.split('.'))) #以“.”进行字符串分割后，再以“-”进行字符串连接
4.字符串的查找与替换
s = "www.jianchi-jiushi-shengli.com "
print(s.count('g')) #统计某个字符出现的次数
print(s.capitalize()) #返回字符串首字母大写
print(s.find('q'))#找到q返回下标，多个时返回第一个；不存在的字符返回-1
print(s.index('c'))#找到这个字符返回下标，多个时返回第一个；不存在的字符报错
print(s.replace('g', 'a'))#字符串替换
print(s.center(40, '*'))#输出一个两边用*补充的长度为40的字符串
5.字符串的格式化输出
name = 'liang'
age = 18
print('my name is {name},I am {age}'.format(name = name, age = age))
#my name is liang,I am 18
3.List（列表）
列表是python的基础数据类型之一 ,其他编程语言也有类似的数据类型.比如JS中的数 组, java中的数组等等. 它是以[ ]括起来, 每个元素用’ , '隔开而且可以存放各种数据类型: 列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{
‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
简单概括：1.承载任意数据类型，存储大量的数据，对应别的语言：数组
1.列表的创建
方式一：（常用）
l1 = [1, 2, '学习']
方式二：（不常用）
l1 = list() 空列表
l1 = list(iterable) 可迭代对象
l1 = list('123')
print(l1) ['1', '2', '3']
方式三：列表推导式
l1 = [i for i in range(1,5)]
print(l1) # [1, 2, 3, 4]
2.列表的增删改查
2.1增加
# append 追加，给列表的最后面追加一个元素
l = [1, 2, 'a']
l.append(666)
print(l) # [1, 2, 'a', 666]
# insert 插入在列表的任意位置插入元素
l = [1, 2, 'a']
l.insert(1, '学习')
print(l) # [1, '学习', 2, 'a']
# extend 迭代着追加，在列表的最后面迭代着追加一组数据
l = [1, 2, 'a']
l.extend('学习a')
print(l)#[1, 2, 'a', '学', '习', 'a']
2.2查找
names = ["aaron", "alex", "james", "meihengfan"]
print(names) #列出列表的内容
print(names[3]) #访问列表中第4个值
print(names[1:3]) #访问列表中从第2个到第3个的值
print(names[-1]) #访问列表中的最后一个值
print(names[:-2]) #访问列表中的所有值，但是把倒数第二个及后面的所有值都去掉
print(names[-3:]) #访问列表中倒数第一个到倒数第三个的值
print(names[0],names[3]) #注意取多个值的时候，不能直接把下标写到一起，需要按照这种方式写
print(names[::2]) #打印列表，但是以2为步长，就是跳着切，也可以根据需求把这个步长给改了
print(names.index("james")) #查找列表中james这个元素的下标
print(len(names)) #确定列表的长度
2.3删除
names = ["aaron", "alex", "james", "meihengfan"]
names.remove("aaron")#指定元素删除，默认删除第一个
del names[2] #按索引和切片删除
del names #直接删除列表
names.pop() #按索引删除，默认删除最后一个
names.clear()#清空列表，危险操作，请慎用
2.4修改
直接操作
names = ["aaron", "alex", "james", "meihengfan"]
names[2] = "liming" #把索引为2的元素修改成了‘liming’
3.列表的其他操作
3.1列表的常用方法
a = ["q","w","q","r","t","y"]
print(a.count('q'))#统计列表中q出现的次数
print(a.index('q'))#找出列表中第一个q出现位置的索引
a.reverse()#反向存放列表
print(a)
print(sorted(a))#对列表进行临时性排序
a.sort()#将原列表排序
print(a)
3.2列表的相加和相乘
相加
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1*3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
相乘
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1*3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
4.Tuple（元组）
俗称不可变的列表，又被成为只读列表，元祖也是python的基本数据类型之一，用小括号括起来，里面可以放任何数据类型的数据，查询可以，循环也可以，切片也可以，但就是不能改。
元组的操作方法基本和列表一致，就是不能增加、删除、修改，只能查找！
5.TupleDictionary（字典）
字典是以键值对形式存储的容器型数据类型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {
key1 : value1, key2 : value2 }
键必须是唯一不可变的，但值则不必，值可以是任意数据类型或者对象。
可变数据类型：列表、字典、集合
不可变数据类型：数字（包含布尔值）、字符串、元组
1.字典的创建
# 方式1:
dic = dict((('one', 1),('two', 2),('three', 3)))
# dic = dict([('one', 1),('two', 2),('three', 3)])
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式2:
dic = dict(one=1,two=2,three=3)
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式3:
dic = dict({
'one': 1, 'two': 2, 'three': 3})
print(dic) # {'one': 1, 'two': 2, 'three': 3}
# 方式4: 字典推导式
# dic = { k: v for k,v in [('one', 1),('two', 2),('three', 3)]}
# print(dic)
2.字典的增删改查
2.1增加
# 通过键值对直接增加
dic = {
'name': '小明', 'age': 18}
dic['weight'] = 75 # 没有weight这个键，就增加键值对
print(dic) # {'name': '小明', 'age': 18, 'weight': 75}
dic['name'] = 'barry' # 有name这个键，就成了字典的改值
print(dic) # {'name': 'barry', 'age': 18, 'weight': 75}
# setdefault
dic = {
'name': '小明', 'age': 18}
dic.setdefault('height', 175) # 没有height此键，则添加
print(dic) # {'name': '小明', 'age': 18, 'height': 175}
dic.setdefault('name', 'barry') # 有此键则不变
print(dic) # {'name': '小明', 'age': 18, 'height': 175}
2.2删除
# pop 通过key删除字典的键值对，有返回值，可设置返回值。
dic = {
'name': '小明', 'age': 18}
# ret = dic.pop('name')
# print(ret, dic) # 小明 {'age': 18}
ret1 = dic.pop('n', None)
print(ret1, dic) # None {'name': '小明', 'age': 18}
#popitem 3.5版本之前，popitem为随机删除，3.6之后为删除最后一个，有返回值
dic = {
'name': '小明', 'age': 18}
ret = dic.popitem()
print(ret, dic) # ('age', 18) {'name': '小明'}
#clear 清空字典
dic = {
'name': '小明', 'age': 18}
dic.clear()
print(dic) # {}
# del
# 通过键删除键值对
dic = {
'name': '小明', 'age': 18}
del dic['name']
print(dic) # {'age': 18}
#删除整个字典
del dic
2.3修改
# 通过键值对直接改
dic = {
'name': '小明', 'age': 18}
dic['name'] = 'barry'
print(dic) # {'name': 'barry', 'age': 18}
# update
dic = {
'name': '小明', 'age': 18}
dic.update(sex='男', height=175)
print(dic) # {'name': '小明', 'age': 18, 'sex': '男', 'height': 175}
dic = {
'name': '小明', 'age': 18}
dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])
print(dic) # {'name': '小明', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
dic1 = {
"name":"jin","age":18,"sex":"male"}
dic2 = {
"name":"alex","weight":75}
dic1.update(dic2)
print(dic1) # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
print(dic2) # {'name': 'alex', 'weight': 75}
2.4查找
# 通过键查询
# 直接dic[key](没有此键会报错)
dic = {
'name': '小明', 'age': 18}
print(dic['name']) # 小明
# get
dic = {
'name': '小明', 'age': 18}
v = dic.get('name')
print(v) # '小明'
v = dic.get('name1')
print(v) # None
v = dic.get('name2','没有此键')
print(v) # 没有此键
keys()
dic = {
'name': '小明', 'age': 18}
print(dic.keys()) # dict_keys(['name', 'age'])
values()
dic = {
'name': '小明', 'age': 18}
print(dic.values()) # dict_values(['小明', 18])
items()
dic = {
'name': '小明', 'age': 18}
print(dic.items()) # dict_items([('name', '小明'), ('age', 18)])
3.字典的嵌套
用一个简单的例子说明字典的嵌套
dic = {
'name':'汪峰',
'age':48,
'wife':[{
'name':'国际章','age':38}],
'children':{
'girl_first':'小苹果','girl_second':'小怡','girl_three':'顶顶'}
}
# 1. 获取汪峰的名字。
print(dic['name'])
# 2.获取这个字典：{'name':'国际章','age':38}。
print(dic['wife'][0])
# 3. 获取汪峰妻子的名字。
print(dic['wife'][0]['name'])
# 4. 获取汪峰的第三个孩子名字。
print(dic['children']['girl_three'])
3.关于拆包应用到字典
a,b = 1,2
print(a,b)#1 2
a,b = ('你好','世界') # 元组的拆包
print(a,b)#你好 世界
a,b = ['你好','大飞哥']# 列表的拆包
print(a,b)#你好 大飞哥
a,b = {
'汪峰':'北京北京','王菲':'天后'}# 字典的拆包
print(a,b)#汪峰 王菲
6.Set（集合）
集合是一个无序的不重复元素序列
1.集合的创建
#方法一：
se1 = {
1, 2, 8, 2}
print(se1)
#方法二：
se2 = set({
1, 2, 8, 2})
print(se2)
强调：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典
se1 = set()
print(type(se1))#2.集合的增加和删除
由于集合是无序的、不重复的，所以集合在储存元素时会自动删除重复的元素，并且无序性使之不能查找单个元素
2.1集合的增加
#方法一：add
se1 = {
1, 2, 8, 2}
se1.add('小明')
print(se1)#{8, 1, 2, '小明'}
#方法二：update
se1 = {
1, 2, 8, 2}
# se1.update('小明')
# print(se1)#{1, 2, '明', 8, '小'}
se1.update(['xiaoming', 'xiaoai'])
print(se1)#{1, 2, 'xiaoming', 8, 'xiaoai'}
2.2集合的删除
set1 = {
1, 2, 8, 2}
set1.remove(8) # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
3.集合的关系测试
3.1交集（& 或者 intersection）
set1 = {
1,2,3,4,5}
set2 = {
4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
3.2并集（| 或者 union）
set1 = {
1,2,3,4,5}
set2 = {
4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7,8}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7,8}
3.3差集（- 或者 difference）
set1 = {
1,2,3,4,5}
set2 = {
4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
3.4反交集（^ 或者 symmetric_difference）
set1 = {
1,2,3,4,5}
set2 = {
4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
3.5子集与超集
set1 = {
1,2,3}
set2 = {
1,2,3,4,5,6}
print(set1 < set2)
print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。
print(set2 > set1)
print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。
四、Python3中的基础数据类型图
五、基础数据类型的常见问题
1、元组
元组中如果只含有一个元素且没有逗号，则该元组不是元组，与改元素数据类型一致，如果有逗号，那么它是元组。
tu = (1)
print(tu, type(tu)) # 1 2、列表
在循环一个列表时的过程中，如果你要改变列表的大小（增加值，或者删除值），那么结果很可能会出错或者报错
例题：删除列表li = [11, 22, 33, 44, 55]中索引为奇数对应的元素删除
正常思路解题：循环列表，然后进行判断，只要他的索引为奇数，就删除
li = [11, 22, 33, 44, 55]
for i in range(len(li)):
if i % 2 != 0:
li.pop(i)
print(li)#[1, 3, 4]
按照题目要求应该得到： [11， 33， 55]，但通过上述方法得到的结果却是：[11, 33, 44]，原因如下：
解决方法：
方法一：直接删除
li = [11, 22, 33, 44, 55]
del li[1::2]
print(li)
方法二：倒序删除
li = [11, 22, 33, 44, 55]
for i in range(len(li) - 1, -1, -1):
if i % 2 != 0:
li.pop(i)
print(li)
方法三：置换
li = [11, 22, 33, 44, 55]
new_li = []
for i in range(len(li)):
if i % 2 == 0:
new_li.append(li[i])
print(new_li)
注意：循环一个列表时，如果要改变其大小，一定要注意最终结果可能会出错或报错！
3、字典
在循环一个字典的过程中，不要改变字典的大小（增，删字典的元素），这样会直接报错。
例题：将字典中dic = {‘k1’:‘AA’, ‘s2’:‘BB’, ‘k3’:‘CC’, ‘s4’:‘DD’}键值带‘k’的元素删除
正常思路：遍历字典，然后判断键值是否带‘k’，如果带，则删除
dic = {
'k1':'AA', 's2':'BB', 'k3':'CC', 's4':'DD'}
for key in dic:
if 'k' in key:
del dic[key]
print(dic)#报错：RuntimeError: dictionary changed size during iteration
按照题目要求应该得到：{‘s2’:‘BB’, ‘s4’:‘DD’}，但通过上述方法得到的结果却是：错误信息RuntimeError: dictionary changed size during iteration。
解决办法：
方法一：把字典的键值添加到列表，然后循环列表删除字典对应值
dic = {
'k1':'AA', 's2':'BB', 'k3':'CC', 's4':'DD'}
li = []
for key in dic:
if 'k' in key:
li.append(key)
for i in li:
dic.pop(i)
print(dic)#{'s2': 'BB', 's4': 'DD'}
方法二：直接循环字典键值，并将其强制转换成列表
dic = {
'k1':'AA', 's2':'BB', 'k3':'CC', 's4':'DD'}
for key in list(dic.keys()):
if 'k' in key:
dic.pop(key)
print(dic)#{'s2': 'BB', 's4': 'DD'}