数据类型（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）。
算术运算符的使用。注意取余与取模的差别。
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连接的表达式一样，也会进行短路操作。
3. 身份运算符
is与==，is not与!=的区别在于，==与!=比较的是对象内部的值是否相等，而is与is not比较的是两个对象是否为同一个对象。
| x is y |
| x is not y |
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二者中的一个。
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参与数学运算。
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并非完全等价，原因我们在后面说明。
7. 成员运算符
In not in
判断子元素是否在当前序列中
8. 运算符优先级
算数运算符> 比较运算> 逻辑运算> 赋值运算符
在小学时，我们学习数学运算，就已经非常明确要先算乘方，然后乘除，然后加减。这里，先算与后算体现的就是一种计算的先后顺序，我们称这种计算顺序为运算符的优先级。同样，在Python中，运算符也存在着优先级的概念，如下表所示，优先级从高到低进行排列，同一行的运算符具有相同的优先级：
| 运算符优先级 |
|---|
| . () [] |
| ** |
| +（正号） -（负号） ~ |
| * / // % |
| + - |
| << >> |
| & |
| ^ |
| I |
| ^ |
| 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，最后求和。
数据类型（２）–字符串和字节
1. 字符串
1.1 定义与基本操作
字符串是一种不可变的序列。顾名思义，就是一组字符组成的序列，每个字符就是序列中的一个元素。
创建字符串
字符串可以包含零个或多个字符，字符需要使用引号界定。引号可以是：
- 单引号
- 双引号
- 三引号
其中，单引号与双引号是完全等价的，而三引号可以在字符串内部换行。如果单（双）引号也需要换行，可以使用续行符“\”，三引号中使用续行符，则不会产生换行。
多个字符串常量也可以“无缝”的组合在一起。例如：
s = “Hello”“World”
字符串的操作
索引，切片，运算，遍历每个字符。
2. 转义序列
2.1 操作
- 运算符
＋× in not in is is not == + * 都是新创建字符串
Is 和 ==一致。 - 索引
字符串[index]
Index: 正数，从左到右 负数从右到左
第一个元素是从0开始
界限：-len(o) len(o)-1
如果越界，会报错 - 切片
字符串[start: end:step]
Start: 起始位置 > 0 <0 =0 默认值：0
End: 终止位置（切片不包含终止位置）> 0 <0 =0 默认值：len(o)
Step: 步长 >0 <0 默认值1
获取切片的时候，注意step的方向和start、end的取值方向一致。
字符串的整切片不会新创建字符串。
2.2 相关方法
count(sub[, start[, end]])返回统计的次数
index（sub,start,end）返回的检索字符的第一次出现的位置，从左向右，如果找不到会报错
Rindex，从右向左查找
find (sub[, start[, end]])跟index一致，找不到会返回-1
rfind/ rindex(sub[, start[, end]])从右向左
format(*args, **kwargs)格式化
join(iterable) 使用当前的字符串对可迭代对象的元素进行拼接
replace(old, new[, count])
lstrip / rstrip / strip([chars]) 去掉两端特定的字符（如果不写参数，默认去掉空格）
split / rsplit(sep=None, maxsplit=-1)切割，如果不写参数，默认按照空格切割，去掉所有的空元素
Split（“ ”）不会去掉空元素
splitlines([keepends])
startswith (prefix[, start[, end]]) 判断是否以sub开头，返回布尔类型
endswith (suffix[, start[, end]])判断是否以sub结尾，返回布尔类型
upper / lower()
capitalize()
partition / rpartition(sep)返回一个元组，(sub之前的元素，当前sub，sub之后的元素)
isalpha()判断是否是字符
isnumeric()
isdigit()判断是否是数字
isdecimal()判断是否是十进制数字
isidentifier()判断是否是合法的标识符，不包括关键字
islower / isupper()
isspace()
isnumeric，isdigit与isdecimal三者之间的区别如下：
三者之间是包含关系，isnumeric范围最大，isdigit其次，isdecimal最小。
3. 字节
3.1 定义与基本操作
bytes是一系列字节组成的序列，是不可改变的。bytes每个元素的值在[0, 255]范围内（无符号单字节）。
3.2 相关方法
bytes的方法与str相似，可参考str的方法。
3.3 字符集与编码
字符集，就是一组字符组成的集合。常见的字符集有ASCII，BIG5，Unicode，GBK等。不同的字符集，包含的字符个数也可能是不相等的。在存储字符时，我们需要将字符转换成二进制值，称为编码，同样，在读取保存的二进制值时，我们需要将二进制值还原成字符，称为解码。可以说，字符集，就是规定了字符与二进制之间如何进行转换的规则，即编码与解码的规则。
因此，我们如果对某一个文本文件采用了一种编码方式保存，在解析该文件内容时，就需要采用相同的编码方式解码，否则就很可能造成乱码的现象，原因就是编码与解码的方式不统一造成的。
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）。
str与bytes
我们可以在str（字符串）与bytes（字节）之间进行转换。通过调用str的encode方法可以返回字符串编码之后的结果（bytes类型）。同样，通过调用bytes类型的decode方法，可以将字节序列解码，转换回编码之前的字符串（str类型）。
此外，我们也可以通过bytes与str函数，来实现编码与解码的操作。
3.4 格式化输出
有时候，多个字符串进行拼接会显得过于繁琐，这在数字与字符串拼接时更加明显，因为我们不得不使用str进行转换才行。而且，有时候，我们可能需要对输出格式进行严格的控制，例如，小数点后保留几位，字符占用的宽度等。此时，我们就可以对字符串进行格式化，以输出我们期望的形式。
在Python中，我们可以采用两种方式进行字符串的格式化：
- 旧式格式化——使用“%”的形式。
- 新式格式化——使用str类的format方法
- 最新格式化——使用格式化字符串常量
旧式格式化——使用“%”的形式
在字符串对象后，可以使用%来进行格式化，格式如下：
格式化字符串%（值的元组或字典）
格式化字符串中的占位符格式为：
% [(关键字)][转换标记][最小宽度][.精度]转换格式
其中，%与转换类型是必选的，其他是可选的。说明如下：
- %：指出这是占位符的开始。
- 关键字：用于匹配字典中的键，使用键所对应的值替换。
转换格式
我们来看一下转换格式，如下表。
| 符号 | 说明 |
|---|---|
| d，i，u | 有符号十进制格式。其中u已经不建议再使用 |
| o | 有符号八进制格式 |
| x | 有符号十六进制格式。（10 ~ 15使用a ~ f） |
| X | 有符号十六进制格式。（10 ~ 15使用A ~ F） |
| f | 浮点格式，精度默认为6。（NaN与无穷大会显示为nan与inf） |
| F | 浮点格式，精度默认为6。（NaN与无穷大会显示为NAN与INF） |
| e | 科学计数法格式，精度默认为6（指数使用e） |
| E | 科学计数法格式，精度默认为6（指数使用E） |
| g | 假设将数值转换成指数格式，如果数值指数值小于-4或者大于等于精度值（默认为6），则使用科学计数法格式，否则使用浮点格式（指数使用e） |
| G | 假设将数值转换成指数格式，如果数值指数值小于-4或者大于等于精度值（默认为6），则使用科学计数法格式，否则使用浮点格式（指数使用E） |
| c | 单字符格式，可以是单个字符或者整数值 |
| a | 将Python对象使用ascii函数转换成字符串格式 |
| s | 将Python对象使用str函数转换成字符串格式 |
| r | 将Python对象使用repr函数转换成字符串格式 |
| % | 转换成普通的%字符 |
新式格式化——使用str类的format方法
从Python2.6（Python2版本）与Python3.0（Python3版本）起，str可以使用format方法来进行格式化，相比于以前的%形式，这种方式称为新式格式化。形式为：
格式化字符串.format(替换值)
格式化字符串使用{}作为占位符，然后使用format方法的参数进行替换。占位符的格式如下：
{[字段名][:格式说明]}
以上部分都是可选的。
与%格式化相同，format方法的格式化也提供动态模板的方式，就是使用嵌套的{}来指定动态模板设置即可。动态模板设置建议使用关键字参数的形式，这样有利于程序的可读性。
数据类型（3）–列表和元组
1. 列表
列表是一种可变的序列类型。能够存储多个元素。
特点：
- 有序、可重复
- 列表可以定义成多种元素类型
- 列表中的元素是可变元素
创建列表
定义列表非常简单，使用一对[]即可。例如：
li = []
这样，就定义了一个空的列表。当然，我们也可以定义非空的列表，元素之间使用逗号（,）分隔：
li = [1, 2, 3, 4]
在Python中，列表中的元素也可以是不同的：
li = [1, 2.3, 5 + 8j, “apple”]
1.1 列表的运算
列表（序列）也是支持部分运算，因为列表可以包含多个元素，相比之前学习的数值类型（仅包含单个值）来说，其计算规则相对复杂一些。
列表支持如下的运算：
| 符号 | 说明 |
|---|---|
| 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为整数。
1.2 索引
列表元素的访问
定义列表后，我们可以通过索引来访问列表的元素。访问方式为：
列表名[索引值]
索引是从0开始编号的，最大索引值为列表的长度- 1，列表（序列）的长度可以通过len函数获得。同时，列表的索引也支持负值，表示倒数第n个位置。例如：li[-1]表示倒数第一个（最后一个）元素（假设li为列表类型）。列表的有效索引值区间为[-length, length - 1]（length为列表的长度）。如果索引不在有效区间，将会产生错误。
列表是可变的序列类型，我们除了可以通过索引获取元素的值，也可以改变元素的值。
1.3 切片
切片可以用来操作列表（序列）一个区间的元素。切片的语法为：
列表名[start : end : step]
start，end与step都是可选的，也可以都是负值。
注意切片截取元素的方向。当两个端点同时存在，与两个端点缺失一个（或全部缺失），表现的不同。
通过切片也可以修改列表的一个区间。
1.4 相关方法
添加：
- append(obj)
- insert(index, obj)
- extend(iterable)
删除：
-
remove(value)
-
pop([index])
-
clear()
-
Del
-
index(value, [start, [stop]]
-
count(value)
-
reverse()
-
copy()
（１）值----不是拷贝，a=[1,2,3] b=a，将a和b指向同一个对象
（２）切片和列表下的copy方法：浅拷贝：只拷贝一层对象
（３）copy包下的deepcopy深拷贝：一直拷贝到不可变类型为止。 -
sort(key=None, reverse=False)
练习以上方法的使用。实现列表的逆序（尽可能使用多种方法）。
del
del除了可以删除变量名，也可以用来删除列表的元素。例如：
del li del li[0] del[0:3]
1.5 列表的复制
列表的内存存储
id函数
- 浅拷贝 切片，列表的copy方法。copy模块的copy方法。
- 深拷贝 copy模块的deepcopy方法。
1.6 列表推导式
列表推导式是一种创建列表的简洁方式。
当我们需要创建一个列表，该列表中的每个元素是通过另外一个列表（或可迭代对象）中的每个元素（或部分元素）经过运算获得时（即当需要创建的列表元素依赖于另外一个可迭代对象的元素时），就可以考虑使用列表推导式来实现。
列表推导式的语法为：
[表达式 for 更多的for或if]
两个数值（1-5）的所有组合。（十位不能是1与4，个位不能是2与5）
列表推导式中的变量
for循环中的变量会在for循环后继续有效（这可能不是我们期望的），而列表推导式中声明的变量仅在列表推导式中有效（如果赋值，与左侧变量也不会冲突）。
1.7 列表的遍历
For I in 列表：遍历元素
For I in range(lenn(列表))：使用索引遍历元素
列表具有索引，可以使用while循环遍历。
序列类型都是可迭代对象，因此，序列可以使用在for循环中进行遍历。
嵌套列表
列表是可以嵌套的，即列表中的元素依然是列表类型。例如，如果保存一个班级的所有学生的名字，是一个一级列表，可以要保存每个学生所选修的课程，就是一个二级列表了。
嵌套列表的遍历
1.8 操作符
+ * in is == < >
注意：结果都是新创建列表
==：内容是否相等
Is：对象是否一个：
A=[1,2,3]
B=[1,2,3]
A is b----False
2. 元组
2.1 定义与基本操作
元组是一种不可变的序列。即元组一经创建，就无法再进行修改，试图对元组进行的任何修改均会产生错误。
除了不可变性，元组与列表非常相似，我们可以近似的认为，元组是一种不可变的列表类型。
元组的特点：元组有序、可重复、元素不可改变
创建元组
元组使用（）表示，多个元素使用逗号“,”分隔。但是，当元组仅有一个元素时，必须在元素后面加上逗号“,”，否则不是元组类型。（重要的是逗号，不是小括号）
以下情况下，元组需要使用()：
- 长度为0的元素（空元组）
- 元组嵌套
- 元组作为表达式的一部分
然而，为了令程序更加具有可读性，建议当使用元组时，总是使用（）。
元组的操作
索引，切片，运算，遍历
2.2 相关方法
因为元组是不可变的序列，因此所有修改序列的方法都不适合元组。
count(value)
index(value, [start, [stop]])
2.3 元组的意义
元组作为一种不可变序列，可以保证数据在程序运行过程中不会意外由自己或其他人修改（例如在函数参数传递中），这样可以保证数据的完整性。
3. 序列概念与分类
序列是一种可迭代对象，可以存储多个数据，并提供数据的访问。序列中的数据，我们称为序列的元素。Python中，内置的序列类型有：
- 列表（list）
- 元组（tuple）
- 字符串（str）
- 字节（bytes）
序列支持如下通用操作：
- 索引 通过索引可以访问序列中指定位置的元素（单个）。
- 切片 通过切片可以访问序列中一个区间的元素（多个）。
- 迭代 序列作为可迭代对象，因此，可以通过for循环进行遍历。
- 长度 可以通过len函数获取序列的长度（序列中含有元素的个数）。
- 运算 序列支持+，*，in，not in，比较，布尔运算符。
4. 序列相关函数
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)
sorted(iterable, key=None, reverse=False)
数据类型（4）–字典和集合
1. 字典
字典，类似于我们日常中所使用的字典，提供的是一种映射存储的方式。字典分为两个部分，一个是键（key），一个是key所关联的值（value）。我们可以认为，一个键关联（或绑定）一个值，称为键值对。字典就是以键值对的形式来存储数据的。
1.1 字典的创建
我们可以使用如下方式来创建字典：
-
使用键值对
x = {“a”: “x”, “b”: “y”} -
使用dict函数
x = dict(a=“x”, b=“y”)
创建字典后，我们也可以增加或删除字典的键值对。
x[“new_key”] = “new value”
del x[“new_key”]
1.2 字典的特征
字典具有如下特征：
- 字典的键必须是不可变（可哈希）的类型。
- 字典的键是不可重复的。
- 字典中的键值对不保证是有顺序的。
-
为什么字典会加快检索效率
将key采用hash函数，映射成hashcode，hashcode对应value的地址 -
为什么字典的key是不可变类型
不可变类型才是可哈希的对象。对应一个对象只能产生一个hashcode
字符串、数值、字节
元组是不是能够当key？不一定
D={key1:value1, key2:value2,……}
D=dict(key1=value1,key=value2)
空字典={}
1.3 相关方法
- get(key[, default])获取key对应的value
跟字典[key]不同的是如果key不存在不会报错
可以指定出错信息 - pop(key[, default])删除指定的键值对
- keys()
- values()
- items()
- clear()清空字典
- setdefault(key[,default])追加字典的键值
如果不指定value，则追加value为None的键值对
如果key已存在，则不进行追加 - update([E, ]**F)追加字典，多个键值对
- popitem()随机删除键值对,都会返回刚刚删除的键值对的值
- fromkeys(iterable, value=None)创建同值不同键的字典
- copy()浅拷贝
1.4 字典的运算
字典的key和value的访问和修改
访问，如果不存在会报错
字典[key]
修改，如果key不存在会添加一个键值对，如果存在，则修改对应的value
字典[lkey]=value
如果在字典定义的时候，就有重复的key，value一定会使用最后一次赋值。
支持 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 | 与数值类型的布尔运算规则相同（返回两个字典中的一个） |
说明：
- 假设上表中，x与y是字典类型，e为某元素（代表键）。
- 字典不支持 >= 与 <= 运算。
- len函数也可以应用与字典类型，返回字典中键值对的个数。
2. 集合
2.1 集合的创建
集合可以包含一组元素，与字典类似，也是使用{}来表示。不同的是，字典存储的是一组键值对，而集合存储的是单一元素。例如：
s = {1, 2, 3, 4}
如果在创建集合时，指定了重复的元素，则重复的元素会自动的去除。如果想要创建一个空的集合，不能使用：
s = {}
而是需要使用：
s = set()
因为前者创建的不是空的集合，而是空的字典。
2.2集合的特征
集合具有如下特征：
- 集合中不含有重复的元素。
- 集合中不保证元素是有顺序的。
- 集合中的元素类型必须是可哈希类型,不可变类型。
2.3集合的运算
集合不能使用任何跟索引相关的方法获取集合元素
集合支持以下运算：
| 符号 | 说明 |
|---|---|
| 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为某元素。
2.4 相关方法
带update的都是原地修改
- add(elem)如果重复，则不添加
- remove(elem)删除指定的元素，如果不存在，报错
- discard(elem)跟remove不同的是，不存在不会报错
- pop()随机删除元素，返回删除的元素
- clear()
- copy()对于集合来说深拷贝和浅拷贝一样
- difference(*s)差集
- difference_update(*s)
- intersection(*s)交集
- intersection_update(*s)
- union(*s)并集
- update(*s)
- symmetric_difference(s)相对差集
- symmetric_difference_update(s)
- isdisjoint(s)
- issubset(s)
- issuperset(s)
3. 数据转换
- Int(x):将x转换成为一个整数
- float(x)：将x转换成为一个浮点数
- str(x)：将x转换成为一个字符串
- bool(x)：将x转换成为布尔类型
- tuple(s)：将序列转换成元组
- list(s)：将序列转换成列表
- set(s)：将序列转换成集合
- dict(d)：将一个元素为kw形式的序列转换成字典
扫一扫
3469
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
