Python：列表，元组，字典，集合

1， 列表，元组，字典，集合

1.1，概念

列表（list）：是长度可变有序的数据存储器，可通过下标索引取到相应的数据。

元组（tuple）：固定长度不可变的顺序容器，访问效率高，适合存储一些长常量数据，可以作为字典的键使用。

集合（set）：无序，元素只出现一次，可以自动去重。

字典（dict）：长度可变的hash字典容器。存储方式为键值对，可以通过相应的键获取相应的值，key支持多种类型。key必须是不可变类型且唯一。

属性\数据类型	列表	元组	集合	字典
英文	list	tuple	set	dict
是否可读写	读写	只读	读写	读写
是否可重复	是	是	否	是
存储方式	值	值	键（不可重复）	键值对（键不能重复）
是否有序	有序	有序	无序	无序，自动正序
初始化	[1,‘a’]	('a',1)	set([1,2])或{1,2}	{"a":1,'b':2}
添加	append	只读	add	d['key']='value'
读元素	I[2:]	t[0]	无	d['a']

test_list = [4, 2, 3, 1, 4]
test_tuple = (5, 2, 1, 3, 4)
test_dict = {"a": 1, "b": 2}
test_set = {12, 4, 6, 5}
for items in test_list:
    print(items, end=" ")
print()
for items in test_tuple:
    print(items, end=" ")
print()
for key, value in test_dict.items():
    print(key, value, end=" ")
print()
for items in test_set:
    print(items, end=" ")
=============================
4 2 3 1 4 
5 2 1 3 4 
a 1 b 2 
5 12 4 6 

1.2，列表，元组，集合，字典间的相互转换

列表元组转化为其他类型

# 列表转换集合
list = [6, 7, 7, 8, 9, 9]
print(set(list))

# 两个列表转换为字典
list1 = ["key1", "key2", "key3"]
list2 = [1, 2, 3]
print(dict(zip(list1, list2)))

#嵌套列表转字典
list3 = [["key1","value1"],["key2","value2"],["key3","value3"]]
print(dict(list3))

#列表、元组转字符串
list = ["燕","双","嘤"]
tuple = ("燕","双","嘤")
print("".join(list))
print("".join(tuple))
==========================
{8, 9, 6, 7}
{'key1': 1, 'key2': 2, 'key3': 3}
{'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
燕双嘤
燕双嘤

字典转换为其他类型

#字典转换为字符串
dict = {"a":1,"b":2}
print(str(dict))

#字典key和value转换
dict = {"a":1,"b":2}
print({value:key for key,value in dict.items()})
================================================
{'a': 1, 'b': 2}
{1: 'a', 2: 'b'}

字符串转换为其他类型

# 字符串转列表
s = "燕双嘤"
print(list(s))

# 字符串转元组
print(tuple(s))

# 字符串转集合
print(set(s))

# 字符串转字典
print(eval("{'name':'燕双嘤','school':'NUDT'}"))
===============================================
['燕', '双', '嘤']
('燕', '双', '嘤')
{'燕', '双', '嘤'}
{'name': '燕双嘤', 'school': 'NUDT'}

2，序列

2.1，概述

所谓序列，指的是一种包含多项数据的数据结构，序列包含的多个数据项按顺序排列，可通过索引来访问。

Python的常见序列包括：列表、元组、字符串、Unicode字符串、buffer对象、range对象。其中列表和元组非常相似，最主要的区别在于：

• 列表是可以修改的，而元组却不能修改。如果要添加和删除元素，只能用列表。元组被称为只读列表，即数据可以被查询，但不能被修改。若元组一旦被定义，则其长度和内容都是固定的，不能被修改，即不能对元组进行更新、增加和删除的操作。
• 列表用‘[]’表示，元组用‘()’表示。
• 列表不能作为字典的key，而元组可以，key不可变原因。
• 如果元组中仅有一个元素，那么需要在元素后加上逗号。

总结：如果只是固定地保存多个数据项，则不需要修改它们，此时就应该使用元组；反之，就应该使用列表。此外，在某些时候，程序需要使用不可变的对象，比如Python要求字典的key必须是不可变的，此时程序就只能使用元组。

2.2，索引

序列对象一般由多个成员组成，每个成员通常称为元素，每个元素都可以通过索引进行访问。索引使用方括号[]表示。

2.3，通用操作

切片：要访问一个序列，不仅可以通过单个的索引值来索引单个序列元素，还可以通过切片操作访问某个范围的多个元素。切片操作是通过指定元素的索引值范围来实现的。

sequence[startindex:endindex]

str = '0123456789′
str[0:3] #截取第一位到第三位的字符
str[:] #截取字符串的全部字符
str[6:] #截取第七个字符到结尾
str[:-3] #截取从头开始到倒数第三个字符之前
str[2] #截取第三个字符
str[-1] #截取倒数第一个字符
str[::-1] #创造一个与原字符串顺序相反的字符串
str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
str[-3:] #截取倒数第三位到结尾
str[:-5:-3] #逆序截取

重复（*）

如果需要获得一个序列的多个副本，可以使用重复运算符实现，其形式为：sequence*copies。

a = "123"
print(a * 2)
============
123123

连接（+）

连接是指将两个相同类型的逆序进行连接，运算符为“+”，形式为：sequence1+sequence2。但操作必须保证参与连接运算的两个序列是同一种类型。

print((1, 2, 3) + (4, 5, 6))
============================
(1, 2, 3, 4, 5, 6)

判断成员（in，not in）

判断一个元素是否属于一个序列的操作使用in和not in这两个成员运算符。

print("燕" in ("燕", "双", "嘤"))

2.4，通用函数

序列类型转换内建函数

序列类型有list()、tuple()、str()这三个类型转换的内建函数。

• list(iter)：将可迭代对象iter转换成列表。
• tuple(iter)：将可迭代对象iter转换成元组。
• str(obj)：将对象obj转换成字符串。

list()和tuple()函数比较常用，常用于列表和元组数据的类型转换，参数不仅可以是序列对象，还可以是一切可迭代对象。

print(list("Hello Shuangying Yan"))
print(tuple("Ying"))
print(list((1, 2, 3)))
print(tuple([1, 2, 3]))
===========================
['H', 'e', 'l', 'l', 'o', ' ', 'S', 'h', 'u', 'a', 'n', 'g', 'y', 'i', 'n', 'g', ' ', 'Y', 'a', 'n']
('Y', 'i', 'n', 'g')
[1, 2, 3]
(1, 2, 3)

str()可以把括号中的参数转换成字符串类型。

print(str(1))
print(str((1, 2, 3)), type(str((1, 2, 3))))
print(str([1, 2, 3]), type(str([1, 2, 3])))
===========================================
1
(1, 2, 3) <class 'str'>
[1, 2, 3] <class 'str'>

序列类型其他内建函数

函数	功能
len(sequence)	返回sequence的长度，为int类型。
sorted(iter,key,reverse)	返回可迭代对象iter排序后的列表，key用来指定排序的规则，reverse代表指定顺序还是逆序排列。
reversed(sequence)	返回序列sequence逆序排列后的迭代器。
sum(iter,start)	将可迭代对象iter中的数值和start参数的值想加，返回float类型数值，start默认为0。
max(iter)	返回可迭代对象iter中的最大值。
min(iter)	返回可迭代对象iter中的最小值。
enumerate(iter[,start])	返回一个enumerate对象，是一个迭代器，该迭代器的元素是由参数iter元素的索引和值组成的元组，起始索引由start确定，默认为0。
zip(iter1[,iter2[...]])	返回一个zip对象，是一个迭代器，该迭代器的第n个元素是由每个可迭代对象的第n个元素组成的元组。

print(list(zip("燕双嘤", "驴驴")))
=================================
[('燕', '驴'), ('双', '驴')]

3，列表：方括号[ ]

3.1，简介

特点：顺序、可添加、可修改、可删除。

# 创建列表
x = [1, 2, 3, 4, 5]
y = list('12345')
m = [0] * 5
n = list()
n.append(1)
s = list(range(0, 10, 2))
print(x, y, m, n, s)
===============
[1, 2, 3, 4, 5] ['1', '2', '3', '4', '5'] [0, 0, 0, 0, 0] [1] [0, 2, 4, 6, 8]

常用方法：

• append(x)：把一个元组添加到列表的结尾。
• extend(x)：通过添加指定列表的所有元素来扩充列表。
• insert(i, x)：在指定添加位置插入一个元素。
• remove(x)：删除列表中值为x的元素，如果没有，报错。
• pop([i])：从列表指定位置或末尾将其返回。
• clear()：移出列表的所有项，等于del a[:]。
• index(x)：返回列表中第一个值为x的元素的索引，如果没有，报错。
• count(x)：返回x在列表中出现的次数。
• sort()：对列表中的元素进行排序。
• reverse()：倒排列表中的元素。
• copy()：返回列表的浅拷贝。

3.2，列表的引用、浅拷贝、原地拷贝

假设A和B是两个列表：

• 引用：A = B

A = [1, 2, 3, 4, 5]
B = ['a', 'b', 'c','d']
A = B
A[1] = 'x'
print(A, B)
=========================================
['a', 'x', 'c', 'd'] ['a', 'x', 'c', 'd']

• 浅拷贝：A = B[ : ]

A = [1, 2, 3, 4, 5]
B = ['a', 'b', 'c','d']
A = B[:]
A[1] = 'x'
print(A, B)
=========================================
['a', 'x', 'c', 'd'] ['a', 'b', 'c', 'd']

• 原地拷贝：A[ : ] = B[ : ]，A[ : ] = B

A = [1, 2, 3, 4, 5]
B = ['a', 'b', 'c','d']
A[:] = B[:]
A[1] = 'x' #or A[:]=B
print(A, B)
=========================================
['a', 'x', 'c', 'd'] ['a', 'b', 'c', 'd']

3.3，增加列表元素

append()方法会把传入的参数追加到列表的最后面。append()方法既可接受单个值，也可接收元组、列表等，但该方法只是把元组、列表当成单个元素，这样就会形成在列表中嵌套列表、嵌套元组的情形。

a = [1, 2, 3]
b = (4, 5)
a.append(b)
print(a)
==============
[1, 2, 3, (4, 5)]

如果希望不将被追加的列表当成一个整体，而只是追加列表中的元素，则可使用列表的extend()方法。

a = [1, 2, 3]
b = (4, 5)
a.extend(b)
print(a)
=============
[1, 2, 3, 4, 5]

如果希望在列表中间增加元素，则可使用列表的insert()方法，使用insert()方法时要指定将元素插入列表的哪个位置。

a = list(range(1,6))
a.insert(3,"燕双嘤")
print(a)
====================
[1, 2, 3, '燕双嘤', 4, 5]

3.4，删除列表元素

删除列表元素使用del语句。del语句是Python的一种语句，专门用于执行删除操作，不仅用于删除列表的元素，也可用于删除变量等。

list = ["燕双嘤", 'I am a trash', 22, (9, 9), [1, 1]]
print(list)
del list[1]
print(list)
del list[:2]
print(list)
======================
['燕双嘤', 'I am a trash', 22, (9, 9), [1, 1]]
['燕双嘤', 22, (9, 9), [1, 1]]
[(9, 9), [1, 1]]

使用del不仅可以删除列表元素，还可以删除普通变量。

a = "燕双嘤"
del a
print(a)
================
Traceback (most recent call last):
  File "E:/Pycharm/WorkSpace/Study/main.py", line 3, in <module>
    print(a)
NameError: name 'a' is not defined

除使用del语句之外，Python还提供了remove()方法来删除列表元素，该方法并不是根据索引来删除缘故的，而是根据元素本身来执行删除操作的。该方法只删除第一个找到的元素，如果找不到该元素，该方法将会引发ValueError错误。

a = [1,2,3,4,5]
a.remove(6)
===============
Traceback (most recent call last):
  File "E:/Pycharm/WorkSpace/Study/main.py", line 2, in <module>
    a.remove(6)
ValueError: list.remove(x): x not in list

3.5，修改列表元素

列表的元素相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素。

a = [1, 2, 3, 4, 5]
a[0] = 0

此外，程序也可通过slice语法对列表其中一部分赋值，在执行这个操作时并不要求新赋值的元素个数与原来的元素个数相等。这意味着通过这种方式既可为列表增加元素，也可为列表删除元素。

a = [1, 2, 3, 4, 5]
a[0:2] = [0]
print(a)
a[0:1] = [1, 2]
print(a)
===================
[0, 3, 4, 5]
[1, 2, 3, 4, 5]

如果对列表中空的slice赋值，就变成了为列表插入元素。可以解决插入多个数据的问题（insert无法做到）。

a = [1, 2, 3, 4, 5]
a[0:0] = [1, 2, 3]
print(a)
===================
[1, 2, 3, 1, 2, 3, 4, 5]


a = [1, 2, 3, 4, 5]
a[0] = [1, 2, 3]
print(a)
===================
[[1, 2, 3], 2, 3, 4, 5]

如果将列表其中一段赋值为空列表，就变成了从列表中删除元素。

a = [1, 2, 3, 4, 5]
a[0:2] = []
print(a)
==================
[3, 4, 5]

PS：对列表使用slice语法赋值时，不能使用单个值；如果使用字符串赋值，Python会自动把字符串当成序列处理，其中每个字符都是一个元素。

a = [1, 2, 3, 4, 5]
a[5:6] = "燕双嘤"
print(a)
==================
[1, 2, 3, 4, 5, '燕', '双', '嘤']

在使用slice语法赋值时，也可指定step参数。但如果指定了step参数，则要求所赋值的列表元素个数大于所替换的列表元素个数。

a = [1, 2, 3, 4, 5]
a[5:8:1] = ["燕","双","嘤"]
print(a)
==================
[1, 2, 3, 4, 5, '燕', '双', '嘤']

a = [1, 2, 3, 4, 5]
a[5:8:2] = ["燕","双","嘤"]
print(a)
=================
Traceback (most recent call last):
  File "E:/Pycharm/WorkSpace/Study/main.py", line 2, in <module>
    a[5:8:2] = ["燕","双","嘤"]
ValueError: attempt to assign sequence of size 3 to extended slice of size 0

3.6，列表的其他常用方法

列表还包括一些常用方法：

• count()：用于统计列表中某个元素出现的次数。
• index()：用于判断某个元素在列表中出现的位置。
• pop()：用于将列表当成“栈”使用，实现元素出栈。
• reverse()：用于将列表中的元素反向存放。
• sort()：用于对列表元素进行排序。

需要注意的是sort()方法除支持默认排序之外，还可传入key和reverse两个参数，而且这两个参数必须通过参数名指定。key参数用于为每个元素都生成一个比较大小的“键”；reverse参数则用于执行是否反转排序——默认是从小到大排序；如果将该参数设为True，将会改变从大到小排序。

a = ["11","1","010","0000"]
a.sort(key=len)
print(a)

sort方法sorted方法的区别：sort是列表方法，只可用来对列表进行排序，是在原序列上进行修改，不会产生新的序列。内置的sorted方法可以用于任何可迭代对象（字符串，列表，元组，字典等），它会产生一个新的序列，旧的对象依然存在。如果不需要旧的列表序列，那么可以采用sort方法。 

4，元组：括号( )

4.1，简介

特点：顺序、不可增加、不可删除、可修改。读取速度比列表快

#创建方法
x = (1,2,3,4,5,6)
y = tuple('Tom', 'Jack', 'Lisa', 'Alice')
n = tuple(range(10))

元组中如果只有一个元素，则必须后面加上逗号(,) 

a = (1,)
b = (1)
c = ("1")
print(type(a), type(b), type(c))
===============================
<class 'tuple'> <class 'int'> <class 'str'>

4.2，元组的不可变性

a=(1,2)
a[1]=3
=======
Traceback (most recent call last):
  File "E:/Pycharm/WorkSpace/Study/main.py", line 2, in <module>
    a[1]=3
TypeError: 'tuple' object does not support item assignment

如果元组套列表：

a=([1,1],[2,2])
a[1][1]=3
print(a)
===============
([1, 1], [2, 3])

其实元组并没有改变，改变的只是列表。

a=([1,1],[2,2])
print(id(a[1]))
a[1][1]=[3]
print(id(a[1]))
===============
1877164949128
1877164949128

因此，元组是不可变的。

4.3，序列封包和序列解包

Python还提供了序列封包和解包的功能。简单来说，Python允许支持一下两种方式赋值：

• 序列封包：程序把多个值赋给一个变量时，Python会自动将多个值封装成元组。

x = 1, 2, 1, 3, 8
print(x)
print(type(x))
print(x[2])
===================
(1, 2, 1, 3, 8)
<class 'tuple'>
1

• 序列解包：程序允许将序列（元组或列表）直接赋值给多个变量，此时序列的各元素会被依次赋值给每个变量。

x = tuple(range(1, 10, 2))
a, b, c, d, e = x
print(a, b, c, d, e)
==========================
1 3 5 7 9

序列解包时也可以只解出部分变量，剩下的依然使用列表变量保存。 

a, *b = 1,2,3
print(a, b)
=============
1 [2, 3]

如果在赋值中同时运用了序列封包和序列解包机制，就可以让赋值运算符支持同时将多个值赋给多个变量。

a, b, c = 1, 2, 3
print(a, b, c)
================
1 2 3

实际上，相当于如下过程：

abc = 1,2,3
a,b,c = abc

5，字典：花括号{ }

比如某些有关联的数据，需要使用key-value的形式保存（Java的Map），就需要用到Python中的字典。特点：依靠键值对读取，无序(输出不唯一)，键不可变，值可变。

5.1，字典的创建

程序既可以用花括号语法来创建字典，也可使用dict()函数来创建字典。实际上，dict是一种类型，就是Python中的字典类型。

在使用花括号语法创建字典时，花括号中应包含多个key-value对，key与value之间用英文冒号隔开；多个key-value对之间用英文逗号隔开。

#一般字典
x = {
    "姓名": "燕双嘤",
    "性别": "男",
    "年龄": "22"
}
#使用元组作为key的字典
x = {
    ("姓", "名"): "燕双嘤",
    "性别": "男",
    "年龄": "22"
}

由于字典的key不可变，因此只能使用元组作为key，而不能使用列表作为key值。

a = {}
b = {3: 4}
c = {[11, 23]: 5}
d = {(11, 23): 5}
=================
Traceback (most recent call last):
  File "E:/Pycharm/WorkSpace/Study/main.py", line 3, in <module>
    c = {[11, 23]: 5}
TypeError: unhashable type: 'list'

在使用dict()函数创建字典时，可以传入多个列表或元组参数作为key-value对，每个列表或元组将被当成一个key-value对，因此这些列表或元素都只能包含两个元素。

a = [("姓名","燕双嘤"),("性别","男"),("年龄","22")]
b = dict(a)
print(b)
c = [["姓名","燕双嘤"],["性别","男"],["年龄","22"]]
d = dict(c)
print(d)
=================================================
{'姓名': '燕双嘤', '性别': '男', '年龄': '22'}
{'姓名': '燕双嘤', '性别': '男', '年龄': '22'}

还可以通过为dict指定关键字参数创建字典，此时字典的key不允许使用表达式。

a = dict(name="燕双嘤",sex="男")
print(a)
===============================
{'name': '燕双嘤', 'sex': '男'}

5.2，字典基本用法

对字典的操作都是基于key的：

• 通过key访问value。
• 通过key添加key-value对。
• 通过key删除key-value对。
• 通过key修改key-value对。
• 通过key判断指定key-value对是否存在。

通过key访问value使用的也是方括号语法，就像列表和元组一样，只是此时括号中放的是key。

a = dict(name="燕双嘤",sex="男")
print(a["sex"])

如果需要为dict添加key-value对，只需为不存在的key赋值即可。

a = dict(name="燕双嘤",sex="男")
print(a)
a["age"] = 22
print(a)

如果要删除字典的key-value对，则可使用del语句。

a = dict(name="燕双嘤",sex="男")
print(a)
del a["sex"]
print(a)

如果对dict中存在的key-value对赋值，新赋的value就会覆盖原有的value，这样便可修改字典中的key-value对。

a = dict(name="燕双嘤", sex="男")
a["name"] = "杜马"
print(a)

如果要判断字典是否包含指定的key，则可以使用in或not in运算符。需要指出的是，对dict而言，in或not in运算符都是基于key来判断的。

a = dict(name="燕双嘤", sex="男")
print("name" in a)

5.3，字典的常用方法

clear()：用于清空字典中所有的key-value对，对一个字典执行clear()方法之后，该字典就会变成一个空字典。

a = dict(name="燕双嘤", sex="男")
a.clear()

get()：根据key来获取value。当使用括号语法访问不存在的key时，字典会引发KeyError错误；但如果使用get()方法访问不存在的key，该方法会简单地返回None。

a = dict(name="燕双嘤", sex="男")
a.get("name")

update()：使用一个字典所包含的key-value对来更新已有的字典。在执行update()方法时，如果被更新的字典中已包含对应的key-value对，那么原value会被覆盖。如果被更新的字典中不包含对应的key-value对，则该key-value对被添加进去

a = dict(name="燕双嘤", sex="男")
a.update({"name": "杜马", "职位": "军统总教官"})

items()、keys()、values()：分别用于获取字典中的所有key-value对、所有key、所有value。这三个方法依次返回dict_items、dict_keys和dict_values对象，Python不希望用户直接操作这几个方法，但可通过list()函数把他们转换成列表。

a = dict(name="燕双嘤", sex="男")
print(list(a.items()))
print(list(a.keys()))
print(list(a.values()))

pop()：用于获取指定key对应的value，并删除这个key-value对。

a = dict(name="燕双嘤", sex="男")
print(a.pop("name"))

setdefault()：根据key来获取对应value的值。但该方法有一个额外的功能——当程序要获取的key在字典中不存在时，该方法会先为这个不存在的key设置一个默认的value，然后返回该key对应的value。

a = dict(name="燕双嘤", sex="男")
print(a.setdefault("age",22))
================================
22

fromkeys()：使用给定的多个key创建字典，这些key对应的value默认都是None；也可以额外传入一个参数作为默认的value。但该方法一般不会使用字典对象调用（毫无意义），通常会使用dict类直接调用。

a = dict.fromkeys(["name","sex","age"])
print(a)
=======================================
{'name': None, 'sex': None, 'age': None}

b = ("name","age")
c = ("燕双嘤",22)
a = dict.fromkeys(b,c)
print(a)
======================
{'name': ('燕双嘤', 22), 'age': ('燕双嘤', 22)}

b = ("name","age")
c = 22
a = dict.fromkeys(b,c)
print(a)
======================
{'name': 22, 'age': 22}

5.4，使用字典格式化字符串

在格式化字符串时（链接），如果要格式化的字符串模板包含多个变量，后面就需要按顺序给出多个变量，这种方式对于字符串模板中包含少量变量的情形是合适的，但如果字符串模板中包含大量变量，这种按顺序提供变量的方式则有些不合适。可改为在字符串模板中按key指定变量，然后通过字典为字符串模板中的key设置值。

temp = "书名是：%(name)s，价格是:%(price)010.2f，出版社是:%(publish)s"
book = {"name":"盗墓笔记","price":20,"publish":"南派泛娱"}
print(temp%book)
===================================================================
书名是：盗墓笔记，价格是:0000020.00，出版社是:南派泛娱

6，集合：花括号{}

6.1，创建集合

可用{}创建集合

set = {1,2,3,3}
print(set)
===============
{1, 2, 3}

通过set()函数和frozenset()函数分别创建可变集合和不可变集合。

a = set("燕双嘤")
print(a)
b = frozenset("杜马")
print(b)
===================
{'双', '燕', '嘤'}
frozenset({'马', '杜'})

PS：不可变集合是可哈希的，而可变集合中的元素是可以修改的，所以是不可哈希的。

6.2，集合运算

Python中的集合也具有一些数学上集合的用法：

Python符号	功能
in	是否是集合的的成员
not	是否不是集合的成员
==	判断集合是否相等
!=	判断集合是否相等
<	判断是否是集合的真子集
<=	判断是否是集合的子集
>	判断是否是集合的真超集
>=	判断是否是集合的超集
&	交集
|	合集
-	差补或相对补集
^	对称拆分

a = set("燕双嘤")
b = set("杜马")
print("燕" in a)
print(a == b)
print(set("燕") < a)
print(a & b, a | b, a - b, a ^ b)
=================================
True
False
True
set() {'嘤', '马', '燕', '杜', '双'} {'嘤', '双', '燕'} {'嘤', '马', '杜', '双', '燕'}

6.3，集合方法

面向所有集合的方法：

• issubset(t)：判断s是否是t的子集。
• issuperset(t)：判断s是否是t的超集。
• union(t)：返回新集合，是s和t的并集。
• intersection(t)：返回新集合，是s和t的交集。
• difference(t)：返回新集合，差补操作。
• symmeric_difference(t)：对称拆分操作。
• copy()：返回集合s的副本。

面向可变集合的方法：

• update(t)：修改s集合，使s中包含s和t并集的成员。
• intersection_update(t)：修改s集合，使s中包含s和t交集的成员。
• difference_update(t)：修改s集合，使s中包含只属于集合s但不属于集合t的成员。
• symmetric_difference_update(t)：修改s集合，使s中包含只属于s或只属于t但不同时属于s和t的成员。
• add(obj)：将对象obj添加到集合s中去。
• remove(obj)：从s中删除对象obj，如果obj不属于s，则产生KeyError异常。
• discard(obj)：从s中删除对象obj，如果不存在，则没有任何操作。
• pop()：从s中删除任意一个成员，并返回这个成员。
• clear()：将s中的成员清空。