Python3基础篇（二）——数据类型

前言：
阅读这篇文章我能学到什么？
  这篇文章将为你介绍Python3的几种数据类型以及对这些数据类型的简单操作。

1 Python3变量的一般特征

  与大多数脚本类似，Python3中变量的不需要单独定义，首次赋值即定义。由于赋值即完成定义的特征，在变量使用前都必须赋值（即使用前必须定义）。
  对于Python3来说变量是不分类型的，我们讨论的皆为数据的类型，也即存储在变量内存当中的对象数据的类型。（所以标题叫数据类型而不是变量类型）
与其他语言类似，我们使用=作为赋值操作符，将右侧表达式的值赋值给左侧变量，这个过程即完成了变量在内存空间的创建，也完成了表达式值的计算和存储。

1
2
a = 1 + 1               #创建变量a，计算右侧表达式值并赋值给变量a
b = a                   #变量之间赋值

  对变量赋值操作。

1
2
3
4
a = 100                 #a中存储整形数据
a = 0.0001              #a中存储浮点数据
a = 'string'            #a中存储字符串数据
print(a)                #打印变量a的值

  对变量a进行多种数据类型存储。

1
2
3
4
5
6
7
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必须是唯一的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#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函数可以查看数据类型。
输入结果：

1
2
3
4
5
6
7
8
9
10
<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一大特点是对整型没有大小限制，这一点也是为了方便表达和运算。

1
2
3
4
number1 = 99999999999999999999999999999999999999999999
number2 = 33333333333333333333333333333333333333333333
number3 = number1 + number2
print(number3)

输出结果为：133333333333333333333333333333333333333333332
  处理这样长串的数据对python来说毫无难度，对c来说会是很头疼的事。

3.1.2 int的表示形式

  python支持int类型的十进制、十六进制、八进制、二进制表示。

1
2
3
4
5
6
7
8
9
10
11
#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类型也可以和操作符结合构成表达式计算结果。这里简单带过，后面讲运算符时会详细讲解。

1
2
3
4
5
6
7
print(1 + 2)
print(2 * 3)
print(4 / 2)            #/运算的结果为浮点
print(5 - 2)
print(10 % 2)           #取余
print(3 ** 2)           #3的2次方
print(3 // 2)           #除法，但是舍小数取整

运行结果为：

1
2
3
4
5
6
7
3
6
2.0
3
0
9
1

3.2 float

3.2.1 float的长度

  和int不一样，Python3的float类型能表示的长度是有限制的，它更像是c/c++中的双精度double类型。Python3对于浮点默认是提供17位数字的精度。

1
2
3
4
5
6
number1 = 9.9999999999999999999999999999999999999999999             #浮点有效位并不能达到这么多，精度将会丢失
number2 = 3.3333333333333333333333333333333333333333333             #浮点有效位并不能达到这么多，精度将会丢失
number3 = number1 + number2
print(number1)
print(number2)
print(number3)

输出结果为：

1
2
3
10.0
3.3333333333333335
13.333333333333334

  可以看到python的浮点表示的数据长度是有限的，在使用时我们要注意有效位的问题。

3.2.2 float的表示形式

  • 科学表示法
1
2
3
4
5
6
number1 = 3e+2                              #指数是正数时，+号可省略
number2 = 1000E-2                           #e可以大写为E

print(number1)
print(number2)
print(type(3e+2))                           #科学表示法是float类型

  科学表示法是float类型，不要认为计算结果是整数就是int类型。e表示的不是数学中的自然对数的底数，同c/c++一样，Python3中aeb表示的是$a \times 10^b$。 ==注意== 科学计数法表示只能是常量，这里的a和b都不能写成变量。

3.2.3 float的运算

  float的运算同int的运算，这里也是简略看下示例代码，等后面讲操作符时详细讲。

1
2
3
4
5
6
7
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)           #除法，但是舍小数取整

输出结果为：

1
2
3
4
5
6
7
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)$，即包含索引是1的字符，但不包含索引是5的字符，所以得到的字符串是'01234'。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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])

输出结果为：

1
2
3
4
5
6
7
8
0123456
0123456
123456
012345
12345
12345
12345
12345

截取子字符串是不会修改原变量值的。

4.2 转义字符

转义字符 含义
\ 反斜杠
' 单引号
" 双引号
\a 响铃
\b 退格
\0 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\o 八进制
\x 十六进制
\other 其他字符以普通格式输出 
1
2
3
4
5
6
7
8
print('\\')                 #输出\
print('\'')                 #输出'
print('\"')                 #输出"
print('123\b')              #退格，删除字符3
print('ab\ncd')             #换行
print('ab\tcd')             #横向制表符
print('ab\rcd')             #回车
print('A\x0aA')             #回车

输出结果为：

1
2
3
4
5
6
7
8
9
10
\
'
"
12
ab
cd
ab	cd
cd
A
A

4.3 字符串运算

操作符 作用
+ 字符串连接
* 重复输出字符串
[] 索引字符串中字符
in 成员运算符，判断某字符是否存在字符串中，结果为bool型
not in 成员运算符，判断某字符是否不存在字符串中，结果为bool型
r/R 原始字符串，被该运算符修改的字符串直接按照字面意思使用，不含转义字符或不能打印的字符。
% 格式字符串 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)

输出结果为：

1
2
3
4
5
6
7
8
9
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的简写 
1
2
3
4
5
6
7
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显示

输出结果为：

1
2
3
4
5
A, abc, -10, 5
-5
12, a, A
1.999990, 3.141593e+00, 3.141593E+00
1e+12, 999, 1E+11, 999

格式化字符时的辅助字符：

符号 作用
. .号前表明字最小段宽度后表示小数位精度
* 表明字段最小宽度或者小数位精度，与.一起使用后字段宽度和精度数从参数中读取
- 用做左对齐
+ 在正数前面显示加号+
<sp> 在正数前面显示空格，比如% f或% f，与空格数无关
# 在八进制数前面显示0，在十六进制前显示0x或0X
0 再试的数字前面填充0
% %%输出一个%字符 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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))                                                      #\$不会被转义，%%表示输出一个%号

输出结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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三引号是可以跨越多行的字符串，其字符串中可以包含转义字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#三引号字符串，所见即所得。也能使用转义字符。
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)

输出结果为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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格式，{}内进行计算和替换。

1
2
3
4
5
6
7
8
9
10
11
12
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)

输出结果为：

1
2
3
4
5
6
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 创建元组

  • 创建空元组
1
2
Tuple = ()                      #因为元组不能修改，所以创建空元组一般没啥用
print(type(Tuple))

输出结果为：

1
<class 'tuple'>

  使用()来创建元组，若元素为空则表示创建空元组，因为元组不能修改，所以创建空元组一般没啥用。

  • 创建单元素元组
1
2
3
4
Tuple = (1, )                           #创建单元素元祖时，元素后需要加,号，否则会把()内当做表达式处理
number = (1)
print(type(Tuple))
print(type(number))

输出结果为：

1
2
<class 'tuple'>
<class 'int'>

  创建单元素元组时，元素后要加,符号，否则会被判定为表达式。

  • 创建多个元素元组
1
2
3
4
Tuple1 = (1, 2)                             #多个元素
Tuple2 = (1, 2,)                            #每个元素后都跟一个,号是被允许的
Tuple3 = ('a', 'b', Tuple1)                 #嵌套元祖，元组元素可由不同类型元素组成
print(Tuple3)

输出结果为：

1
('a', 'b', (1, 2))
  • 创建一个元素同于其他元组的元组
1
2
3
4
5
6
7
8
9
10
Tuple1 = ()                 #创建空元组
Tuple2 = (1,)               #创建单元素元组
Tuple3 = (1, "2")           #创建多元素元组
Tuple4 = Tuple1             #创建元组，其元素同Tuple1元组
Tuple5 = Tuple2
Tuple6 = Tuple3

print(Tuple1, Tuple4)
print(Tuple2, Tuple5)
print(Tuple3, Tuple6)

输出结果为：

1
2
3
() ()
(1,) (1,)
(1, '2') (1, '2')

5.2 访问元组

  对元组的访问是指对元组元素的访问。元组是有序的，其访问方式同前面提到的字符串的索引访问，正向索引时第一个元素的索引号是0，索引号从0开始递增，反向索引时最后一个元素索引号-1，索引从-1开始递减。每个元素有正负两个索引号。当然，同样也支持像字符串那样用[:]区间截取。

1
2
3
4
5
6
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
4
1, 2, 3.0
1, 2, 3.0
('2', 3.0)
('2', 3.0)

5.3 元组运算

  由于元组的元素不能修改，所以其运算相对简单。其运算有将多个元组使用+进行拼接产生新的元祖，使用*产生内容重复的新元组，使用in或not in判断元素是否存在元组中。另外还有一些元组的内置函数这里就不讲了，查一下文档会更详细。

1
2
3
4
5
6
7
8
9
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)                          #判断元素是否不存在元组中

输出结果为：

1
2
3
4
5
6
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 创建列表

  • 创建空列表
1
2
List = []
print(type(List))

输出结果为：

1
<class 'list'>

  使用[]来创建列表，不同于元组，空列表后续可以增添和修改值。

  • 创建多个元素元组
1
2
3
4
5
6
7
8
9
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)

输出结果为：

1
2
3
4
5
<class 'list'>
[1]
[1, '2', 3.0]
[1, '2', 3.0]
[1, [1, '2', 3.0]]

  创建只含一个元素的列表时，不需要像元组那样必须加一个,号，因为元组的符号是()会与表达式表示冲突，而列表是[]不会与表达式冲突。

  • 创建一个元素同于其他列表的列表
1
2
3
4
5
6
7
8
9
10
List1 = []                 #创建空列表
List2 = [1,]               #创建单元素列表
List3 = [1, "2"]           #创建多元素列表
List4 = List1              #创建列表，其元素同List1列表
List5 = List2
List6 = List3

print(List1, List4)
print(List2, List5)
print(List3, List6)

输出结果为：

1
2
3
[] []
[1] [1]
[1, '2'] [1, '2']

6.2 访问列表

  列表也是有序存储，同字符串和数组一样，列表也是通过元素的序号进行访问。每个元素同样都有正负两个序号，同样是使用[]符号进行索引，使用[:]进行截取。

1
2
3
4
5
6
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
4
1, 2, 3.0
1, 2, 3.0
['2', 3.0]
['2', 3.0]

6.3 列表运算

  列表的运算除了列表之间的运算，还有对列表内元素的运算。

  • 列表中元素的修改
1
2
3
4
5
6
7
8
9
10
11
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
4
[1, '2', 3.3]
[1, '2', 3.3, 4]
[1, '2', 3.3, 4.4, 4]
[1, '2', 3.3, 4]
  • 列表之间的运算
1
2
3
4
5
6
7
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
4
[1, 2, 3, 'a', 'b', 'c']
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True
True

  关于列表的操作还有很多内置的函数，这里就不一一讲了。

7 Set

  集合是一些不重复元素的集合，这些元素在集合内是无序的，不像元组和列表那样每个元素都有确定且有序的索引号。Python3的集合概念很像数学里的集合概念。创建集合时使用{}，但当创建空集合时必须使用set()，因为无元素的{}表示创建空的字典，有冲突所以只能满足其一。

7.1 创建集合

  • 创建空集合
1
2
3
Set = set()                 #创建空集合，输出空集合显示为"set()"
print(type(Set))
print(Set)

输出结果为：

1
2
<class 'set'>
set()
  • 创建非空集合
1
2
3
4
5
6
7
8
9
10
11
12
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
2
3
4
5
{1}
{1, 3.0, '2'}
{'b', 'a', 'f', 'e', 'c', 'd'}
{1, 2, (1, 3)}
set()

  以上程序你可以试着多运行几次，你会发现集合中元素的顺序不是固定的。

7.2 访问集合

  集合元素是无序的，因此不能通过索引进行访问。讨论”元素位于集合中第几个？“这样的问题是没有意义的，集合中的元素是不重复的（如果放入重复元素，那么也只会有一个有效），我们关心的是某些元素存在还是不存在某个集合中，以及集合之间的运算。

1
2
3
4
5
6
7
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
3
4
{1, 2}
{1, 2}
True
True

7.3 集合的运算

1
2
3
4
5
6
7
8
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的元素，或者说两集合的差异元素。

输出结果为：

1
2
3
4
5
6
{'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集合内置函数的运用，这里就不介绍了，我们主要讨论的是几种数据类型的特性。几种类型的内置函数都比较相似，很容易掌握和记忆。

8 Dictionary

  字典是很强大的数据类型，已经有较多脚本语言都支持字典类型。字典也集合一样也使用{}进行表示。每个元素都由一个键和一个值构成，键在字典中必须是唯一的，因为字典也是无序的，字典中两个元素你说不清楚谁先谁后，元素是靠键来索引的。不同元素的值是允许重复和修改的。其元素的值可以是任意类型，但键是不允许修改的（键可以是常量——字符串、数字、元组），所以你想修改字典中某个元素的键，请将该元素删除后重新添加。

8.1 创建字典

  • 创建空字典
1
2
dic = {}
print(type(dic))

输出结果为：

1
<class 'dict'>
  • 创建非空字典
1
2
3
4
5
6
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
2
3
{1: 1}
{1: 1, '2': '2', 3.0: 3.0, (1, 4): (1, 4), 5: [1, 2], 6: {1, 6}}
{1: 2}

8.2 访问字典

  因为字典是无序的，所以不能按序号访问，但是每个元素都有唯一的键値，字典是按键値访问的。

1
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
1 2

8.3 字典运算

  字典主要用于查询，对字典的操作主要是对字典中元素的操作，所以字典之间没有啥运算。

1
2
3
4
5
6
7
8
9
10
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
2
3
4
{1: 1, '2': 2}
{1: 1}
{}
{5: 5}

  字典同样也有很多内置函数，这些库函数需要用的时候边查边学比较好。