可以使用元组存储一个固定的元素列表，使用集合存储和快速访问不重复的元素、使用字典存储键值对并使用这些关键字来快速访问元素。

一、元组

        元组跟列表类似，但是元组中的元素是固定的;也就是说，一旦一个元组被创建,就无法对元组中的元素进行添加、删除、替换或重新排序。

        如果在应用中不应该对列表中的内容进行修改，那么就可以使用元组来防止元素被意外添加、删除或替换。除了元组的元素是固定的以外，元组与列表很像。进一步讲，由于Python的实现，元组比列表的效率更高。

        可以通过将元素用一对括号括起来来创建一个元组。这些元素用逗号分隔。可以创建一个空元组或从一个列表创建一个元组， 如下面的例子所示。

t1 = () # Create an empty tuple
t2 = (1，3，5) # Create a tuple with three el ements
# Create a tuple from a list
t3 = tup1e([2 * x for x in range(1， 5)])

        也可以从一个字符串创建一个元组。字符串中的每个字就变成了元组的一个元素。例如:

# Create a tuple from a string
t4 = tuple("abac") # t4 is ['a'. 'b', 'a'. 'c']

        元组是序列。在表10-1中针对序列的常见操作也可以用在元组上。可以在元组上使用len、min、max和sum函数。可以使用一个for循环遍历一个元组的所有元素，并使用一个下标运算符来访问元组中对应的元素或元素段。可以使用in和not in运算符来判断一个元素是否在元组中，并使用比较运算符来对元组中的元素进行比较。

“元组的元素是固定的”是指不能给一个元组添加、删除和替换元素以及打乱元组中的元素。

注意：一个元组包含了一个固定的元素列表。一个元组里的一个个体元素可能是易变的。例如，下面的代码创建了一个圆的元组(第2行)，并改变第一个圆的半径为30(第3行)。

>>> from CircleFromGeometricObject import Circle
>>> circles = (Circle(2)， Circle(4)， Circle(7))
>>> circles[0].setRadius(30)
>>> circles[0].getRadius()
>>> 30
>>>

        在这个例子中，元组中每一个元素都是一个圆对象。尽管不能添加、删除或替换元组中的圆对象，但是可以改变一个圆的半径，因为一个圆对象是可变的。如果一个元组包含不可变的对象，那么这个元组被称为不可变的。例如，一个数字元组或一个字符串元组是不可变的。

二、集合

关键点：集合与列表类似，可以使用它们存储一个元素集合。但是，不同于列表，集合中的元素是不重复且不是按任何特定顺序放置的。

如果你的应用程序不关心元素的顺序，使用一个集合来存储元素比使用列表效率更高。
 

2.1、创建集合

        可以通过将元素用一对花括号( { })括起来以创建一个元素集合。集合中的元素用逗号分隔。可以创建一个空集，或者从一个列表或一个元组创建一个集合，如下面的例子所示。

s1 = set() # Create an empty set
s2 = {1, 3, 5} # Create a set with three e lements
s3 = set((1, 3, 5)) # Create a set from a tuple
# Create a set from a list
s4 = set([x * 2 for x in range(1, 10)])

        同样的，可以通过使用语法list(set)或tuple(set)从集合创建一个列表或一个元组。

        也可以从一个字符串创建一个集合。 字符串中的每个字符就成为集合中的一个元素。

例如:

# Create a set from a string
s5 = set("abac") # s5 is {'a'，'b'，'c'}

注意：尽管字符a在字符串中出现了两次，但在集合中只出现了一次，因为一个集合中不存储重复的元素。

        一个集合可以包含类型相同或不同的元素。例如: s= {1,2,3,"one" ,"two" ,"three"}是一个包含数字和字符串的集合。集合中的每个元素必须是哈希的( hashable)。Python 中的每一个对象都有一个哈希值，而且如果在对象的生命周期里对象的哈希值从未改变，那么这个对象是哈希的。目前所介绍的所有类型对象除了列表之外都是哈希的。

2.2、操作和访问集合

        可以通过使用add(e)或remove(e)方法来对一个集合添加或删除元素。可以使用函数len、min、 max和sum对集合操作，可以使用for循环遍历一个集合中的所有元素。

        可以使用in或not in运算符来判断一个元素是否在一个集合当中

注意：如果删除一个集合中不存在的元素，remove(e) 方法将抛出一个KeyError异常。

2.3、 子集和超集

如果集合s1中的每个元素都在集合s2中，则称s1是s2的子集。可以使用s1.issubset(s2)方法来判断s1是否是s2的子集，如下面代码所示。

>>> s1={1，2，4}
>>> s2={1,4，5，2，6}
>>> s1.issubset(s2) # s1 is a subset of s2
True
>>>

如果一个集合s2中的元素同样都在集合s1中，则称集合s1是集合s2的超集。可以使用s1.issuperset(s2)方法来判断s1是否是s2的超集，如下面代码所示。

>>> s1={1，2,4}
>>> s2={1,4，5，2，6}
>>> s2.issuperset(s1) # s2 is a superset of s1
True
>>>

2.4、相等性测试

        可以使用运算符==和!=来检测两个集合是否包含相同的元素。例如:

>>> s1={1，2，4}
>>> s2={1，4，2}
>>> s1==s2
True
>>> s1 != s2
False
>>>

在这个例子中，尽管s1和s2的元素顺序不同，但是这两个集合包含相同的元素。

注意：使用传统的比较运算符(>、>=、<=和<)来比较集合毫无意义，因为集合中的元素并没有排序。但是，当这些操作符用在集合上时有着特殊的含义：

• 如果s1是s2的一个真子集，则s1<s2返回True。
• 如果s1是s2的一个子集，则s1<=s2返回True。
• 如果s1是s2的一个真超集，则s1>s2返回True。
• 如果s1是s2的一个超集，则s1>=s2返回True。

        注意：如果s1是s2的一个真子集，那么s1的每个元素同样也都在s2中，但是s2中至少存在一个不在s1中的元素。如果s1是s2的一个真子集，那么s2是s1的一个真超集。

2.5、集合运算

Python提供了求并集、交集、差集和对称差集合的运算方法。

两个集合的并集是一个包含这两个集合所有元素的集合。可以使用union方法或者 | 运算符来实现这个操作。例如:

>>> s1={1，2，4}
>>> s2={1，3，5}
>>> s1.union(s2)
{1，2，3，4，5}
>>>
>>> s1 | s2
{1,2，3，4，5}
>>>

两个集合的交集是-一个包含了两个集合共同的元素的集合。可以使用intersection方法或者&运算符来实现这个操作。例如:

>>> s1={1, 2, 4}
>>> s2={1, 3, 5}
>>> s1.intersection(s2)
{1}
>>>
>>> s1 & s2
{1}
>>>

set1和set2之间的差集是一个包含了出现在set1但不出现在set2的元素的集合。可以使用difference方法或 - 运算符来实现这个操作。例如:

>>> s1={1,2，4}
>>> s2={1，3，5}
>>> sl.difference(s2)
{2，4}
>>>
>>> s1 - s2
{2，4}
>>

        两个集合之间的对称差(或者称为异或)集合是一个包含了除它们共同元素之外所有在这两个集合之中的元素。可以使用symmertric_difference 方法或 ^ 运算符来实现这个操作。
例如:

>>> s1={1, 2, 4}
>>> s2={1, 3, 5}
>>> s1.symmetric_difference(s2)
{2，3，4，5}
>>>
>>> s1 ^ s2
{2，3，4，5}
>>>

注意：这些set方法都返回一个结果集合，但是它们并不会改变这些集合中的元素。

三、比较集合和列表的性能

关键点：对于in和not in运算符和remove方法，集合比列表的效率更高。

        列表中的元素可以使用下标运算符来访问。但是，集合并不支持下标运算符，因为集合中的元素是无序的。使用for循环遍历集合中的所有元素。

四、字典

关键点：一个字典是一个存储键值对集合的容器对象。它通过使用关键字实现快速获取、删除和更新值。

        假设程序需要存储“No-Fly” 表中有关恐怖分子的详细信息。字典就是这个任务的一种有效的数据结构。一个字典是按照关键字存储值的集合。这些关键字很像下标运算符。在一个列表中，下标是整数。在一个字典中，关键字必须是一个可哈希对象。一个字典不能包含有重复的关键字。每个关键字都对应着一个值。一个关键字和它对应的值形成存储在字典中的一个条目(输入域)，如图所示。

        这种数据结构被称为“字典"，因为它与词典很类似，在这里，单词就相当于关键字而这些单词的详细定义就是相应的值。一个字典也被认为是一张图，它将每个关键字和一个值相匹配。

4.1、 创建一个字典

        可以通过一对花括号({ })将这些条目括起来以创建一个字典。每一个条目都由一个关键字，然后跟着一个冒号，再跟着一个值组成。每一个条目都用逗号分隔。例如，下面语句:

students = {"111-34-3434":"John", "132-56-6290":"Peter"}

        创建一个具有两个条目的字典，如图14-1b所示。字典中的每一个条目的形式都是key:value。第一个条目的关键字是111-34-3434，它对应的值是John。关键字必须是可哈希类型，例如:数字和字符串。而值可以是任意类型。可以使用下面的语法来创建一个空字典。

students = {} # Create an empty dictionary

注意: Python 使用花括号创建集合和字典。 语法{ }被用来表示一个空字典。 为了创建一个空集合，使用set()。

4.2、 添加、修改和获取值

为了添加一个条目到字典中，使用语法:

dictionaryName[key] = value

例如:

students["234-56-9010"] = "Susan"

        如果这个关键字已经在字典中存在，前面的语法将替换该关键字对应的值。为了获取一个值，只要使用dictionaryName[key]编写一个表达式即可。如果该关键字在字典中，那么返回这个关键字对应的值。否则，抛出一个KeyError异常。

4.3、删除条目

为了从字典删除一个条目，使用语法:

del dictionaryName[key]

例如:

del students["234-56-9010"]

        这条语句从字典中删除关键字为234-56-9010的对应条目。如果字典中不存在该关键字，那么抛出一个KeyError异常。

4.4、循环条目

        可以使用一个for循环来遍历字典中所有的关键字。例如:

1 >>> students = {"111-34-3434": "John"，"132-56-6290":"Peter"}
2 >>> for key in students :
3 ...     print(key + ":" + str(students[key]))
4 ...
5 "111- 34- 3434":"John"
6 "132- 56-6290":"Peter" 
7 >>>

        for循环对字典students中的关键字进行迭代(第2行)。students[key] 返回关键字key对应的值(第3行)。

4.5、 len 函数

可以使用len(dictionary)来获得一个字典中条目的数目。例如:

1 >>> students = {"111-34-3434":"John"， "132-56- 6290" :"Peter"}
2 >>> len(students)
3 2
4 >>>

在第2行，len(students)返回字典students中条目的数目。

4.6、检测一个关键字是否在字典中

可以使用in或not in运算符来判断一个关键字是否在一个字典当中。例如:

1 >>> students = {"111-34-3434":"John", "132-56- 6290":"Peter"}
2 >>> "111-34-3434" in s tudents
3 True
4 >>> "999-34-3434" in students
5 False
6 >>>

        在第2行，"111-34-3434" in students 将检测关键字111-34-3434 是否在字典students 中。

4.7、相等性检测

可以使用运算符==和!=来检测两个字典是否包含同样的条目。例如:

>>> d1 = {"red":41， "blue":3}
>>> d2 = {"b1ue":3， "red":41}
>>> d1 == d2
True
>>> d1 != d2
False

在这个例子中，不管这些条目在字典中的顺序，d1和d2包含有相同的条目。

注意：不能使用比较运算符(>、>=、<=和<)对字典进行比较，因为字典中的条目是没有顺序的。

4.8、字典方法

        Python中的字典类是dict。

        get(key)方法除了当关键字key不在字典中时返回None而不是抛出一个异常，其他都与dictionaryName[key]类似。pop(key) 方法与del dictionaryName[key]类似。

五、总结

• 一个元组是一个固定列表。不能对元组中的元素进行添加、删除或替换。
• 由于元组是一个序列，所以序列的常用操作也可以用于元组。
• 尽管不能对元组进行元素的添加、删除或者替换，但是如果该元素是可变的话你可以改变这个单独元素的内容。
• 如果元组的所有元素都是不可变的，那么这个元组是不可变的。
• 集合就像是用来存储元素集的列表。但是，不同于列表，集合中的元素是不可重复的而且是没有以特定顺序放置的。
• 可以使用add方法向一个集合添加元素，使用remove方法从一个集合删除元素。
• 函数len. min、 max和sum都可用在集合上。
• 可以使用一个for循环来遍历集合中的元素。
• 可以使用issubset或issuperset方法来检测一个集合是否是另一个集合的子集或父集，并使用|、&、-和^运算符来实现求集合的并集、交集、差集和对称差集。
• 在判断一个元素是否存在于集合或列表中，以及从集合或列表删除元素时，集合都比列表的效率更高。
• 字典可用于存储键值对。可以使用一个关键字来获取一个值。这些关键字就像是一个下标操作符。
• 在一个列表中，这些下标都是整数。在一个字典中，这些关键字可以是任意的可哈希对象，例如:数字和字符串。
• 可以使用dictionaryName[key]来获取字典中某个给定关键字对应的值，并使用dictionaryName[key]=value来添加或修改字典中的一个条目。
• 可以使用del dictionaryName[key]删除给定关键字对应的条目。
• 可以使用一个for循环来遍历一个字典中的所有关键字。
• 可以使用len函数返回字典的所有条目数。
• 可以使用in和not in运算符来确定一个关键字是否在字典当中，使用==和!=操作符来检测两个字典是否相同。
• 可以对字典使用keys(、values()、 iterms()、 clear()、 get(key)、 pop(key) 和popitem()方法。