Python数据类型_python shujuleix-CSDN博客

本文链接：https://blog.csdn.net/shayuwei/article/details/88998517

文章目录

1 运算符

运算符，即具有特殊计算规则的符号。运算符涉及到的，参与运算的数据，称为操作数。不同的运算符，涉及的操作数也不相同。例如，加法运算符“+”涉及两个操作数，而负号运算符“-”则涉及一个操作数。运算符涉及几个操作数，我们就称该运算符是几元运算符，例如，加法运算符“+”为二元运算符，而负号运算符“-”为一元运算符。由运算符与操作数结合起来的计算式，称为“表达式”。

我们可以将运算符分为如下几类：

算术运算符
比较运算符
身份运算符
布尔运算符
位运算符
赋值运算符

1.1 算术运算符

算术运算符用来进行类似数学上的加减乘除运算。

符号	说明
x + y	加法运算，返回x与y的和
x – y	减法运算，返回x与y的差
x * y	乘法运算，返回x与y的积
x / y	除法运算，返回x与y的商（浮点类型）
x // y	除法运算，返回x与y的商（向下取整）
x % y	取模运算，返回x模y的结果（求余数）
x ** y	乘方运算，返回x的y次方
+x	正号，x的值不会改变，该符号可以省略
-x	负号，取x的相反数

在除法运算时，除数不能为0，否则会产生错误（ZeroDivisionError）。

算术运算符的使用。注意取余与取模的差别。

x=5
y=10
# y/x返回的是float类型
print(y/x)
print(type(y/x))
# y//x返回的是int类型
print(y//x)
print(type(y//x))

# 整除只有整数除以整数才是int类型
print(10//3)
print(type(10//3))
print(10//3.5)
print(type(10//3.5))
print(10.5//3.5)
print(type(10.5//3.5))
# //是向下取整
print(5//2.5)

# 输出一个三位整数的百位、十位、个位
num=int(input("请输入一个三位的整数"))
a=num//100
#b=(num-a*100)//10
b=num//10%10
#c=num-a*100-b*10
c=num%10
print("这个数是:",num,"百位是：",a,"十位是：",b,"个位是：",c)

在这里插入图片描述

1.2 比较运算符

比较运算符执行的是比较运算，如果表达式成立，返回True，否则返回False。

符号	说明
x > y	如果x大于y，返回True，否则返回False
x >= y	如果x大于等于y，返回True，否则返回False
x < y	如果x小于y，返回True，否则返回False
x <= y	如果x小于等于y，返回True，否则返回False
x == y	如果x等于y，返回True，否则返回False
x != y	如果x不等于y，返回True，否则返回False

在Python语言中，比较运算符支持链式比较。x < y < z相当于x < y and y < z，不同之处仅在于，后者中y只会计算一次。链式比较与拆分成and或or连接的表达式一样，也会进行短路操作。

1.3 身份运算符

is与 ==，is not与!=的区别:

== 与!=比较的是对象内部的值是否相等，而is与is not比较的是两个对象是否为同一个对象。

条件	结果
x is y	如果x与y是同一个对象，返回True，否则返回False
x is not y	如果x与y是不同的对象，返回True，否则返回False

1.4 布尔（逻辑）运算符

布尔运算符也称逻辑运算符，列表如下：

符号	说明
x and y	如果x为True，返回y，否则返回x
x or y	如果x为True，返回x，否则返回y
not x	如果x为True，返回False，否则返回True

x与y未必一定是布尔类型（取值为True与False），实际上，x与y可以是任意类型，因为在Python中，任意类型都可以转换为布尔类型。and与or运算符总是会返回x与y二者中的一个。

#x=5>3，y=s>3,如果x是true，返回y，否则返回x
compare=5>3 and 2>3
print(compare)							#F
# 短路现象:第一个成立就不看第二个了
compare1=2>3 and 5>3
print(compare1)							#F

#如果x为true返回x，否则返回y
compare2=5>3 or 2>3
print(compare2)							#T
compare3=2>3 or 3>5
print(compare3)							#F
# 短路
compare4=5>3 or 3>2
print(compare4)							#T

# 如果x为true则返回false
compare5=not 5>3
print(compare5)							#F
compare6=not 3>5
print(compare6)							#T

短路
and与or运算符会执行短路操作。

1.5 位运算符（不常用）

原码、反码、补码
正数：原码、反码、补码都是二进制码
负数：原码：正数的二进制码，最高位取1
反码：除最高位以外，其余取反
补码：反码+1
计算机中以补码存储

位运算符提供的是对位（bit）进行的操作。位运算符的操作数要求是整数类型（布尔类型）。位运算符如下表所示：

符号	说明
x & y	x与y按位与运算，如果两个位都是1，结果为1，否则结果为0（有0则结果为0）
x	y
x ^ y	x与y按位异或运算，如果两个位相同，则结果为0，如果两个位不同，则结果为1（有1则为1，但又不同时为1）
x << y	将x向左移动y位，右侧以0进行填充。y不能为负值，否则会产生ValueError
x >> y	将x向右移动y位，左侧以符号位进行填充。y不能为负值，否则会产生ValueError
~x	对x进行按位取反，即1变为0，0变为1

说明：

布尔类型作为整数类型的子类型，也可以参与位运算，但是，最好不要这样，因为布尔类型的作用是进行逻辑上的判断，而不是当成数值1与0参与数学运算。

1.6 赋值运算符

赋值运算符包括简单赋值运算符与复合赋值运算符。

符号	说明
x = y	简单赋值运算。即x关联y所关联的对象
x op= y	复合赋值运算。op可以是任意二元算术运算符与二元位运算符

x op= y相当于x = x op y。例如x += y相当于x = x + y。

说明：

x op= y与x = x op y并非完全等价，原因我们在后面说明。

# 复合赋值运算
a=3
a+=2    			#相当于a=a+2
print(a)			#结果是5

1.7 成员运算符

In not in
判断子元素是否在当前序列中

1.8 运算符优先级

算数运算符> 比较运算> 逻辑运算> 赋值运算符

运算符优先级
. () []
**
+（正号） -（负号） ~
* / // %
+ -
<< >>
&
^
丨
in not in is is not < <= > >= == !=
not
and
or
= op=（+ - * / // % ** >> << & ^

在更多的时候，我们没有必要刻意去记忆优先级的顺序。当我们在使用表达式，无法确定优先级时，我们可以使用小括号（）来调整表达式的结合性，小括号（）的优先级是最高的（这点与数学上相同）。

优先级说明

不过，在Python中，运算符的优先级与数学上还是有一些差别的，在数学中，我们可以认为优先级高的会先计算，然而，在Python中，运算符优先级更多体现的是一种结合性，而不是计算的顺序。

例如，假设如下的表达式：

x + y * z

如果在数学中，我们可以认为是先计算y * z，然后再与x求和。但是在Python中却并非如此。首先*的优先级高于+，因此，表达式可以认为是按照如下的方式进行结合：

x + (y * z)

此时，Python解释器会首先计算x的值，然后计算y的值，再计算z的值，接下来计算y * z的值（假设为w），最后计算x与w的和。也就是说，x的计算会先于y与z，而不是我们按照数学思维所想象的——先计算y * z的乘积，然后再计算x，最后求和。

明确这种计算方式有什么意义吗？当然！我们可以想象一下，如果在计算x的时候，会改变后面y或者z的值，结局会是如何？此时，按照数学思维与按照Python（计算机）思维，就会得到不同的结果。

2 序列

2.1 序列概念与分类

序列是一种可迭代对象，可以存储多个数据，并提供数据的访问。序列中的数据，我们称为序列的元素。

1.Python中，内置的序列类型有：

列表（list）
元组（tuple）
字符串（str）
字节（bytes）

2.序列支持如下通用操作：

索引通过索引可以访问序列中指定位置的元素（单个）。
切片通过切片可以访问序列中一个区间的元素（多个）。
迭代序列作为可迭代对象，因此，可以通过for循环进行遍历。
长度可以通过len函数获取序列的长度（序列中含有元素的个数）。
运算序列支持+，*，in，not in，比较，布尔运算符。

2.2 列表

列表是一种可变的序列类型。能够存储多个元素。

2.2.1 索引

1.创建列表
定义列表非常简单，使用一对[]即可。例如：

li = []

这样，就定义了一个空的列表。当然，我们也可以定义非空的列表，元素之间使用逗号（,）分隔：

li = [1, 2, 3, 4]

在Python中，列表中的元素也可以是不同的：

li = [1, 2.3, 5 + 8j, “apple”]

2.列表元素的访问
定义列表后，我们可以通过索引来访问列表的元素。访问方式为：
列表名[索引值]
索引是从0开始编号的，最大索引值为列表的长度- 1，列表（序列）的长度可以通过len函数获得。同时，列表的索引也支持负值，表示倒数第n个位置。例如：li[-1]表示倒数第一个（最后一个）元素（假设li为列表类型）。列表的有效索引值区间为[-length, length - 1]（length为列表的长度）。如果索引不在有效区间，将会产生错误。
列表是可变的序列类型，我们除了可以通过索引获取元素的值，也可以改变元素的值。

lis = list(range(5))
print(lis)
# 列表的长度
print(len(lis))
# lis[0]代表这个序列索引为0的那个元素
print(lis[0])
# 最后一个元素的索引
print(len(lis)-1)
# 最后一个元素
print(lis[len(lis)-1])

result:
[0, 1, 2, 3, 4]
5
0
4
4
4
#################################
# 对应索引
#       0 1   2     3
#      -4-3  -2    -1
lis1 = [1,2,"老王",True]
#找老王
print(lis1[2])
print(lis1[-2])

3.列表的遍历
列表具有索引，可以使用while循环遍历。
序列类型都是可迭代对象，因此，序列可以使用在for循环中进行遍历。
4.嵌套列表
列表是可以嵌套的，即列表中的元素依然是列表类型。例如，如果保存一个班级的所有学生的名字，是一个一级列表，可以要保存每个学生所选修的课程，就是一个二级列表了。

lis = [1,2,3,[4,5,6]]
# 结果为4
print(lis[3][0])

lis = [1,2,3,[4,5,6,[0,1]]]
# 结果为0
print(lis[3][3][0])

5.嵌套列表的遍历

#遍历下标
lis = [[1,2],[4,5,6]]
# len(lis)代表一维列表的索引区间
for i in range(len(lis)):
    for j in range(len(lis[i])):    #len(lis[i])代表二维列表的索引区间
        print(lis[i][j])
 
# 字符串也是一个序列
lis1 = [1,2,[3,4],"abc",5,6]
for i in lis1:
    if type(i) == int:
        print(i)
    else:
        for j in i:
            print(j)

2.2.2 切片

切片可以用来操作列表（序列）一个区间的元素。切片的语法为：
列表名[start : end : step]
start，end与step都是可选的，也可以都是负值。
注意切片截取元素的方向。当两个端点同时存在，与两个端点缺失一个（或全部缺失），表现的不同。
通过切片也可以修改列表的一个区间。

lis = list(range(10))
print(lis)
# 取第0位和第1位，包头不包尾
print(lis[0:2])
# 取最后两位
print(lis[-2:])
# 0:6是从0开始取到5，0，1，2，3，4，5    2是每两位取一个
print(lis[0:6:2])
# 这些0也可以不写，比如：print(lis[:6:2])和print(lis[0:6:2])是等价的

2.2.3 相关方法

append(obj)
在列表后面追加元素
insert(index, obj)
在列表中的指定位置添加元素
remove(value)
移除列表中指定的元素
clear()
extend(iterable)
index(value, [start, [stop]]
count(value)
copy()
sort(key=None, reverse=False)
reverse()
将列表反序排列
pop([index])
把列表中的最后一位抛出

lis = list(range(10))
print(lis)
# 追加
lis.append(10)
print(lis)
# 在指定位置添加
lis.insert(1,"a")
print(lis)
# 移除   remove的是value
lis.remove(5)
print(lis)
# 把最后一位抛出去
lis.pop()
print(lis)
# 把0改成字符串
lis[0] = "qwe"
print(lis)

del
del除了可以删除变量名，也可以用来删除列表的元素。例如：
del li del li[0] del[0:3]

2.2.4 列表的运算

列表（序列）也是支持部分运算，因为列表可以包含多个元素，相比之前学习的数值类型（仅包含单个值）来说，其计算规则相对复杂一些。
列表支持如下的运算：

符号	说明
x + y	连接x与y两个列表
x * n	将序列重复n次（所有元素重复n次）。
e in x	如果e在x中，返回True，否则返回False。
e not in y	如果e不在x中，返回True，否则返回False。
x 比较 y	1.依次比较两个序列中的元素（>，>=，<，<=，==，!=）。2.判断两个列表是否为同一个列表（is，is not）。
x 布尔 y	与数值类型的布尔运算（and或or）规则相同（返回两个列表中的一个）

假设上表中，x与y是列表类型，e为列表中的元素，n为整数。

# 连接两个列表
a = [1,2]
b = [3,4]
c = a+b
print(c)

2.3 元组

2.3.1 定义与基本操作

元组是一种不可变的序列。即元组一经创建，就无法再进行修改，试图对元组进行的任何修改均会产生错误。
除了不可变性，元组与列表非常相似，我们可以近似的认为，元组是一种不可变的列表类型。

1.创建元组
元组使用（）表示，多个元素使用逗号“,”分隔。但是，当元组仅有一个元素时，必须在元素后面加上逗号“,”，否则不是元组类型。（重要的是逗号，不是小括号）

# 元祖 tuple
tup = (1,)
print(type(tup))
tup1 = (1,2,3,4)
print(tup1[2])

2.以下情况下，元组需要使用()：

长度为0的元素（空元组）
元组嵌套
元组作为表达式的一部分

然而，为了令程序更加具有可读性，建议当使用元组时，总是使用（）。

2.3.2 相关方法

因为元组是不可变的序列，因此所有修改序列的方法都不适合元组。
 count(value)
 index(value, [start, [stop]])

2.3.3 元组的意义

元组作为一种不可变序列，可以保证数据在程序运行过程中不会意外由自己或其他人修改（例如在函数参数传递中），这样可以保证数据的完整性。

2.4 字符串

2.4.1 定义与基本操作

字符串是一种不可变的序列。顾名思义，就是一组字符组成的序列，每个字符就是序列中的一个元素。

1.创建字符串
字符串可以包含零个或多个字符，字符需要使用引号界定。引号可以是：

单引号
双引号
三引号
其中，单引号与双引号是完全等价的，而三引号可以在字符串内部换行。如果单（双）引号也需要换行，可以使用续行符“\”，三引号中使用续行符，则不会产生换行。

str = "qwe"
str1 = 'qwe'
print(str == str1)

2.字符串的操作
索引，切片，运算，遍历每个字符。

2.4.2 相关方法

count(sub[, start[, end]])
find / index(sub[, start[, end]])
rfind/ rindex(sub[, start[, end]])
format(*args, **kwargs)
join(iterable)
replace(old, new[, count])
lstrip / rstrip / strip([chars])
split / rsplit(sep=None, maxsplit=-1)
splitlines([keepends])
startswith (prefix[, start[, end]])
endswith (suffix[, start[, end]])
upper / lower()
capitalize()
partition / rpartition(sep)
ljust / rjust / center(width[, fillchar])
isalpha()
isnumeric()
isdigit()
isdecimal()
isidentifier()
islower / isupper()
isspace()

isnumeric，isdigit与isdecimal三者之间的区别如下：
三者之间是包含关系，isnumeric范围最大，isdigit其次，isdecimal最小。

str2="qwertyuqq"
# count()代表字符串中指定元素出现的次数
print(str2.count("q"))
# find()是查询字符串中指定元素出现的索引位置，如果不存在，则返回-1
print(str2.find("w"))
print(str2.find("x"))
#####################################
a = "-"
b = "xyz"
# 以a为连接符将b进行连接
print(a.join(b))

# 转换大小写
# 将字符串转换为小写
print(b.lower())
# 将字符串转换为大写
print(b.upper())
# str转换list
c = "ab c"
# 以空格作为分隔符将字符串进行分隔
print(c.split(" "))

2.5 字节

2.5.1 定义与基本操作

bytes是一系列字节组成的序列，是不可改变的。bytes每个元素的值在[0, 255]范围内（无符号单字节）。
1.创建字节
bytes常量的创建与字符串相同，只是在字符前使用b或B前缀即可。
2.字节的操作
索引，切片，运算，遍历每个字节。

2.5.2 相关方法

bytes的方法与str相似，可参考str的方法。

2.6 字符集与编码

字符集，就是一组字符组成的集合。常见的字符集有ASCII，BIG5，Unicode，GBK等。不同的字符集，包含的字符个数也可能是不相等的。在存储字符时，我们需要将字符转换成二进制值，称为编码，同样，在读取保存的二进制值时，我们需要将二进制值还原成字符，称为解码。可以说，字符集，就是规定了字符与二进制之间如何进行转换的规则，即编码与解码的规则。
因此，我们如果对某一个文本文件采用了一种编码方式保存，在解析该文件内容时，就需要采用相同的编码方式解码，否则就很可能造成乱码的现象，原因就是编码与解码的方式不统一造成的。

2.6.1 Unicode与UTF-8

在Python中，字符串str类型使用的字符集是Unicode字符集，该字符集是国际组织制定的可以容纳世界上所有文字和符号的字符编码方案，这就解决了传统字符集的局限。例如，ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）字符集只能支持一些西方字符，不支持汉字，日文等语言字符。目前Unicode字符集包含1114112个编码值（0x0 ~ 0x10FFFF）。
然而，由于Unicode取值范围的广泛性，这可能会对存储带来一些问题。对于码值小的字符，只需要使用1个字节存储就够了，但是，对于码值大的字符，却需要使用更多的字节去存储。如果使用定长的方式存储，这势必会造成存储空间的浪费。因此，后来人们创建了UTF-8的编码方式。UTF-8（8-bit Unicode Transformation Format）是针对Unicode设定的可变长度字符编码，是对Unicode字符集的一种通用转换格式。UTF-8编码使用1 ~ 4个字节来表示Unicode（0x000000 ~ 0x10FFFF）区间的值。如下表。

取值	占用空间（字节）
0x000000 ~ 0x00007F	1
0x000080 ~ 0x0007FF	2
0x000800 ~ 0x00FFFF	3
0x010000 ~ 0x1FFFFF	4

Python3默认文件的编码方式为UTF-8编码（Python2默认为ASCII）。

2.6.2 str与bytes

我们可以在str（字符串）与bytes（字节）之间进行转换。通过调用str的encode方法可以返回字符串编码之后的结果（bytes类型）。同样，通过调用bytes类型的decode方法，可以将字节序列解码，转换回编码之前的字符串（str类型）。
此外，我们也可以通过bytes与str函数，来实现编码与解码的操作。

str1 = "123"
# 字符串转化成字节
str2 = b"123"
print(type(str2))

2.7 转义序列

转义序列：就是使用两个或更多的字符来表示另外一个字符。即转义序列中的每个字符都不是其本来的含义，而是组合在一起，表示一个新的含义（字符）。
Python中，转义序列列表如下：

符号	说明
\a	响铃符
\b	退格符
\f	换页符
\n	换行符
\r	回车符
\t	水平制表符
\v	垂直制表符
’	单引号’
"	双引号"
\	反斜杠\
\换行	续行符，不会产生换行
\ooo	可以是1 ~ 3位八进制数值，表示该数值对应的值（bytes类型）或字符（str类型）。
\xhh	\h后接两位16进制数值，表示十六进制数值对应的值（bytes类型）或字符（str类型）
\N{name}	name为Unicode字符数据库中定义的名字。仅支持str类型。
\uxxxx	\u后接4位十六进制数值，表示该值（16位）对应的字符。仅支持str类型。
\Uxxxxxxxx	\U后接8位十六进制数值，表示该值（32位）对应的字符。仅支持str类型。

说明
我们可以使用unicodedata模块来访问获取Unicode字符数据库中字符对应的名字。
16位的转义不能表示所有的Unicode字符，32位的转义可以表示所有的Unicode字符。
最后三种转义仅支持str类型。
原始字符串
如果在字符串常量前使用r或R前缀，则这样的字符串称为原始字符串。在原始字符串中，转义序列不会发生作用，这样某些情况下，可能会带来一定的简便性。例如，在Windows平台的路径操作，正则表达式等。
原始字符串中不能出现奇数个数的“\”，并且，不能以单一的“\”结尾。

# 将字符串转化为字节类型
print(str1.encode())
# 将字节类型转化为字符串类型
print(str2.decode())


print("i'm shayuwei")
# 报错报错
# print('i'm shayuwei')
# 转译字符的作用是将不必要的标识转化为字符
print('i\'m shayuwei')

# \n 换行
str3 = "a\nb"
print(str3)

# 转译
str4 = "yes\\no"
print(str4)

2.8 序列相关函数

Python也提供了相应的函数，能够用于根据已经存在的可迭代对象（序列类型都是可迭代类型）创建新的序列类型，实际上，从另一个角度来讲，也就相当于进行了类型转换。

list() / list(iterable)
tuple() / tuple(iterable)
str() / str(object)
bytes() / bytes(str)
len(obj)
max(iterable, *[, default=obj, key=func]) / max(arg1, arg2, *args, *[, key=func])
min(iterable, *[, default=obj, key=func]) / min(arg1, arg2, *args, *[, key=func])
sum(iterable, start=0)
chr(i) 将一个整数转换为一个字符
ord© 返回给定字符的编码值。
sorted(iterable, key=None, reverse=False)

2.9 序列的遍历

对序列，我们可以使用while，for循环进行遍历。

2.10 格式化

# 字符串格式化
# 旧式格式化方式
str5 = "my name is %s,age %d" % ("a",18)
print(str5)
# 新式格式化方式
print("my name is {},age {}".format("b",20))

3 字典

字典，类似于我们日常中所使用的字典，提供的是一种映射存储的方式。字典分为两个部分，一个是键（key），一个是key所关联的值（value）。我们可以认为，一个键关联（或绑定）一个值，称为键值对。字典就是以键值对的形式来存储数据的。

3.1 字典的创建

我们可以使用如下方式来创建字典：

# 使用键值对创建
dic = {"a":1,"b":2}
print(dic)

# 使用元祖的列表创建
dic1 = dict([("c",1),("d",2)])
print(dic1)

# 使用dict函数创建
a = ["a","b"]
b = [1,2]
dic3 = dict(zip(a,b))
print(dic3)

创建字典后，我们也可以增加或删除字典的键值对。

dic = {"a":1,"b":2}
# 如果key是以前存在的，那么value相当于原字典对应的value进行修改
dic["a"] = "c"
print(dic)
# 如果key不存在，那么直接在原字典添加键值对
dic["c"] = "d"
print(dic)
# 删除键值对
del dic["c"]
print(dic)

3.2 字典的特征

字典具有如下特征：

字典的键必须是不可变（可哈希）的类型。
字典的键是不可重复的。
字典中的键值对不保证是有顺序的。

（1）为什么字典会加快检索效率

将key采用hash函数，映射成hashcode，hashcode对应value的地址

（2）为什么字典的key是不可变类型

不可变类型才是可哈希的对象。对应一个对象只能产生一个hashcode

字符串、数值、字节

元组是不是能够当key？不一定

D={key1:value1, key2:value2,……}

D=dict(key1=value1,key=value2)

空字典={}

3.3 相关方法

get(key[, default])获取key对应的value
跟字典[key]不同的是如果key不存在不会报错
可以指定出错信息

# 通过键获取value
print(dic.get("a"))

pop(key[, default])删除指定的键值对

# 删除一组键值对
print(dic.pop("a"))
print(dic)

keys()
values()
items()

dic4 = {"a":1,"b":2,"c":3,"d":4}
# 打印key值
print(dic4.keys())
# 打印value值
print(dic4.values())
# 将键值对以元组的形式打印出来
print(dic4.items())

clear()清空字典

# 清除字典的全部数据
print(dic4.clear())
print(dic4)

setdefault(key[,default])追加字典的键值
如果不指定value，则追加value为None的键值对
如果key已存在，则不进行追加

# 如果本身有这个key，那么会返回none，如果本身不存在这个key，那么会自动添加相应的键值对
print(dic4.setdefault("a",2))
print(dic4.setdefault("e",100))

update([E, ]**F)追加字典，多个键值对

# 将参数指定的字典添加到x中并返回
x = {"f":5}
x.update(dic4)
print(x)

popitem()随机删除键值对,（删除哪个没有保证）都会返回刚刚删除的键值对的值
fromkeys(iterable, value=None)创建同值不同键的字典

# 创建一个新的字典，使用参数（可迭代对象）中的每一个元素作为key
# 如果没有提供第二个参数，则默认为None
print(dict.fromkeys([1,2,4]))
print(dict.fromkeys([1,2,4],2000))

copy()浅拷贝

# 对当前字典进行复制
y = x.copy()
print(y)		#{'f': 5, 'a': None, 'e': 100}

浅拷贝和深拷贝的区别参考
https://blog.csdn.net/shayuwei/article/details/89002832

3.4 字典的运算

字典的key和value的访问和修改

1.访问时，如果不存在会报错

2.修改

字典[key]在进行修改时，如果key不存在会添加一个键值对，如果存在，则修改对应的value
字典[key]=value，如果在字典定义的时候，就有重复的key，value一定会使用最后一次赋值。

3.支持 is、 in、 ==

字典支持如下的运算符：

符号	说明
e in x	如果x中存在e键，返回True，否则返回False。
e not in x	如果x中不存在e键，返回True，否则返回False。
x 比较 y	1.比较两个字典中的键值对（==，!=）2.判断两个字典是否为同一个字典（is，is not）
x 布尔 y	与数值类型的布尔运算规则相同（返回两个字典中的一个）

# in:检验字典是否存在这个key
print("a" in dic1)
print("a" not in dic1)

dic5 = {"1":1,"2":2}
dic6 = {"2":2,"1":1}
# 字典是无序的，比较内容，即键值对，它们是相等的，但是作为对象，它们是不同的
print(dic5 == dic6)     #True
print(dic5 is dic6)     #False
# 查看 对象id 磁盘上的唯一标示符 这个相等 dic is dic2 才是TRUE
print(id(dic5))     #2190089874168
print(id(dic6))     #2190089874240

说明：

1.假设上表中，x与y是字典类型，e为某元素（代表键）。
2.字典不支持 >= 与 <= 运算。
3.len函数也可以应用与字典类型，返回字典中键值对的个数。

# len返回的是字典里键值对的个数
print(len(dic5))

3.5 字典的遍历

遍历字典主要是遍历字典的项、键和值。遍历字典的项是把字典包含的所有项都列举出来，遍历字典的键和值是把字典所有的键和值都列举出来。共有三种方法：

dic7 = {"a":1,"b":2,"c":3,"d":4}
# 字典遍历
# 方法一：根据key值进行遍历
for x in dic7.keys():
    print(x,dic7[x])
    
# 方法二：两个变量进行拆包   对字典items()方法返回的元组列表进行序列解包
for x, y in dic7.items():
    # 取出时是成组出现的（“a”，1）（“b”，2）
    print(x, y)
    
# 方法三：类似于序列，用下标取键值对
for x in dic7.items():
    print(x[0],x[1])

3.6 字典推导式

# 字典推导式
dic = list(range(10))
dic1 = {x : x*2 for x in dic}
print(dic1)

4 集合

4.1 集合的创建

集合可以包含一组元素，与字典类似，也是使用{}来表示。不同的是，字典存储的是一组键值对，而集合存储的是单一元素。例如：

s = {1, 2, 3, 4}

如果在创建集合时，指定了重复的元素，则重复的元素会自动的去除。
如果想要创建一个空的集合，不能使用：

s = {}

而是需要使用：

s = set()

因为前者创建的不是空的集合，而是空的字典。

# 自动去重
my_set = {1,2,3,3,4}
print(my_set)			# {1, 2, 3, 4}

# 空字典
s = {}
# 空集合
s1 = set()

print(s)				# {}
print(s1)				# set()

4.2 集合的特征

集合具有如下特征：

集合中不含有重复的元素。
集合中不保证元素是有顺序的。
集合中的元素类型必须是可哈希类型,不可变类型。

4.3 相关方法

add(elem)如果重复，则不添加

set1 = {1,2,3,4}
# 向集合中添加指定的元素
set1.add(1)		# 集合中不含有重复的元素，所以添加后自动去重
set1.add(5)
print(set1)
#{1, 2, 3, 4, 5}

remove(elem)删除指定的元素，如果不存在，报错

# 删除集合中指定的元素，如果不存在，则会报错
set1.remove(2)
print(set1)
#{1, 3, 4, 5}

discard(elem)跟remove不同的是，不存在不会报错

# 即使要删除的元素不存在，也不会报错
set1.discard(6)
print(set1)
#{1, 3, 4, 5}

pop()随机删除元素，返回删除的元素

# 随便删除一个元素，返回的是删除掉的元素
print(set1.pop())
print(set1)
#1
#{3, 4, 5}

clear()

# 删除集合中所有的元素
set1.clear()
print(set1)
#set()

copy()对于集合来说深拷贝和浅拷贝一样
difference(*s)差集
difference_update(*s)
intersection(*s)交集
intersection_update(*s)
union(*s)并集
update(*s)
symmetric_difference(s)相对差集
symmetric_difference_update(s)

set1 = {1,2,3}
set2 = {2,3,5}
# 做差集，第一个集合减掉与第二个集合相交的部分【不改变源数据】
print(set1.difference(set2)
print(set1 - set2)
# 做差集，第一个集合减掉与第二个集合相交的部分【改变源数据】
# set1.difference_update(set2)
print(set1)			# 1

# 交集
print(set1.intersection(set2))
print(set1 & set2)
# 和交集相同，但是会改变原集合
# set1.intersection_update(set2)
print(set1)			# {2, 3}

# 并集
print(set1.union(set2))
print(set1 | set2)
# 和union相同，但是会改变集合
# set1.update(set2)
print(set1)			# {1, 2, 3, 4, 5}

# 对称差集
print(set1.symmetric_difference(set2))
print(set1 ^ set2)
# 和对称差集功能相同，但是会改变集合
# set1.symmetric_difference_update(set2)
print(set1)			# {1, 5}

带update的都是原地修改

isdisjoint(s)如果两个集合有一个空交集，返回 True
issubset(s)判断set1是否是set2的真子集
issuperset(s)判断set2是否是set1的超集

#超集定义：如果一个集合S2中的每一个元素都在集合S1中，
# 且集合S1中可能包含S2中没有的元素，则集合S1就是S2的一个超集。 
# S1是S2的超集，则S2是S1的真子集，反之亦然

#isdisjoint() 　如果两个集合有一个空交集，返回 True
s = {1, 2}
s1 = {3, 4}
s2 = {2, 3}
print(s.isdisjoint(s1))   
# True                          # s  和 s1 两个集合的交集为空返回 True
print(s.isdisjoint(s2))
#False                          # s  和 s2 两个集合的交集为 2 不是空 所有返回False

#issubset()　如果另一个集合包含这个集合，返回 True
s = {1, 2, 3}
s1 = {1, 2, 3, 4}
s2 = {2, 3}
s.issubset(s1)
#True                           # 因为 s1 集合 包含 s 集合
s.issubset(s2)
#False                          # s2 集合 不包含 s 集合

#issuperset() 　如果这个集合包含另一个集合，返回 True
s.issuperset(s1)
#False                          # s 集合不包含 s1 集合
s.issuperset(s2)
#True                           # s 集合包含 s2 集合

4.4 集合的运算

集合不能使用任何跟索引相关的方法获取集合元素

集合支持以下运算：

符号	说明
e in x	如果x中存在e键，返回True，否则返回False。
e not in x	如果x中不存在e键，返回True，否则返回False。
x & y	返回x与y的交集，相当于x. intersection(y)。
x 丨 y	返回x与y的并集，相当于x.union(y)。
x - y	返回x与y的差集，相当于x. difference(y)。
x ^ y	返回x与y的对称差集，相当于x. symmetric_difference(y)。
x 比较 y	1.比较两个集合中的元素是否一致（==，!=）。2.比较x是否为y的父集（子集）（>，>=，<=，<）3.判断两个集合是否为同一个集合（is，is not）
x 布尔 y	与数值类型的布尔运算规则相同（返回两个集合中的一个）

说明：

假设上表中，x与y是集合类型，e为某元素。

4.5 集合推导式

# 集合推导式
x= {i for i in range(10)}
print(x)
# 集合推导式原型，集合推导式就是这个循环的缩写
x = set(x)
for i in range(10):
    x.add(i)
print(x)

5 布尔类型转换

在Python中，任意类型都能够转换为布尔类型（我们可以通过bool函数进行转换），因此，任意类型都可以作为if或while的表达式中进行条件判断。不过，我们没有必要进行显式的转换，一切类型判断都可以隐式进行。

类型	True	False
int	非0值	0
float	非0值	0.0
complex	非0值	0j
序列(list,tuple,str,bytes)	非空序列（至少一个元素）	空序列（没有元素）
dict	非空字典（至少一组键值对）	空字典（没有键值对）
set	非空集合（至少一个元素）	空集合（没有元素）