python3基础篇（二）——数据类型
1 阅读这篇文章我能学到什么？
这篇文章将为你介绍python3的几种数据类型以及对这些数据类型的简单操作。
——如果您觉得这是一篇不错的博文，希望你能给一个小小的赞，感谢您的支持。
目录名
-
python3基础篇（二）——数据类型
1 python3变量的一般特征
与大多数脚本类似，python3中的变量不需要单独定义，首次赋值即定义。由于赋值即完成定义的特征，在变量使用前都必须赋值（即使用前必须定义）。
对于python3来说变量是不分类型的，我们讨论的皆为数据的类型，也即存储在变量内存当中的对象数据的类型。（所以标题叫数据类型而不是变量类型）
与其他语言类似，我们使用=作为赋值操作符，将右侧表达式的值赋值给左侧变量，这个过程即完成了变量在内存空间的创建，也完成了表达式的得计算和存储。
a = 1 + 1 #创建变量a，计算右侧表达式值并赋值给变量a
b = a #变量之间赋值
对变量赋值操作。
a = 100 #a中存储整形数据
a = 0.0001 #a中存储浮点数据
a = 'string' #a中存储字符串数据
print(a) #打印变量a的值
对变量a进行多种数据类型存储。
a = b = c = 0 #从右到左依次对三个变量赋值相同的值
d, e, f = 1, 0.2, "string" #对三个变量分别赋值，且类型不同
del a
del b
del c
del d, e, f
赋值操作是灵活的，定义的变量可以使用del关键词删除变量回收内存。变量被del之后不能再使用，除非重新定义。
2 有哪些数据类型
- Number（数字）：具体又有整形（int）、浮点（float）、复数（complex）、布尔（bool）四种类型。
- String（字符串）：被符号
'或"括起来的数据为字符串，与c/c++不同，python没有单个字符的字符类型，即使单个字符也被认为是字符串。- Tuple（元组）：写在
()内的多个元素构成一个整体，这些元素的类型可以不同，但是元素不能被修改。元组是有序的。- List(列表)：写在
[]内的多个元素构成一个整体，与元组类似元素类型同样可不同，但列表的元素可以被修改。列表同样是有序的。- Set（集合）：写在
{}内，类似数学概念的集合，由一个或多个各异的大小整体构成，这些整体称为集合的元素或成员。- Dictionary（字典）：写在
{}内，相比于列表，列表是有序的对象集合，字典是无序的对象集合。列表通过偏移来查找元素，字典通过键值来查找元素。字典的每个元素都由一个键値（key）和一个值（value）构成，一个字典中的key必须是唯一的。
#Number
print(type(1))
print(type(0.1))
print(type(1 + 2j))
print(type(True))
#String
print(type("String"))
print(type('String'))
#Tuple
print(type((1, 2)))
#List
print(type([1, 2]))
#Set
print(type({1, 2}))
#Dictionary
print(type({'key1':1, 'key2':2})
type函数可以查看数据类型。
输入结果：
<class 'int'>
<class 'float'>
<class 'complex'>
<class 'bool'>
<class 'str'>
<class 'str'>
<class 'tuple'>
<class 'list'>
<class 'set'>
<class 'dict'>
3 Number
3.1 int
3.1.1 int的长度
python3只有一种整数类型即长整型，表示为int，python取消了python2中的long类型。python3一大特点是对整型没有大小限制，这一点也是为了方便表达和运算。
number1 = 99999999999999999999999999999999999999999999
number2 = 33333333333333333333333333333333333333333333
number3 = number1 + number2
print(number3)
输出结果为：133333333333333333333333333333333333333333332
处理这样长串的数据对python来说毫无难度，对c来说会是很头疼的事。
3.1.2 int的表示形式
python支持int类型的十进制、十六进制、八进制、二进制表示。
#0x或0X表示16进制
print(0x0F) #16进制的A~F也可用小写a~f
print(0X0F)
#0o或0O表示8进制
print(0o07)
print(0O07)
#0b或0B表示2进制
print(0b00000101)
print(0B00000101)
3.1.3 int的运算
与其他计算与编程语言一样，python3好的int类型也可以和操作符结合构成表达式计算结果。这里简单带过，后面讲运算符时会详细讲解。
print(1 + 2)
print(2 * 3)
print(4 / 2) #/运算的结果为浮点
print(5 - 2)
print(10 % 2) #取余
print(3 ** 2) #3的2次方
print(3 // 2) #除法，但是舍小数取整
运行结果为：
3
6
2.0
3
0
9
1
3.2 float
3.2.1 float的长度
和int不一样，python3的float类型能表示的长度是有限制的，它更像是c/c++中的双精度double类型。python3对于浮点默认是提供17位数字的精度。
number1 = 9.9999999999999999999999999999999999999999999 #浮点有效位并不能达到这么多，精度将会丢失
number2 = 3.3333333333333333333333333333333333333333333 #浮点有效位并不能达到这么多，精度将会丢失
number3 = number1 + number2
print(number1)
print(number2)
print(number3)
输出结果为：
10.0
3.3333333333333335
13.333333333333334
可以看到python的浮点表示的数据长度是有限的，在使用时我们要注意有效位的问题。
3.2.2 float的表示形式
- 科学表示法
number1 = 3e+2 #指数是正数时，+号可省略
number2 = 1000E-2 #e可以大写为E
print(number1)
print(number2)
print(type(3e+2)) #科学表示法是float类型
科学表示法是float类型，不要认为计算结果是整数就是int类型。e表示的不是数学中的自然对数的底数，同c/c++一样，python3中aeb表示的是
3.2.3 float的运算
float的运算同int的运算，这里也是简略看下示例代码，等后面讲操作符时详细讲。
print(1.00002 + 2)
print(2e2 * 3)
print(4E-2 / 2) #/运算的结果为浮点
print(5.0 - 2.0)
print(10.2 % 2) #取余
print(3.2 ** 2.1) #3.2的2.1次方
print(3.0 // 2) #除法，但是舍小数取整
输出结果为：
3.00002
600.0
0.02
3.0
0.1999999999999993
11.503101568235094
1.0
4 String
python3的字符串类型由'或"括起来，在python3中单双引号的作用是等价的。要对字符串中的字符或子字符串操作时，需要结合[]进行访问。和其他脚本一样，python3也支持对字符串的运算，支持转义字符。python也支持格式化的字符串，f-string是3.6版本后新增的规则。python2对字符串有两种存储方式，一种是8位ASCII字符存储，一种是Unicode字符存储，而python3将所有字符都以Unicode字符存储。python3为了方便字符串操作，内建了很多字符串操作函数。
字符串的'和"虽然都能表示字符串，但是不能交叉匹配，比如'AAA"和"AAA'都是错误的字符串。另外引号嵌套时需要注意，比如"'AAA'"和'"AAA"'最外层的引号会配成一对，最后print得到字符串分别为'AAA'和"AAA"，而''AAA'’和""AAA""将会语法报错，因为相邻的引号之间会配对。如果是普通字符串你可以使用转义字符写为'\'AAA\''或"\"AAA\""。字符串嵌套时内外层使用不同的引号的运用主要是在f-string中，后文会讲到。
4.1 字符串的访问
对字符串的访问有两种操作，一种对对字符串索引得到字符串内的一个字符，另一种是对字符串进行截取得到子字符串。因为python将字符串进行有序存储，所以两种操作都是基于字符串中字符的索引号进行的。python字符串中每个字符都具有两个索引号，一正一负，正数表示从左往右（从首字符到末尾字符），从0递增时分配的索引。负数表示从右往左（从末尾字符到首字符），从-1递减时分配的索引。比如字符串"0123456"，字符0的索引是0也是-7，字符6的索引是-1也是6。
对字符串的字符索引时，可以在字符串变量后加上[]并在其中写上需要索引的字符的索引号。最终表达式的值就是只含有所需索引字符的字符串，前面提到过，python是没有只含单个字符的字符类型的，都是字符串类型。比如"0123456"[0]的值是字符串'0'。
&ems; 对字符串的截取。截取字符串就是通过运算符[:]设定区间的过程，比如"0123456[1:5]"得到的结果就是子字符串'01234'。由于python3字符串内每个字符具有两个索引号（一正一负，表示索引的方向不同），似乎使得[:]运算符的使用变得复杂，其实只要记住python的字符串截取区间是“左闭右开”的，比如"0123456[1:5]"截取的区间为
，即包含索引是1的字符，但不包含索引是5的字符，所以得到的字符串是'01234'。
str = '0123456' #字符串中每个字符都有对应索引（是有序的），索引从左到右从0开始步长为1累加
#访问字符串内字符，即索引字符
print(str[0]) #输出索引是0的字符
print(str[6]) #输出索引是6的字符
#访问整个字符串
print(str)
print(str[0:]) #左边0可以被省略，但是右边没有-0这种操作！
print(str[:])
#访问子字符串，即截取出子字符串
print(str[1:]) #从索引为1的字符截取至字符串结束
print(str[:6]) #从字符串起始截至索引为6的字符
print(str[1:6]) #从索引号为1的字符截取至索引号为6的字符
print(str[1:-1]) #从索引号为1的字符截取至索引号为-1的字符
print(str[-6:-1]) #从索引号为-6的字符截取至索引号为-1的字符
print(str[-6:6]) #从索引号为-6的字符截取至索引号为6的字符
#访问空字符串
print(str[3:3]) #当截取的区间长度小于等于0时，截取到的子字符串为空
print(str[3:2])
输出结果为：
0123456
0123456
123456
012345
12345
12345
12345
12345
截取子字符串是不会修改原变量值的。
4.2 转义字符
| 转义字符 | 含义 |
|---|---|
| \ | 反斜杠 |
| ’ | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格 |
| \0 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \o | 八进制 |
| \x | 十六进制 |
| \other | 其他字符以普通格式输出 |
print('\\') #输出\
print('\'') #输出'
print('\"') #输出"
print('123\b') #退格，删除字符3
print('ab\ncd') #换行
print('ab\tcd') #横向制表符
print('ab\rcd') #回车
print('A\x0aA') #回车
输出结果为：
\
'
"
12
ab
cd
ab cd
cd
A
A
4.3 字符串运算
| 操作符 | 作用 |
|---|---|
| + | 字符串连接 |
| * | 重复输出字符串 |
| [] | 索引字符串中字符 |
| in | 成员运算符，判断某字符是否存在字符串中，结果为bool型 |
| not in | 成员运算符，判断某字符是否不存在字符串中，结果为bool型 |
| r/R | 原始字符串，被该运算符修改的字符串直接按照字面意思使用，不含转义字符或不能打印的字符。 |
| % | 格式字符串 |
str1 = "abc"
str2 = "123"
print(str1 + str2) #字符串拼接
print(str1 * 3) #字符串重复3次
print(str1[1]) #索引字符
print(str1[1:2]) #截取子字符串
print("a" in str1) #判断str1中是否含有字符a
print("a" not in str2) #判断str2中是否不含有字符a
str3 = r"A\nA"
str4 = "A\nA"
print(str3)
print(str4)
输出结果为：
abc123
abcabcabc
b
b
True
True
A\nA
A
A
4.4 字符串格式化
python3的字符串格式化类似于c/c++的sprintf函数的用法。
| 格式 | 作用 |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整形 |
| %o | 格式化无符号八进制 |
| %x/%X | 格式化无符号十六进制数，大写X时十六进制数也相应大写 |
| %f | 格式化浮点数，可指定小数点后的精度 |
| %e/%E | 以科学计数法格式化浮点数，e的大小写决定科学计数法e的大小写 |
| %g/%G | 小写g是%f和%e的简写，大写G是%f和%E的简写 |
print("%c, %s, %d, %u" % ("A", "abc", -10.1, 5.1)) #可以看到%d和%u将浮点数格式化为整数
print("%u" % (-5.1)) #%u输出依然是带符号了，并没有转化为无符号数
print("%o, %x, %X" % (10, 10, 10)) #8进制和16进制，o不能大写，x的大小写对应16进制数的大小写
print("%f, %e, %E" % (1.99999, 3.14159265359, 3.14159265359))
print("%g, %g, %G, %G" % (999999999999, 999, 99999999999, 999)) #自动优化决定将浮点数按%f或%e/%G显示
输出结果为：
A, abc, -10, 5
-5
12, a, A
1.999990, 3.141593e+00, 3.141593E+00
1e+12, 999, 1E+11, 999
格式化字符时的辅助字符：
| 符号 | 作用 |
|---|---|
| . | .号前表明字最小段宽度后表示小数位精度 |
| * | 表明字段最小宽度或者小数位精度，与.一起使用后字段宽度和精度数从参数中读取 |
| - | 用做左对齐 |
| + | 在正数前面显示加好+ |
在正数前面显示空格，比如% f或% f，与空格数无关 |
|
| # | 在八进制数前面显示0，在十六进制前显示0x或0X |
| 0 | 再试的数字前面填充0 |
| % | %%输出一个%字符 |
print("%05.f, %05.0f, %05.f, %05.0f" % (33.0, 33.0, 333333.0, 333333.0)) #字段宽度最小宽度为5，用0补齐。.之后的0可省略，表示保留0位小数
print("%5.f" % (33.0)) #未指定用0补齐，则默认用空格补齐左端（默认右对齐）
print("%.5f, %0.5f" % (33.33, 33.33)) #保留小数后5位
print("%.5f" % (33.333333))
print("%0*.*f" % (6, 2, 33.0))
print("%-05.f" % (33.0)) #指定左对齐，空格在右端补齐
print("%+f, %+f" % (33.0, -33.0)) #如果是正数则显示正号
print("%f, %f" % (33.0, -33.0))
print("% f, % f" % (33.0, -33.0)) #在正数的符号位显示一个空格
print("% f" % (33.0)) #与空格数无关，最终只会显示一个空格
print("%o, %#o" % (33, 33))
print("%x, %#x, %#X" % (33, 33, 33))
print("%5.d, %05.d" % (33, 33)) #保持最小字段宽度，用0填补
print("%%d, \%d" % (33)) #\$不会被转义，%%表示输出一个%号
输出结果为：
00033, 00033, 333333, 333333
33
33.33000, 33.33000
33.33333
033.00
33
+33.000000, -33.000000
33.000000, -33.000000
33.000000, -33.000000
33.000000
41, 0o41
21, 0x21, 0X21
33, 00033
%d, \33
4.5 三引号
python三引号是可以跨越多行的字符串，其字符串中可以包含转义字符。
#三引号字符串，所见即所得。也能使用转义字符。
str1 = '''aaa
aaa
aaa'''
str2 = '''\
bbb
bbb
bbb
'''
str3 = '''
ccc
ccc
ccc\
'''
str4 = 'aaa\nbbb\nccc'
str5 = '''aaa
bbb
ccc\
'''
str6 = '''aaa\nbbb\nccc'''
print(str1)
print(str2)
print(str3)
print(str4) #str4 str5 str6输入同样字符串
print(str5)
print(str6)
输出结果为：
aaa
aaa
aaa
bbb
bbb
bbb
ccc
ccc
ccc
aaa
bbb
ccc
aaa
bbb
ccc
aaa
bbb
ccc
4.6 新字符串格式化语法——f-string
python3.6之后新增f-string特性，用于新的格式化字符串语法。与旧的格式化语法最大不同在于，新的格式化语法不用太关心数据的类型，旧的格式化语法需要使用%d和%f等表明语法格式。旧格式化语法使用%，新的格式化语法使用f声明字符串符合f-string格式，{}内进行计算和替换。
dic = {"int":3, "float":2.1, "string":"aaa"}
print("%d, %d, %f, %s" % (1 + 2, dic["int"], dic["float"], dic["string"])) #旧格式化方法
print(f"{1+1}, {dic['int']}, {dic['float']}, {dic['string']}") #新格式化方法
a = 1
print(f"{a+2}")
print(f"{a+2=}") #自动将结果添补在=号之后
str1 = "a + 2 = %d" % (a + 2)
str2 = f"{a + 2 = }"
print(str1)
print(str2)
输出结果为：
3, 3, 2.100000, aaa
2, 3, 2.1, aaa
3
a+2=3
a + 2 = 3
a + 2 = 3
5 Tuple
元组与列表相似。不同在于元组中的元素创建后就无法修改。元组使用()符号表示。元组的元素可以是不同的类型。虽然元组元素不允许修改，但是可以使用del删除整个元组。列表是有序的。
5.1 创建元组
- 创建空元组
Tuple = () #因为元组不能修改，所以创建空元组一般没啥用
print(type(Tuple))
输出结果为：
<class 'tuple'>
使用()来创建元组，若元素为空则表示创建空元组，因为元组不能修改，所以创建空元组一般没啥用。
- 创建单元素元组
Tuple = (1, ) #创建单元素元祖时，元素后需要加,号，否则会把()内当做表达式处理
number = (1)
print(type(Tuple))
print(type(number))
输出结果为：
<class 'tuple'>
<class 'int'>
创建单元素元组时，元素后要加,符号，否则会被判定为表达式。
- 创建多个元素元组
Tuple1 = (1, 2) #多个元素
Tuple2 = (1, 2,) #每个元素后都跟一个,号是被允许的
Tuple3 = ('a', 'b', Tuple1) #嵌套元祖，元组元素可由不同类型元素组成
print(Tuple3)
输出结果为：
('a', 'b', (1, 2))
- 创建一个元素同于其他元组的元组
Tuple1 = () #创建空元组
Tuple2 = (1,) #创建单元素元组
Tuple3 = (1, "2") #创建多元素元组
Tuple4 = Tuple1 #创建元组，其元素同Tuple1元组
Tuple5 = Tuple2
Tuple6 = Tuple3
print(Tuple1, Tuple4)
print(Tuple2, Tuple5)
print(Tuple3, Tuple6)
输出结果为：
() ()
(1,) (1,)
(1, '2') (1, '2')
5.2 访问元组
对元组的访问是指对元组元素的访问。元组是有序的，其访问方式同前面提到的字符串的索引访问，正向索引时第一个元素的索引号是0，索引号从0开始递增，反向索引时最后一个元素索引号-1，索引从-1开始递减。每个元素有正负两个索引号。当然，同样也支持像字符串那样用[:]区间截取。
Tuple = (1, '2', 3.0)
print(f"{Tuple[0]}, {Tuple[1]}, {Tuple[2]}") #索引元组的元素，正序号
print(f"{Tuple[-3]}, {Tuple[-2]}, {Tuple[-1]}") #索引元组的元素，负序号
print(f"{Tuple[1:]}") #区间截取
print(f"{Tuple[-2:]}")
输出结果为：
1, 2, 3.0
1, 2, 3.0
('2', 3.0)
('2', 3.0)
5.3 元组运算
由于元组的元素不能修改，所以其运算相对简单。其运算有将多个元组使用+进行拼接产生新的元祖，使用*产生内容重复的新元组，使用in或not in判断元素是否存在元组中。另外还有一些元组的内置函数这里就不讲了，查一下文档会更详细。
Tuple1 = (1, 2, 3)
Tuple2 = (3, 2, 1)
print(len(Tuple1)) #元组长度
print(Tuple1+Tuple2) #元组相加为元组元素的拼接
print((1, 2) + Tuple2) #元组拼接
print(Tuple1 * 3) #赋值3倍元组
print(3 in Tuple1) #判断元素是否存在元组中
print(4 not in Tuple1) #判断元素是否不存在元组中
输出结果为：
3
(1, 2, 3, 3, 2, 1)
(1, 2, 3, 2, 1)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
True
True
6 List
python的列表是运用较为频繁的数据类型，其与元组非常像，区别在于列表的元素可以被修改。列表使用[]表示。元素类型也可以不同。列表也是有序的。
6.1 创建列表
- 创建空列表
List = []
print(type(List))
输出结果为：
<class 'list'>
使用[]来创建列表，不同于元组，空列表后续可以增添和修改值。
- 创建多个元素元组
List1 = [1] #只含一个元素，[]符号不会与表达式冲突，因此不需要加,号
List2 = [1, "2", 3.0] #含有多个元素的列表创建，可以由不同类型元素构成
List3 = [1, "2", 3.0,] #创建列表，可以在每个元素末尾后加,
List4 = [1, List2] #嵌套列表，创建多元素列表
print(type(List1))
print(List1)
print(List2)
print(List3)
print(List4)
输出结果为：
<class 'list'>
[1]
[1, '2', 3.0]
[1, '2', 3.0]
[1, [1, '2', 3.0]]
创建只含一个元素的列表时，不需要像元组那样必须加一个,号，因为元祖的符号是()会与表达式表示冲突，而列表是[]不会与表达式冲突。
- 创建一个元素同于其他列表的列表
List1 = [] #创建空列表
List2 = [1,] #创建单元素列表
List3 = [1, "2"] #创建多元素列表
List4 = List1 #创建列表，其元素同List1列表
List5 = List2
List6 = List3
print(List1, List4)
print(List2, List5)
print(List3, List6)
输出结果为：
[] []
[1] [1]
[1, '2'] [1, '2']
6.2 访问列表
列表也是有序存储，同字符串和数组一样，列表也是通过元素的序号进行访问。每个元素同样都有正负两个序号，同样是使用[]符号进行缩影，使用[:]进行截取。
List = [1, '2', 3.0]
print(f"{List[0]}, {List[1]}, {List[2]}") #索引列表的元素，正序号
print(f"{List[-3]}, {List[-2]}, {List[-1]}") #索引列表的元素，负序号
print(f"{List[1:]}") #区间截取
print(f"{List[-2:]}")
输出结果为：
1, 2, 3.0
1, 2, 3.0
['2', 3.0]
['2', 3.0]
6.3 列表运算
列表的运算除了列表之间的运算，还有对列表内元素的运算。
- 列表中元素的修改
List = [1, "2", 3.0]
List[2] = 3.3 #修改列表元素的值
print(List)
#List[3] = 4 #此时列表还没有序号是3的元素，这样操作并不是新增元素，会语法错误
List.append(4) #使用列表内置函数为列表中新增一个元素
print(List)
List.insert(3, 4.4) #使用列表内置函数在序号3处插入一个元素，后续元素依次往后移动
print(List)
List.pop(3) #移除需序号3的元素
print(List)
输出结果为：
[1, '2', 3.3]
[1, '2', 3.3, 4]
[1, '2', 3.3, 4.4, 4]
[1, '2', 3.3, 4]
- 列表之间的运算
List1 = [1, 2, 3]
List2 = ['a', 'b', 'c']
print(List1 + List2) #将两个列表拼接
print(List1 * 3) #将列表重复3次
print(3 in List1) #判断List1中是否存在值为3的元素
print(4 not in List1) #判断List1中是否不存在值为4的元素
del List1, List2 #删除List2
输出结果为：
[1, 2, 3, 'a', 'b', 'c']
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True
True
关于列表测操作还有很多内置的函数，这里就不一一讲了。
7 Set
集合是一些不重复元素的集合，这些元素在集合内是无序的，不想元组和列表那样每个元素都有确定且有序的索引号。python3的集合概念很像数学里的集合概念。创建集合时使用{}，但当创建空集合时必须使用set()，因为无元素的{}表示创建空的字典，有冲突所以只能满足其一。
7.1 创建集合
- 创建空集合
Set = set() #创建空集合，输出空集合显示为"set()"
print(type(Set))
print(Set)
输出结果为：
<class 'set'>
set()
- 创建非空集合
Set1 = {1,} #创建单元素集合
Set2 = {1, "2", 3.0} #创建多元素集合，元素可以是不同类型
Set3 = set("aaabcdef") #使用set函数带一个字符串参数创建集合时，集合元素为字符串中每个字符构成的集合，元素不能重复。
#Set4 = {1, 2, {1, 3}} #集合不能嵌套定义
#Set5 = {1, 2, [1, 3]} #列表不能作为集合元素
Set6 = {1, 2, (1, 3)} #元组可以作为集合的元素
print(Set1)
print(Set2)
print(Set3)
Set1.pop() #集合Set1中只有一个元素，将这个元素弹出后变空元素
print(Set1)
输出结果为：
{1}
{1, 3.0, '2'}
{'b', 'a', 'f', 'e', 'c', 'd'}
{1, 2, (1, 3)}
set()
以上程序你可以试着多运行几次，你会发现集合中元素的顺序不是固定的。
7.2 访问集合
集合元素是无序的，因此不能通过索引进行访问。讨论”元素位于集合中第几个？“这样的问题是没有意义的，集合中的元素是不重复的（如果放入重复元素，那么也只会有一个有效），我们关心的是某些元素存在还是不存在某个集合中，以及集合之间的运算。
Set1 = {1, 1, 2, 2} #尝试创建有重复元素的集合
print(Set1)
Set1.add(1) #继续往里添加重复元素
print(Set1)
print(1 in Set1) #判断集合Set1中是否含有元素1
print(3 not in Set1) #判断集合Set1中是否不含元素3
输出结果为：
{1, 2}
{1, 2}
True
True
7.3 集合的运算
Set1 = set("aaabcdef")
Set2 = set("abefgh")
print(Set1)
print(Set2)
print(Set1 - Set2) #集合作差，从集合Set1中去掉两集合共同有的元素。或者说集合Set1有而Set2没有的元素
print(Set1 | Set2) #集合Set1或Set2中含有的元素
print(Set1 & Set2) #集合Set1和Set2都含有的元素
print(Set1 ^ Set2) #不同时存在于集合Set1和Set2的元素，或者说两集合的差异元素。
输出结果为：
{'e', 'a', 'f', 'd', 'b', 'c'}
{'h', 'e', 'g', 'a', 'f', 'b'}
{'d', 'c'}
{'h', 'e', 'g', 'a', 'f', 'd', 'b', 'c'}
{'a', 'b', 'f', 'e'}
{'h', 'g', 'd', 'c'}
python3集合的概念类似数学中集合的概念。
关于集合中元素的增添，删除，求集合的大小等操作其实就是python3集合内置函数的运用，这里就不介绍了，我们主要讨论的是几种数据类型的特性。几种类型的内置函数都比较相似，很容易掌握和记忆。
8 Dictionary
字典是很强大的数据类型，已经有较多脚本语言都支持字典类型。字典也集合一样也使用{}进行表示。每个元素都由一个键和一个值构成，键在字典中必须是唯一的，因为字典也是无序的，字典中两个元素你说不清楚谁先谁后，元素是靠键来索引的。不同元素的值是允许重复和修改的。其元素的值可以是任意类型，但键是不允许修改的（键可以是常量——字符串、数字、元组），所以你想修改字典中某个元素的键，请将该元素删除后重新添加。
8.1 创建字典
- 创建空字典
dic = {}
print(type(dic))
输出结果为：
<class 'dict'>
- 创建非空字典
dic1 = {1:1} #创建单元素字典
dic2 = {1:1, "2":"2", 3.0:3.0, (1, 4):(1, 4), 5:[1, 2], 6:{1, 6}} #键可以是常亮字符串、数字、元组，而值可以是任意类型
dic3 = {1:1, 1:2} #相同的键被赋多次值事，值只会是最新的依次。
print(dic1)
print(dic2)
print(dic3)
输出结果为：
{1: 1}
{1: 1, '2': '2', 3.0: 3.0, (1, 4): (1, 4), 5: [1, 2], 6: {1, 6}}
{1: 2}
8.2 访问字典
因为字典是无序的，所以不能按序号访问，但是每个元素都有唯一的键値，字典是按键値访问的。
dic1 = {1:1, "2":"2", 3.0:3.0, (1, 4):(1, 4), 5:[1, 2], 6:{1, 6}} #键可以是常亮字符串、数字、元组，而值可以是任意类型
print(dic1[1], dic1["2"]) #按键値访问字典
输出结果为：
1 2
8.3 字典运算
字典主要用于查询，对字典的操作主要是对字典中元素的操作，所以字典之间没有啥运算。
dic1 = {1:1, "2":"2"}
dic1["2"] = 2 #修改字典中键对应的元素值
print(dic1)
del dic1["2"] #删除键对应的元素
print(dic1)
dic1.clear() #清空字典所用元素
print(dic1)
dic1[5] = 5 #字典中添加新元素，直接往新键里写值会自动创建新元素
print(dic1)
del dic1 #删除整个字典
输出结果为：
{1: 1, '2': 2}
{1: 1}
{}
{5: 5}
字典同样也有很多内置函数，这些库函数需要用的时候边查边学比较好。
