学习目标

掌握列表创建，以及列表元素操作
掌握元组的创建与删除，并区分元组与列表
掌握字典的创建，以及字典元素操作
掌握集合的创建，以及集合运算
了解序列运算，包括序列解包、序列元素的访问等
了解其他序列类型

序列

在Python中，最基本的数据结构是序列。序列中的成员有序排列，都可以通过下标偏移量访问到它的一个或几个成员。
序列（sequence）是一种用来存放多个值的数据类型，序列中对象类型可以相同也可以不同。
序列中的每个元素可以通过索引来进行访问（集合类型除外）。
序列按照其中的元素是否可变分为可变序列和不可变序列，按照元素是否有序分为有序序列和无序序列。

列表

列表是Python内置的有序、可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开。
当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙。
在Python中，一个列表中的数据类型可以各不相同，可以同时为整数、实数、字符串等基本类型，甚至是列表、元组、字典、集合以及其他自定义类型的对象。

下面几个都是合法的列表对象：

• [‘Google’, ‘Baidu’, 1997, 2008]
• [1, 2, 3, 4, 5]
• [“a”, “b”, “c”, “d”]
• [123, [“das”, “aaa”],234]

列表是Python中最具灵活性的有序集合对象类型。和字符串不同的是，列表具有可变长度、异构以及任意嵌套列表的特点。
列表是可变对象，支持在远处修改。
Python中列表存放的元素是值得引用，并不是直接存储值，列表类似于其他语言的数组。
列表中的自动化内存管理可能会涉及列表中大量的元素移动，效率较低，因此应尽量从列表尾部进行元素的添加与删除操作，提高列表的工作效率。

1. 列表的创建（赋值）

将列表元素放置在一对方括号[]内，以逗号分隔，将这个列表赋值给变量，即可创建列表。

lst1 = ["cat", "dog", "tiger", "1024"]
lst2 = [31, 32, 101.45, "door"]
lst3 = [1, 2, ['hello', 5]]
print(lst1, lst2)
print(lst3)
'''
输出结果
['cat', 'dog', 'tiger', '1024']
[31, 32, 101.45, 'door']
[1, 2, ['hello', 5]]
'''

2. 列表的创建（list()函数）

也可以使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转化为列表。

list1 = list("abc")
list2 = list(range(1, 10, 2))
print(list1)
print(list2)
'''
输出结果：
['a', 'b', 'c']
[1, 3, 5, 7, 9]
'''

3. 列表元素的访问与计数

列表中的元素可以使用下标操作符list[index]访问列表中下标为index的元素，len(list)获取列表list的长度。
list[index]可以像变量一样使用，被称为下标变量。
当列表元素是序列时，可以采用二级下标方式list[index1][index2]

a = [1, 2, 3, 4, 5, 6, "abcd"]
print(len(a))
print(a[0])
print(a[6][0])
'''
输出结果：
7
1
a
'''

使用列表对象的index()方法获取指定元素首次出现的下标，若对象列表中不存在指定元素，则抛出异常。

aList = [3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
print(aList.index(7))
print(aList.index(1))
'''
4
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
in <module>
      1 aList = [3, 4, 5, 5.5, 7, 9, 11, 13, 15, 17]
      2 print(aList.index(7))
----> 3 print(aList.index(1))
ValueError: 1 is not in list
'''

4. 改变列表元素值

可以通过列表的下标来修改列表里面的值，格式为：
变量名[下标] = 新的值

x = [1, 1, 3, 4]
# 将列表中第二个1改为2
x[1] = 2
print(x)
'''
[1, 2, 3, 4]
'''

列表元素分段改变：

name = list('Perl')
name[1:] = list('ython')
'''
['P', 'y', 't', 'h', 'o', 'n']
'''

5. 列表元素的增加

表表元素的添加可以使用append()、extend()和insert()，或使用“+”和“*”运算符。除了“+”运算符外，其他几个方法都属于原地操作。
append()方法

通过 append()方法在当前列表尾部追加元素，是原地修改列表，速度较快。

extend()方法

使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()来增加列表元素也不改变其内存首地址，属于原地操作。

insert()方法

使用列表对象的insert(index, x)方法可以将元素添加至列表的指定位置。 列表的insert()方法可以在列表的任意位置插入元素，但由于列表的自动内存管理功能，insert()方法会引起插入位置之后所有元素的移动，这会影响处理速度。

采用+和*方法

采用+和*方法在形式上简单容易理解，但严格意义上并不是真的为列表添加元素，而是有可能会被处理为创建一个新的列表，并将原列表中的元素和新元素依次复制到新列表的内存空间。 由于设计大量元素的复制，该操作速度较慢，对于列表元素较多和进行大量数据操作过程中从性能的考虑不建议使用该方法。

# 设置元素，d为任意值
s[下标] = d
# 更新列表s，将列表d元素增加到列表s中
s += [d]
# 更新列表s，其元素重复n次
s *= n

采用+运算符

如果是通过“+”运算符来增加列表元素，实际上是创建了一个新列表，并将原列表中的元素和新元素依此复制到新列表的内存空间。由于涉及大量元素的复制，该操作速度较慢，在涉及大量元素添加时不建议使用该方法。

aList = [1, 2, 3]
aList += [4, 5]
print(aList)
'''
[1, 2, 3, 4, 5]
'''

采用*运算符

使用乘法“”来扩展列表对象，将列表与整数相乘，生成一个新列表，新列表是原列表中元素的重复。 当使用运算符将包含列表的列表重复并创建新列表时，当修改其中一个值时，相应的引用也会被修改。

bList = [[1, 2, 3]] * 3
bList[0][0] = 4
print(bList)
'''
[[4, 2, 3], [4, 2, 3], [4, 2, 3]]
'''

采用列表对象的append()方法

append()方法是将所附加的内容作为一个元素来处理，附加的内容是一个含有多个元素的列表时，相当于将该列表作为一个元素附加到原有列表的尾部。 通过append()方法在当前列表尾部追加元素，是原地修改列表，速度较快。

aList = [3, 4, 5, 6]
aList.append(7)
print(aList)
aList.append([3, 2])
print(aList)
'''
[3, 4, 5, 6, 7]
[3, 4, 5, 6, 7, [3, 2]]
'''

采用列表对象的extend()方法

使用列表对象的extend()方法可以将另一个迭代对象的所有元素添加至该列表对象尾部。通过extend()方法来增加列表元素也不改变其内存首地址，属于原地操作。

aList = [1, 2, 3, 4]
aList.extend([5, 6])
print(aList)
'''
[1, 2, 3, 4, 5, 6]
'''

采用列表对象的insert()方法

使用列表对象的insert(index,object)方法将元素添加到指定位置。第一个参数index表示插入的位置，第二个参数表示要插入的对象。 列表的insert()方法可以在列表的任意位置插入元素，但由于列表的自动内存管理功能，insert()方法会引起插入位置之后所有元素的移动，这会影响处理速度。

a = [1, 2, 3, 5]
# 在下标为3的位置插入元素6
a.insert(3, 6)
print(a)
'''
[1, 2, 3, 6, 5]
'''

6. 列表元素的删除

可以采用以下三种方式：

• 使用del命令删除列表中指定位置的元素。如同一般的变量，del命令也可以删除整个列表变量。
• 使用列表的pop方法删除并返回指定位置（默认为最后一个）上的元素。若指定的索引超出列表的范围，会抛出异常。
• 使用列表的remove()方法删除首次出现的元素。若没有此元素，会抛出异常。 ```python names = [‘one’, ‘two’, ‘three’, ‘four’, ‘five’, ‘six’]

  删除names的第二个元素

  del names[1]

  删除names的第二个至第四个元素

  names[1:4] = [] print(names)

‘’’ [‘one’, ‘six’] ‘’’

<a name="WCIyU"></a>
## 7. 列表元素的排序和反转
列表结构具有对象自身提供的sort()方法进行原地排序，即这种排序是永久性排序，将会按照顺序改变列表中元素的次序。<br />若要按与字母顺序相反的顺序排列列表元素，只需向sort()方法传递参数reverse=True
```python
cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()
# 改变了列表中元素的顺序
print(cars)
# 改变了列表中元素的顺序
cars.sort(reverse = True)
print(cars)
'''
['audi', 'bmw', 'subaru', 'toyota']
['toyota', 'subaru', 'bmw', 'audi']
'''

要保留列表元素原来的排列顺序，同时以特定的顺序呈现它，可使用内置函数sorted()。
sorted(iterable, key = None, reverse = False)
返回系列的排序列表。
函数sorted()让你能够按特定顺序显示列表元素，同时不影响它在列表中的原始排序。

cars = ['bmw', 'audi', 'toyota', 'subaru']
print(sorted(cars))
# 并没有实际改变列表中元素的顺序
print(cars)
s3 = 'abAC'
sorted(s3, key = str.lower)
'''
['audi', 'bmw', 'subaru', 'toyota']
['bmw', 'audi', 'toyota', 'subaru']
['a', 'A', 'b', 'C']
'''

sorted()排序后会生成新列表，原列表不会改变。
reverse()方法用于将列表所有元素逆序或翻转。

a = [15, 8, 14, 16, 10, 19, 13, 18, 11, 17, 12, 9]
print(id(a))
b = sorted(a)
print(b)
print(id(b))
# 原地排序，指定排序依据根据字符串大小
a.sort(key = str)
print(a)
print(id(a))
# 反转列表，原地操作
a.reverse()
print(a)
print(id(a))
'''
2363174214400
[8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
2363174198336
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 8, 9]
2363174214400
[9, 8, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10]
2363174214400
'''

8. 列表切片操作

使用语法“list_name[start:end:step]”来返回列表list_name的一个片段。start表示切片开始位置，默认为0；end表示切片截止（但不包括）位置，默认为列表长度；step表示切片的步长，默认为1。
当start为0时可以省略，当end为列表长度时可以省略，当step为1时可以省略，省略步长时还可以同时省略最后一个冒号。
当step为负整数时，表示反向切片，这时start位置应该在end位置的右侧，否则会返回空列表，start默认为-1，end默认为列表第1个元素前面的位置。-1表示列表最后一个元素的位置，其他以此类推。

numbers = [1, 2, 3, 4, 5, 6, 7, 8]
# 返回包含原列表中所有元素的新列表
print(numbers[::])
# 从第一个元素开始，隔一个取元素
print(numbers[::2])
# 反向切片
print(numbers[::-1])
# 指定切片开始位置和结束位置，步长默认为1
print(numbers[1:3])
# 指定切片开始位置和步长，省略结束位置
print(numbers[1::2])
'''
[1, 2, 3, 4, 5, 6, 7, 8]
[1, 3, 5, 7]
[8, 7, 6, 5, 4, 3, 2, 1]
[2, 3]
[2, 4, 6, 8]
'''

使用切片获取列表的部分元素

使用切片可以返回列表中部分元素组成的新列表。切片操作不会因为下标越界而抛出异常，而是简单地在列表尾部截断或返回一个空列表，代码具有更强的健壮性。

使用切片为列表增加/删除元素

可以使用切片操作在列表任意位置插入新元素，但是并不影响列表对象的内存地址，属于原地操作。

num = [1, 2, 3, 4, 5]
num[len(num):] = [6, 7, 8]
print(num)
num[:0] = [-2, -1]
print(num)
aList = [3, 5, 7, 9]
# 删除列表中前3个元素
aList[:3] = []
print(aList)
'''
[1, 2, 3, 4, 5, 6, 7, 8]
[-2, -1, 1, 2, 3, 4, 5, 6, 7, 8]
[9]
'''

9. 列表成员测试

使用in/not in运算符可以判断一个元素是否在列表中。

aList = [1, 2, 3]
a = 2
print(a in aList)
print(4 not in aList)
'''
True
True
'''

10. 列表的比较

关系运算符（<、>、==、!=、<=、>=）也可以用来对列表进行比较。

list1 = [1, 2, 3]
list2 = [2, 5, 6]
print(list1 > list2)
print(list1 < list2)
'''
False
True
'''

列表中的元素随机排列shuffle()函数

shuffle()函数：random模块中的shuffle()函数可实现随机排列列表中的元素。

import random
list1 = [2, 3, 7, 1, 6, 12]
random.shuffle(list1)
list1
'''
[6, 3, 12, 2, 7, 1]
'''

序列及列表总结

在Python中字符串、列表以及后面要讲的元组都是序列类型。
所谓序列，即成员有序排列，并且可以通过偏移量访问到它的一个或几个成员。
序列中的每个元素都被分配一个数字—它的位置，也称为索引，第一个索引是0，第二个索引是1，依此类推。
序列都可以进行的操作包括索引、切片、加、乘、检查成员。
Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

序列的常见操作总结表

列表对象常用的方法总结表

可以利用dir()来查看列表的方法：

dir(list)
'''
['__add__',
 '__class__',
 '__class_getitem__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']
'''

元组

列表的功能虽然很强大，但负担也很重，在很大程度上影响了运行效率。有时候我们并不需要那么多功能，很希望能有个轻量级的列表，元组（tuple）正是这样一种类型。
列表和元组都属于有序序列，都支持使用双向索引访问其中的元素。
元组属于不可变（immutable）序列，一旦被创建，元组内的元素不可以修改，也无法添加或删除元素，若要调整，只能重新建立元组。
元组没有提供append()、extend()和insert()等方法，无法向元组中添加元素；同样，元组也没有remove()和pop()方法，也不支持对元组元素进行del操作，不能从元组中删除元素，而只能使用del命令删除整个元组。
虽然tuple的元素不可改变，但它可以包含可变对象，比如list列表，可改变元组中可变对象的值。

tuple4 = ('a', 'b', ['A', 'B'])
tuple4[2][0] = 'X'
tuple4[2][1] = 'Y'
tuple4[2][2:] = 'Z'
print(tuple4)
'''
('a', 'b', ['X', 'Y', 'Z'])
'''

元组也支持切片操作，但是只能通过切片来访问元组中的元素，而不允许使用切片来修改元组中元素的值，也不支持使用切片操作来为元组增加或删除元素。
Python内部实现对元组做了大量优化，访问速度比列表更快。如果定义了一系列常量值，主要用途仅是对它们进行遍历或其他类似用途，而不需要对其元素进行任何修改，那么一般建议使用元组而不用列表。
元组属于不可变序列。采用圆括号中用逗号分隔的方式进行定义，圆括号可以省略。
也可以使用tuple()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。
与列表相同，元组中的元素也可以为基本数据类型或者列表、元组等序列类型。
若要创建只包含一个元素的元组，要在元素后加一个逗号。

a = (1, 'a', [2, 3])
b = tuple('abc')
color_tuple = 'Red', 'Green', 'Blue'
# 和t2 = 4 是一样的
t2 = (4)
# 元组中只有一个元素，必须在后面多写一个逗号
t3 = (4,)
# 将其他迭代对象转换为元组
t4 = tuple(range(5))
print(a)
print(b)
print(color_tuple)
print(t2)
print(t3)
print(t4)
'''
(1, 'a', [2, 3])
('a', 'b', 'c')
('Red', 'Green', 'Blue')
4
(4,)
(0, 1, 2, 3, 4)
'''

元组的基本操作

元组也是序列，因此一些用于列表的基本操作也可以用在元组上。
可以使用下标访问元组的元素，支持两个方法count()和index()，提供in和not in运算符来判断元素是否在元组中，提供对元组进行切片等。

t = (1, 2, 3)
tt = tuple(range(4, 7))
print("The second element in t is %d"%t[1])
# 元组连接
ttt = t + tt
print(ttt)
# 元组切片
tttt = ttt[2:7]
print(tttt)
# 计算指定元素出现的次数
print(tttt.count(2))
# 计算指定元素第一次出现的下标
print(tttt.index(5))
# 元组可以数乘
t2 = (1, 2, 3) * 3
print(t2)
'''
The second element in t is 2
(1, 2, 3, 4, 5, 6)
(3, 4, 5, 6)
0
2
(1, 2, 3, 1, 2, 3, 1, 2, 3)
'''

list()函数可以将元组转换为列表。
tuple()函数可以将列表转换为元组。

a = tuple([1, 3, 5])
b = list((1, 3, 5))
print(a)
print(b)
'''
(1, 3, 5)
[1, 3, 5]
'''

tup = tuple('bar')
print('输出元组tup：', tup)
nested_tup = (4, 5, 6,),(7, 8)
# 输出元素是元组的元组
print('输出元组tup：', nested_tup)
print('元组的连接', tup + tuple('wwy'))
# 元组的拆分
a, b , c = tup
print(a, b, c)
# 统计某个数值在元组中出现的次数
print(tup.count(a))
'''
输出元组tup： ('b', 'a', 'r')
输出元组tup： ((4, 5, 6), (7, 8))
元组的连接 ('b', 'a', 'r', 'w', 'w', 'y')
b a r
1
'''

像列表一样，也可以用for循环来遍历元组中的所有值。

元组的用途

元组有很多用途，例如：坐标(x, y)，数据库中的员工记录。
元组的访问和处理速度比列表更快，如果主要用途是对元素遍历或查找，而不需要对元素进行修改，一般建议使用元组而不是列表。
另一方面，由于元组的内在实现不允许修改其元素值，从而适用于在一些场合中进行数据的保护。

字典

字典是一种通过名字或关键字引用的数据结构，其键可以是数字、字符串、元组，这种结构类型也称为映射。字典类型是Python中唯一内建的映射类型。
字典，也称映射，是一个由键/值对组成的非排序可变集合体。键值对在字典中以下面的方式标记：
dict = {key1:value1, key2:value2}
键/值对用冒号分割，而各个元素之间用逗号分隔，所有元素都包括在花括号中。
字典中元素的“键”可以使Python中任意不可变数据，例如整数、实数、复数、字符串、元组等可哈希数据，但不能使用列表、集合、字典或其他可变类型作为字典的“键”。
在同一个字典中，“键（key）”必须是唯一的，但“值（value）”是可以重复的。
列表是有序的对象集合，字典是无序对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

1. 字典的创建

直接利用大括号{}内添加键值对的方式进行内容的赋值。

d = {'one':1, 'two':2, 'three':3}
print(d)
dict1 = {'Alice':'2341', 'Beth':'9102','Cecil':'3258'}
# 为字典添加元素
dict1['Jack'] = '1234'
print(dict1)
type(dict1)
'''
{'one': 1, 'two': 2, 'three': 3}
{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258', 'Jack': '1234'}
dict
'''

通过内置的dict()函数来创建。

# 定义一个列表
lot = [(1, 'a'), (2, 'b'), (3, 'c')]
# 使用dict类转换列表到字典
dict1 = dict(lot)
print(dict1)
'''
{1: 'a', 2: 'b', 3: 'c'}
'''

通过关键字创建字典。

d = dict(one = 1, two = 2, three = 3)
print(d)
print(d['one'])
print(d['three'])
'''
{'one': 1, 'two': 2, 'three': 3}
1
3
'''

2. 字典的基本操作

字典元素的访问

aDict = {'年龄':19, '成绩':[85, 90, 68, 72], '姓名':'王宁', 'sex':'男'}
# 访问“键”对应的“值”
print(aDict["年龄"])
print(aDict.get('name', 'Not Exists.'))
# 访问所有“键”
print(aDict.keys())
# 访问所有“值”
print(aDict.values())
# 返回整个字典内容
print(aDict.items())
'''
19
Not Exists.
dict_keys(['年龄', '成绩', '姓名', 'sex'])
dict_values([19, [85, 90, 68, 72], '王宁', '男'])
dict_items([('年龄', 19), ('成绩', [85, 90, 68, 72]), ('姓名', '王宁'), ('sex', '男')])
'''

字典元素的添加

使用字典的update()方法来添加元素，还可以使用“键”的方式来增加元素。

aDict = {'年龄':19, '成绩':[85, 90, 68, 72], '姓名':'王宁', 'sex':'男'}
aDict['年龄'] = 20
# 使用键的方式添加元素
aDict['地址'] = "西安市长安区西京路1号"
# 使用updata()方法添加元素
aDict.update({"电话":"13456789012"})
print(aDict)
'''
{'年龄': 20, '成绩': [85, 90, 68, 72], '姓名': '王宁', 'sex': '男', '地址': '西安市长安区西京路1号', '电话': '13456789012'}
'''

字典元素的修改

通过“键”的方式来赋值或使用update()方法

aDict = {'年龄':19, '成绩':{85, 90, 68, 72}, '姓名':'王宁', 'sex':'男'}
aDict.update({"成绩":[80,90,68,72]})
print(aDict)
aDict["成绩"] = [60, 70, 80, 90]
print(aDict)
'''
{'年龄': 19, '成绩': [80, 90, 68, 72], '姓名': '王宁', 'sex': '男'}
{'年龄': 19, '成绩': [60, 70, 80, 90], '姓名': '王宁', 'sex': '男'}
'''

字典元素的删除

删除字典元素可以使用del命令、使用字典对象的pop()和popitem()方法等方式。
如果要删除字典所有元素使用clear()方法。

aDict = {'年龄':19, '成绩':{85, 90, 68, 72}, '姓名':'王宁', 'sex':'男'}
del aDict["成绩"]
print(aDict)
# 删除指定键对应的元素
aDict.pop("sex")
print(aDict)
# 弹出一个元素，对空字典会抛出异常
aDict.popitem()
print(aDict)
aDict.clear()
print(aDict)
'''
{'年龄': 19, '姓名': '王宁', 'sex': '男'}
{'年龄': 19, '姓名': '王宁'}
{'年龄': 19}
{}
'''

通过zip()函数协助构造字典

zip()函数的作用是将可迭代对象作为参数，将对象中对应的元素打包成多个元组，然后返回由这些元组组成的对象。

keys = ['ftp', 'telnt', 'www']
values = [21, 23, 80]
d = dict(zip(keys, values))
print(d)
'''
{'ftp': 21, 'telnt': 23, 'www': 80}
'''

3. 字典的常用方法总结表

4. 对字典的转换

可以使用函数tuple()和list()将字典转换为元组和列表，但要注意的是，这里的转换后和之前的元素顺序是不同的，因为字典类似于散列，列表类似于链表，元组类似于列表只是元素无法改变，所以，要把散列转换为链表而顺序不变是不可行的。

fruit_dict = {'apple':1, 'banana':2, 'orange':3}
# 将字典的key转换为元组
dict1 = tuple(fruit_dict)
print(dict1)
# 将字典的值转换为元组
dict2 = tuple(fruit_dict.values())
print(dict2)
# 将字典得key转换为列表
dict3 = list(fruit_dict)
print(dict3)
# 将字典的值转换为列表
dict4 = list(fruit_dict.values())
print(dict4)
'''
('apple', 'banana', 'orange')
(1, 2, 3)
['apple', 'banana', 'orange']
[1, 2, 3]
'''

集合

集合（set）属于Python无序可变序列，使用一对大括号“{}”作为定界符，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，元素之间不允许重复。
集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，而不能包含列表、字典、集合等可变类型的数据。

1. 集合的创建

• 直接将集合赋值给变量，即可创建一个集合对象。
• 也可以使用set()函数将列表、元组、字符串、range对象等可迭代对象转换为集合，如果原来的数据中存在重复元素，则在转换为集合的时候只保留一个；如果原序列或迭代对象中有不可哈希的值，无法转换为集合，则抛出异常。
• 创建空集合比较特殊。创建一个空集合必须用set()函数，因为{}是用来创建一个空字典。 ```python s = {‘P’, ‘y’, ‘t’, ‘h’, ‘o’, ‘n’}

  整形的集合

  s1 = {1, 2, 3}

  混合类型的集合

  s2 = {1.0, ‘Python’, (1, 2, 3)}

  从列表创建

  s3 = set([‘P’, ‘y’]) s4 = set() print(s, s1, s2, s3, s4) type(s4)

‘’’ {‘y’, ‘o’, ‘P’, ‘h’, ‘t’, ‘n’} {1, 2, 3} {1.0, (1, 2, 3), ‘Python’} {‘y’, ‘P’} set() set ‘’’

<a name="lmHM1"></a>
## 2. 集合的基本操作
<a name="stcRF"></a>
### 2.1 集合元素的增加
使用集合对象的add()方法可以增加新元素，如果该元素已存在则忽略该操作，不会抛出异常；update()方法用于合并另外一个集合汇总的元素到当前集合汇总，并自动去除重复元素。
```python
s1 = {1, 2}
s1.add(3)
print(s1)
s1.update([6, 4, 3])
print(s1)
'''
{1, 2, 3}
{1, 2, 3, 4, 6}
'''

2.2 集合元素的删除

• pop()方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常。
• remove()方法用于删除集合中的元素，如果指定元素不存在则抛出异常。
• discard()用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作。
• clear()方法清空集合删除所有元素。 ```python set4 = {1, 2, 3, 4} set4.discard(4) print(set4) set4.pop() print(set4) set4.clear() print(set4)

‘’’ {1, 2, 3} {2, 3} set() ‘’’

<a name="Fz99z"></a>
### 2.3 集合运算
Python集合支持交集、并集、差集、对称差集等运算，此外还包括集合大小的比较、子集与父集的判断等。
| 集合运算 | 运算符 | 集合对象的方法 |
| --- | --- | --- |
| 并集 | a &#124; b | a.union(b) |
| 交集 | a & b | a.intersection(b) |
| 差集 | a - b | a.difference(b) |
| 对称差集 | a ^ b | a.symmetric_difference(b) |
| 比较大小 | a < b, a > b, a <= b, a >= b |  |
| 子集 | a.issubset(b) |  |
| 父集 | a.issuperset(b) |  |
使用“&”操作符执行交集操作，也可使用集合对象的方法intersection()完成。
```python
A = {1, 2, 3, 4, 5, 6, 7, 8}
B = {0, 3, 4, 5}
# 用运算符求集合A和B的交集
print(A & B)
# 用函数求集合A和B的交集
print(A.intersection(B))
'''
{3, 4, 5}
{3, 4, 5}
'''

2.4 利用dir()来查看方法列表

dir(set)
'''
['__and__',
 '__class__',
 '__class_getitem__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__iand__',
 '__init__',
 '__init_subclass__',
 '__ior__',
 '__isub__',
 '__iter__',
 '__ixor__',
 '__le__',
 '__len__',
 '__lt__',
 '__ne__',
 '__new__',
 '__or__',
 '__rand__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__ror__',
 '__rsub__',
 '__rxor__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__xor__',
 'add',
 'clear',
 'copy',
 'difference',
 'difference_update',
 'discard',
 'intersection',
 'intersection_update',
 'isdisjoint',
 'issubset',
 'issuperset',
 'pop',
 'remove',
 'symmetric_difference',
 'symmetric_difference_update',
 'union',
 'update']
 '''

2.5 set各方法列表

如果有方法不会用，可利用help()函数，查看用途及详细说明。

2.6 集合与内置函数

序列的基本运算

1. 大小比较

• 当两个列表或元组比较大小时，从第一个元素顺序开始比较，如果相等则继续。
• 返回第一个不相等元素比较的结果。
• 如果所有元素比较均相等，则长的列表大，一样长则两列表相等。 ```python a = [1, 2, 3] b = [1, 3, 5] c = [1, 2, 3, -1] print(a < b, a < c, b < c) print((1, 2, 3) == {1.0, 2.0, 3.0}) ‘hello’ > ‘world’

‘’’ True True False False False ‘’’

<a name="VF6el"></a>
## 2. 基本计算
通过内置函数len()、max()、min()，可以获取序列的长度、元素最大值、元素最小值。<br />内置函数sum()可获取列表或元组个元素之和。如果有非数值元素，则导致TupeError。对于字符串（str）和字节数据（bytes），也将导致TypeError。<br />这些基本计算函数均适用于列表、元组、字符串、集合、range对象和字典等序列结构。<br />通过内置函数all()和any()，可以判断序列的元素是否全部和部分为True。
```python
s = 'abcdefg'
print(len(s), max(s), min(s), sep = ',')
a = {1:1, 2:5, 3:8}
print(sum(a), sum(a.values()), max(a), max(a.values()), sep = ',')
print(any((1, 2, 0)))
print(all([1, 2, 0]))
'''
7,g,a
6,14,3,8
True
False
'''

总结

列表、字符串、元组属于有序序列，支持双向索引，支持切片操作。
字典和集合属于无序序列，字典可以通过“键”作为下标来访问字典中的“值”，集合不支持使用下标方式来访问。
列表支持在任意位置插入和删除元素，但一般建议尽量从列表的尾部进行插入和删除，这样可以获得更高的速度。
切片可以返回列表、元组、字符串中的部分元素，也可以对列表中的元素进行修改。
列表是比数组更加方便灵活和功能强大的数据结构
元组属于不可变序列，一旦创建就不能修改
字典提供了通过键值访问数据的方式
集合对集合运算的支持更好