python 字符串序列化对象 python中字符串属于什么序列

序列是一块用来存放多个对象的连续内存空间，用来存储一系列数据，是一种数据存储方式。比如，一个整数序列 [10, 20, 30, 40]，可以这样示意表示：

序列在内存中存储的是对象的地址，而不是值。a = [10, 20, 30, 40] 图示如下：

Python 中，常用的序列结构有：字符串（str）、列表（list）、元组（tuple）、字典（dict）、集合（set）。

3.1 字符串

3.1.1 字符串的基本特点

字符串的本质是：字符序列。

Python 中，字符串是不可变的，我们无法对原有字符串做任何修改。但是，可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

Python 中，不支持单字符类型，单个字符也是一个字符串。

字符的编码

Python3 的默认字符编码是 16 位的 Unicode 编码。
使用内置函数 ord() 可以把字符转换成对应的 Unicode 码；
使用内置函数 chr() 可以把十进制数字转成对应的字符。

3.1.2 字符串的创建

Python 中，使用单引号 ' 或双引号 " 创建字符串。

s = 'abc'
s = "abc"

多行字符串使用连续三个单引号 ''' 或者三个双引号 """ 创建。

s = '''abc
def
gh'''

原始字符串使用 r'' 或者 r"" 创建，引号中的字符不会被转义。

str = r'\n\t\r'

转义字符	作用
\ （在行尾时）	续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\b	退格（Backspace）
\n	换行
\t	制表符
\r	回车

3.1.3 字符串的常见操作

拼接（+）

1. 可以使用 + 将多个字符串拼接起来。比如： 'a' + 'b' ==> 'ab'（1）如果 + 两边都是字符串，则拼接；
   （2）如果 + 两边都是数字，则加法运算；
   （3）如果 + 两边数据类型不一致，则抛出异常。
2. 可以将多个字面量字符串直接放到一起实现拼接。比如：'a' 'b' ==> 'ab'

复制（*）

使用 * 可以实现字符串的复制。比如：'a' * 3 = 'aaa'

按索引取值（[ ]）

字符串的本质是字符序列，所以可以使用 [] 提取字符串中的字符。
正向搜索：最左侧第一个字符序号为 0，第二个为 1，以此类推，直到 len(str) - 1 为止。
反向搜索：最右侧第一个字符序号为 -1，第二个为 -2，以此类推，直到 -len(str) 为止。

切片（slice）

切片可以快速提取子字符串，标准格式为：[起始索引 start : 终止索引 end : 步长 step] 切片操作时，起始索引和终止索引不在 [ 0, len( ) - 1 ] 范围内，也不会报错。起始索引 < 0，会当作 0 处理；终止索引 > ( len( ) - 1 ) 会当作 -1。

操作数都为正数的切片

操作	作用	示例	结果
[ : ]	截取整个字符串	“abcdef” [:]	“abcdef”
[ start : ]	从 start 开始截取到末尾	“abcdef” [2:]	“cdef”
[ : end ]	从开头截取到 (end - 1)	“abcdef” [:2]	“ab”
[ start : end ]	从 start 开始截取到 (end -1)	“abcdef” [2:4]	“abcd”
[ start : end : step ]	从 start 开始截取到 (end -1)，步长是 step	“abcdef” [1:5:2]	“bd”

操作数都为负数的切片

示例	说明	结果
“abcdef”[-3:]	截取倒数3个字符	“def”
“abcdef”[-5:-3]	从倒数第5个字符截取到倒数第3个字符	“bc”
“abcdef”[::-1]	步长为负，从右向左反向截取	“fedcba”

替换（replace）

Python 中，字符串是不可变的，我们可以通过 [ ] 提取指定位置的字符，一旦进行改变就会抛出异常。如果确实需要改变字符串中的某些字符，我们可以通过创建新的字符串来实现。

str.replace(old, new, count) 就是通过创建新字符串实现的替换。

分割（split）

str.split(sep, maxsplit) 可以基于指定分隔符将字符串分隔成多个子字符串（存储到列表中）。如果不指定分隔符，默认使用空白字符（换行符、空格、制表符）。

合并（join）

sep.join(iterable) 的作用与 split() 刚好相反，用于将一系列子字符串连接起来。

字符串拼接不推荐使用 + ，因为 + 每次会生成新的字符串对象，性能不佳；
推荐使用 join( ) 进行拼接，join( ) 在拼接前会计算所有字符串的长度，然后逐一拷贝，只创建一次对象。

import time

start = time.time()
a = ''
for i in range(1000000):
    a += "python"
end = time.time()
print("+    时间：", end - start)

start1 = time.time()
li = []
for i in range(1000000):
    li.append("python")
a = ''.join(li)
end1 = time.time()
print("join 时间：", end1 - start1)

--------------------- 执行结果 ---------------------
+    时间： 2.1248202323913574
join 时间： 0.10938239097595215

成员判断（in)

in / not in 关键字，用于判断某个子字符串是否存在于字符串中。比如：'a' in 'abc'

比较

== 比较字符串的值，is 比较字符串是否为同一个对象。
符合驻留机制的字符串，== 判断相等的都是同一对象。

字符串驻留机制：

字符串驻留机制，是指字符串驻留池中，仅保留一份相同且不可变的字符串。
Python 中，会对 符合标识符规则的字符串（仅包含字母、数字、下划线）启用字符串驻留机制。

3.1.4 字符串的常用方法

方法	作用
len(str)	字符串长度
str.startswith(‘str’)	以指定字符串开头
str.endswith(‘str’)	以指定字符串结尾
str.find(‘str’)	查找指定字符串第一次出现的位置
str.rfind(‘str’)	查找指定字符串最后一次出现的位置
str.count(‘str’)	统计指定字符串出现的次数
str.isalnum()	判断所有字符是否全是字母或数字
str.isalpha()	判断所有字符是否全是字母（包括汉字）
str.isdigit()	判断所有字符是否全是数字
str.isspace()	判断所有字符是否全是空白字符（空格、换行、制表符）
str.isupper()	判断所有字符是否全是大写字母
str.islower()	判断所有字符是否全是小写字母
str.strip(‘str’)	删除首尾指定字符，无参默认删除首尾所有空白字符
str.lstrip(‘str’)	删除开始指定字符
str.rstrip(‘str’)	删除结尾指定字符
str.capitalize()	第一个单词首字母大写
str.title()	每个单词首字母大写
str.upper()	所有字母转成大写
str.lower()	所有字母转成小写
str.swapcase()	所有字母大小写转换
str.center(len[, ‘str’])	字符串按长度居中，空白用第二个参数填补，默认填写空格
str.ljust(len[, ‘str’])	字符串按长度居左，空白用第二个参数填补，默认填写空格
str.rjust(len[, ‘str’])	字符串按长度居右，空白用第二个参数填补，默认填写空格

3.1.5 字符串的格式化

1. % 字符串格式化

在 Python 中，字符串格式化与 C 语言是一致的，用 %? 占位符实现。

>>> 'Hello, %s, you have $%d.' % ('Join', 1000)
'Hello, Join, you have $1000.'

有几个占位符，后面就跟几个变量或者值，顺序一一对应。如果只有一个占位符，括号可以省略。
常见的占位符有：

占位符	含义
%d	整数
%f	浮点数
%s	字符串
%x	十六进制数

整数和浮点数可以指定是否补0以及整数和小数位数，如 %2d，%02d，%.2f 等。

字符串中的 %% 可以表示一个普通 %。

2. format 字符串格式化

从 python 3.0 开始，可以使用 format() 函数来格式化字符串，通过 {索引}/{参数名} 的方式，映射参数值。

>>> 'name: {0}, age: {1}'.format('lw', 18)
'name: lw, age: 18'

>>> 'name: {name}, age: {age}'.format(age = 18, name = 'lw')
'name: lw, age: 18'

填充与对齐

填充与对齐常常一起使用，^ < > 分别表示居中、居左、居右对齐，后面带宽度。
: 后面带填充的字符，只能是一个字符，默认使用空格填充。

>>> '{:>4}'.format(1)
'   1'
>>> '{:0>4}'.format(1)
'0001'
>>> '我是{0}，我喜欢的数字是{1:-^9}'.format('lw', 888)
'我是lw，我喜欢的数字是---888---'

数字格式化

格式	作用
{:.2f}	保留小数点后2位小数
{:+.2f}	带符号保留小数点后2位小数
{:2d}	最小宽度为2，默认填写空格
{:02d} = {:0>2d}	最小宽度为2，左边填充0
{:,}	每三位数字用逗号隔开
{:.2%}	百分比格式，自动乘100，最后加 %
{:.2e}	指数计法

3. f-string 字符串格式化

从 python 3.6 开始，可以使用 f-string 进行字符串格式化。格式为：{variable:format}，variable 是替换并填入字符串的内容，可以是变量、表达式、函数等，format 是格式描述符，采用默认格式时可以不指定 {:format}。

>>> name = 'Join'
>>> age = 30

>>> f'Hello, {name}, you age is {age}.'
'Hello, Join, you age is 30.'

>>> name = 'Peter'
>>> age = 20

>>> '%s is %d years old.' % (name, age)
'Peter is 20 years old.'

>>> '{0} is {1} years old.'.format(name, age)
'Peter is 20 years old.'

>>> f'{name} is {age} years old.'
'Peter is 20 years old.'

3.1.6 字符串的其他操作

1. 不换行打印

通常调用 print( ) 时，末尾会自动打印一个换行符。如果，我们不想换行，可以通过 end = “任意字符”，实现在末尾添加内容。

2. 从控制台读取字符串

可以使用 input( ) 从控制台读取键盘输入的内容，返回 str 类型的数据内容。

3. 可变字符串

在 Python 中，字符串是不可变的。但是有时候，确实需要频繁修改某一个字符串，可以使用 io.StringIO 对象或者 array 模块。

3.2 列表

列表是有序的可变序列，是包含多个元素的连续的内存空间，列表用于存储任意数目、任意类型的数据集合。

>>> a = [10, True, 'Hello', 20.5]

列表常用方法

方法	分类	作用
list.append(x)	增加元素	将元素 x 增加到列表 list 末尾
list.extend(aList)	增加元素	将列表 aList 的所有元素增加到列表 list 末尾
list.insert(index, x)	增加元素	将元素 x 插入列表 list 的 index 处
list.remove(x)	删除元素	删除列表 list 中首次出现的元素 x
list.pop([index])	删除元素	删除并返回列表 list 指定位置 index 处的元素，默认是最后一个元素
list.clear()	删除元素	清空列表所有元素
list.index(x)	获取元素位置	返回列表 list 中元素 x 首次出现的位置
list.count(x)	计数	统计元素 x 在列表 list 中出现的次数
len(list)	获取长度	返回列表长度
list.reverse()	翻转列表	原地翻转列表 list 所有元素
list.sort()	排序	原地排序列表 list 所有元素，升序
list.copy()	浅拷贝	返回列表 list 的浅拷贝

3.2.1 列表的创建

1.基本语法 [] 创建

a = [10, 20, 30, 40]
a = [] # 创建空列表

2.使用 list() 创建，参数为任意可迭代对象，即可被 for 循环遍历的对象

a = list() # 等价于 a = []
a = list('abc')
a = list(range(10))

3.使用 range() 创建整数列表

语法：
range([start,] end, [,step]) start 默认为 0，step 默认为 1。
range( ) 返回 range 对象，而不是列表，可以使用 list( ) 转为列表对象。

4.列表推导式

语法：
[表达式 for item in 可迭代对象] or [表达式 for item in 可迭代对象 if 判断条件]

a = [ x * 2 for x in range(5) ]  # a = [0, 2, 4, 6, 8]
a = [ x * 2 for x in range(5) if x % 2 == 0 ]  # a = [0, 4, 8]

>>> t1 = [(row, col) for row in range(1,5) for col in range(1,5)]
>>> t1
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4)]

3.2.2 列表元素的添加、删除、访问

增加元素

1. append(元素) 原地在尾部增加元素，速度最快，推荐使用；
2. + 并不是真正在尾部添加元素，而是创建新列表，将原列表的元素和将要增加的列表元素，依次放入新创建的列表中，速度较慢；
3. extend(列表) 将目标列表元素添加到当前列表尾部，原地操作；作用于 + 一样；
4. insert() 用于将指定元素插入列表特定位置，会让插入位置后面的所有元素进行移动，影响处理效率。涉及大量元素时，尽量避免使用；类似的还有 remove( )、pop( )、del，他们在删除非尾部元素时，也会涉及后面所有元素的移动。
5. 乘法扩展，产生一个新列表，将原有列表元素多次重复。

删除元素

1. del 元素 删除指定元素，其实是将后面元素复制到要删除元素的位置；
2. pop(索引) 删除并返回指定位置元素，如果操作元素不在末尾，会涉及后面所有元素的复制；
3. remove(元素) 删除首次出现的指定元素，不存在抛出异常；

当列表中的元素进行增加和删除时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加和删除元素，这样可以提高列表的操作效率。

访问元素

1. 索引方式：列表[索引]，索引区间为 [0, len - 1]。
2. index(value[, start[, end]])，获取元素在列表中首次出现的位置，其中，start 和 end 指定了搜索的范围。

3.2.3 列表的常用操作

1. 统计元素出现的数量
   list.count(x) 获取指定元素 x 在列表中出现的次数。
2. 列表长度
   len(list) 返回列表长度，即列表中元素的个数。
3. 列表成员资格判断
   使用 count()，如果返回 0，表示元素不存在；
   使用 in / not in 判断。
4. 列表切片操作（slice）
   与字符串切片一样，区别在于返回列表。
5. 列表遍历

for obj in list:
	print(obj)

6. 列表排序
   1）修改原列表，不建新列表的排序
   list.sort() 默认升序排列；
   list.sort(reverse = True) 降序排列；
   random.shuffle(list) 随机打乱排列；
   2）建立新列表排序，原列表不变
   sorted(list) 默认升序排列；
   sorted(list, reverse = True) 降序排列；
   3）reversed( ) 返回逆序迭代器
   reversed() 不对列表做任何修改，只返回一个逆序排列的迭代器。
   迭代器只能使用一次，第二次使用里边为空，因为迭代器里边实际上是指向最后一个列表元素的指针，使用时指针向前移动，第二次使用时，指针已经在列表的最前边了。
7. 列表最大、最小元素
   max(list) min(list) 可以获取列表最大、最小元素。
8. 列表元素求和
   sum(list) 可以获取列表元素的和，不适用于非数值列表，会报错。

3.3 元组

列表是有序的可变序列，可以任意修改列表中的元素。元组是有序的不可变序列，不能修改元组中的元素。因此，元组没有增加元素、删除元素、修改元素的方法。

3.3.1 元组的创建

1.基本语法 () 创建，小括号可以省略

a = (10, 20, 30)
a = 10, 20, 30
a = (10,)
a = 10,  # 如果元组只有一个元素，则后面必须加逗号，否则解释器会解释为整数。

2.使用 tuple() 创建，参数为任意可迭代对象，即可被 for 循环遍历的对象

a = tuple() # 等价于 a = ()
a = tuple('abc')
a = tuple(range(5))
a = tuple([1, 2, 3])

3.生成器推导式

语法：
(表达式 for item in 可迭代对象) or (表达式 for item in 可迭代对象 if 判断条件)

>>> list = [1, 2, 3, 4]
>>> generator = (x * 10 for x in list)
>>> generator
<generator object <genexpr> at 0x0000026D7E33F660>
>>> t1 = tuple(generator)
>>> t1
(10, 20, 30, 40)

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。

但是，列表推导式直接生成列表对象，而生成器推导式生成的不是元组，而是一个生成器对象。

我们可以使用 tuple( ) 将生成器对象转换成元组，也可以使用 __next__() 方法进行遍历，或者直接作为迭代器对象来使用。

不管用什么方法，生成器只能访问一次，与迭代器类似。

3.3.2 元组元素的访问

1. 元组元素不可修改，会报错。
2. 元组元素的访问和列表一样，比如切片，只是返回仍然是元组对象。
3. 列表中的排序方法 list.sort( ) 是原地修改列表对象，元组没有该方法。只能通过内置函数 sorted( tuple ) 进行排序，返回结果为新的列表对象。

3.3.3 zip 拉链

zip(list1, list2, ...) 可以将多个列表对象组合成为元组，并返回生成的 zip 对象。zip 也是一个迭代器对象。

list1 = [10, 20, 30]
list2 = [40, 50 ,60]
list3 = [70, 80, 90]
z = zip(list1, list2, list3)
z
<zip object at 0x00000271B01E7E40>
t1 = tuple(z) # 不能使用 list(z)
>>> t1
((10, 40, 70), (20, 50, 80), (30, 60, 90))

【元组总结】

1. 元组的核心特点：不可变序列；
2. 元组的访问和处理速度比列表快；
3. 与整数、字符串一样，元组可以作为字典的键，列表不行。

3.4 字典

字典是存储“键值对”的无序的可变序列，字典中的每个元素都是一个“键值对”，包含键对象和值对象，可以通过键对象获取、删除、更新值对象。

键对象是任意不可变对象，比如：整数、浮点数、字符串、元组等，且不可重复；

值对象可以是任意对象，可重复。

3.4.1 字典的创建

1.基本语法 {} 创建

>>> a = {'name' : 'lw', 'age' : 28, 'address' : ['ab', 'cd']}
>>> a
{'name': 'lw', 'age': 28, 'address': ['ab', 'cd']}
>>> b = {}

2.使用 dict() 创建

>>> c = dict(name = 'lw', age = 28, address = ['ab', 'cd'])
>>> d = dict([("name", "lw"), ("age", 28), ("address", ["ab", "cd"])])
>>> e = dict() # 相当于 {}

3.使用 zip() 创建

>>> keys = ["name", "age", "address"]
>>> values = ["lw", 28, ["ab", "cd"]]
>>> d = dict(zip(keys, values))
>>> d
{'name': 'lw', 'age': 28, 'address': ['ab', 'cd']}

4.使用 fromkeys 创建值为空的字典

>>> e = dict.fromkeys(["name", "age", "address"])
>>> e
{'name': None, 'age': None, 'address': None}

5.字典推导式

语法：
{key:value for 表达式 in 可迭代对象} or {key:value for 表达式 in 可迭代对象 if 判断条件}

# 统计文本中字符出现的次数
>>> text = 'i love you, i love python, i love study'
>>> word_cnt = {char:text.count(char) for char in text}
>>> word_cnt
{'i': 3, ' ': 8, 'l': 3, 'o': 5, 'v': 3, 'e': 3, 'y': 3, 'u': 2, ',': 2, 'p': 1, 't': 2, 'h': 1, 'n': 1, 's': 1, 'd': 1}

3.4.2 字典元素的访问

a = {'name' : 'lw', 'age' : 28, 'job' : 'programmer'} # 初始化一个字典对象

1. 使用 [键] 获取值，键不存在时，抛出异常。

>>> a['name']  # 键存在
'lw'

>>> a[address]  # 键不存在
Traceback (most recent call last):
  File "<pyshell#164>", line 1, in <module>
    a[address]
NameError: name 'address' is not defined

2. 使用 get(键) 获取值，键不存在，返回 None，也可以设置键不存在时返回的默认值。

>>> a.get('name')
'lw'

>>> a.get('address')

>>> a.get('address', '西安')
'西安'

3. 使用 items() 列出所有键值对，使用 keys( ) 列出所有键，使用 values( ) 列出所有的值。

>>> a.items()
dict_items([('name', 'lw'), ('age', 28), ('job', 'programmer')])

>>> a.keys()
dict_keys(['name', 'age', 'job'])

>>> a.values()
dict_values(['lw', 28, 'programmer'])

4. 字典元素的个数
   len() 返回字典长度，即字典元素的个数。
5. 检测一个“键”是否在字典中

>>> 'name' in a
True

3.4.3 字典元素的添加、修改、删除

1. 使用 [] 添加键值对，如果键存在，覆盖旧的值；如果键不存在，新增键值对。

>>> a  # 原字典
{'name': 'lw', 'age': 28, 'job': 'programmer'}

>>> a['sex'] = '男'  # sex 键不存在，新增键值对
>>> a
{'name': 'lw', 'age': 28, 'job': 'programmer', 'sex': '男'}

>>> a['name'] = 'jack'  # name 键已存在，覆盖旧值
>>> a
{'name': 'jack', 'age': 28, 'job': 'programmer', 'sex': '男'}

2. 使用 update() 将其他字典元素全部添加到当前字典中，如果键重复，使用新值覆盖旧值。

>>> b = {'name': 'lw', 'age': 28, 'job': 'programmer'}
>>> c = {'name': 'jack', 'sex': '男'}

>>> b.update(c)
>>> b
{'name': 'jack', 'age': 28, 'job': 'programmer', 'sex': '男'}

3. 字典中元素的删除，可以使用 del() 方法；或者使用 pop() 删除指定键值对，并返回对应的“值对象”；或者使用 clear() 删除所有键值对。

>>> a  # 原字典
{'name': 'jack', 'age': 28, 'job': 'programmer', 'sex': '男'}

>>> del(a['name'])  # 删除键值对
>>> a  
{'age': 28, 'job': 'programmer', 'sex': '男'}

>>> a.pop('job')  # 删除键值对并返回值对象
'programmer'

>>> a
{'age': 28, 'sex': '男'}
>>> a.clear()  # 清空字典
>>> a
{}

4. 可以使用 popitem() 随机删除和返回一个键值对。因为字典是无序的，所以 popitem( ) 随机弹出一个元素。若需要一个一个地移除并处理元素，可以使用此方法。

>>> a
{'age': 28, 'job': 'programmer', 'sex': '男'}

>>> a.popitem()
('sex', '男')

3.4.4 序列解包

序列解包可以用于元组、列表、字典，可以方便地对多个变量赋值。

>>> x, y, z = 10, 20, 30
>>> x, y, z = (10, 20, 30)
>>> x, y, z = [30, 40, 50]
>>> (x, y ,z) = (15, 25, 35)
>>> (x, y, z) = [13, 23, 43]
>>> [x, y, z] = [15, 16, 17]
>>> [x, y, z] = (18, 28, 38)
>>> x, y, z = {30, 40, 50}

序列解包用于字典时，默认是对“键”进行操作；
如果需要对“值”进行操作，需要使用 values()；
如果需要对“键值对”进行操作，需要使用 items()。

>>> a = {'age': 28, 'job': 'programmer', 'sex': '男'}

>>> x, y, z = a  # 默认操作键
>>> x
'age'
>>> y
'job'
>>> z
'sex'

>>> x, y, z = a.items()  # items() 操作键值对
>>> x
('age', 28)
>>> y
('job', 'programmer')
>>> z
('sex', '男')

>>> x, y, z = a.values()  # values() 操作值
>>> x
28
>>> y
'programmer'
>>> z
'男'

3.5 集合

集合是无序可变序列，元素不能重复。实际上，集合底层是用字典实现的，集合的所有元素就是字典的“键”。

Python中，集合主要利用其唯一性，及并集、交集、差集等操作，所以不可以直接通过下标进行访问，必须访问时可以将其转换成 list 再访问。

3.5.1 集合的创建

1.基本语法 {} 创建

>>> a = {1, 3, 5}
>>> a
{1, 3, 5}

2.使用 set() 将列表、元组等可迭代对象转成集合，如果原来的数据存在重复，只保留一个。

>>> t1 = (1, 3, 5, 3)
>>> t1
(1, 3, 5, 3)
>>> s1 = set(t1)
>>> s1
{1, 3, 5}

3.集合推导式

语法：
{key for 表达式 in 可迭代对象} or {key for 表达式 in 可迭代对象 if 判断条件}

>>> {i for i in range(1, 100) if i % 9 == 0}
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}

3.5.2 集合元素的添加、删除

1.使用 add() 方法添加元素

>>> a = {1, 3, 5}
>>> a.add(7)  # 添加元素
>>> a
{1, 3, 5, 7}

2.使用 remove() 方法删除指定元素，元素不存在会报错

>>> a
{1, 3, 5}
>>> a.remove(5)  # 删除元素
>>> a
{1, 3}

>>> a.remove(2)  # 元素不存在会报错
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    a.remove(2)
KeyError: 2

3.使用 pop() 方法随机删除和返回一个元素

>>> a = {1, 5, 2, 7, 4, 8}
>>> a.pop()
1
>>> a.pop()
2

4.使用 clear() 方法删除集合中的所有元素

>>> a
{1, 3}
>>> a.clear()  # 清空集合
>>> a
set()

3.5.3 集合的交集、并集、差集运算

交集：& 、intersection，取同时存在于 a 和 b 的元素

>>> a = {1, 3, 5}
>>> b = {3, 5, 7}
>>> a & b              # 交集
{3, 5}
>>> a.intersection(b)  # 交集
{3, 5}

并集：| 、union，取 a 和 b 的所有元素

>>> a | b              # 并集
{1, 3, 5, 7}
>>> a.union(b)         # 并集
{1, 3, 5, 7}
>>> a | (b - a)        # 并集
{1, 3, 5, 7}

差集：- 、difference ，在 a 中，不在 b 中的元素

>>> a - b			  # 差集
{1}
>>> a.difference(b)    # 差集
{1}

对等差集：^、symmetric_difference，所有不同时存在于 a 和 b 的元素

>>> a ^ b			# 对等差集
{1, 7}
>>> a.symmetric_difference(b)	# 对等差集
{1, 7}
>>> (a | b) - (a & b)	# 对等差集
{1, 7}