我心中的王者：Python-第10章 集合(Set)

我心中的王者：Python-第10章　集合(Set)

集合的基本观念是无序且每个元素是唯一的，集合元素的内容是不可变的(immutable)，常见的元素有整数(intger)、浮点数(float)、字符串(string)、元组(tuple)等。至于可变(mutable)内容列表(list)、字典(dict)、集合(set)等不可以是集合元素。但是集合本身是可变的(mutable)，我们可以增加或删除集合的元素。

10-1　建立集合

Python可以使用大括号“{ }”或set( )函数建立集合，下列将分别说明。

10-1-1　使用大括号建立集合

Python允许我们直接使用大括号“{ }”设定集合，例如，集合名称是langs，内容是‘Python’、‘C’、‘Java’。可以使用下列方式设定集合。

程序实例ch10_1.py：基本集合的建立。

# ch10_1.py
langs = {'Python', 'C', 'Java'}
print("打印集合 = ", langs)
print("打印类别 = ", type(langs))

执行结果

打印集合 =  {'C', 'Python', 'Java'}
打印类别 =  <class 'set'>

集合的特色是元素是唯一的，所以如果设定集合时有重复元素情形，多的部分将被舍去。

程序实例ch10_2.py：基本集合的建立，建立时部分元素重复，观察执行结果。

# ch10_2.py
langs = {'Python', 'C', 'Java', 'Python', 'C'}
print(langs)

执行结果

{'Python', 'C', 'Java'}

上述‘Python’和‘C’在设定时皆出现2次，但是列出时有重复的元素将只保留1份。集合内容可以是由不同数据类型组成，可参考下列实例。

程序实例ch10_3.py：使用整数和不同数据类型所建的集合。

# ch10_3.py
# 集合由整数所组成
integer_set = {1, 2, 3, 4, 5}
print(integer_set)
# 集合由不同数据型态所组成
mixed_set = {1, 'Python', (2, 5, 10)}
print(mixed_set)
# 集合的元素是不可变的所以程序第6行所设定的元组元素改成
# 第10行列表的写法将会产生错误
# mixed_set = { 1, 'Python', [2, 5, 10]}

执行结果

{1, 2, 3, 4, 5}
{'Python', 1, (2, 5, 10)}

读者可以将第10行的“#”删除，会发现程序有错误产生，原因是[2, 5, 10]是列表，这是可变的元素所以不可以当作集合元素。

读者可能会思考，字典是用大括号定义，集合也是用大括号定义，可否直接使用空的大括号定义空集合？可参考下列实例。

程序实例ch10_4.py：建立空集合并观察执行结果，发现错误的实例。

# ch10_4.py
x = {}                      # 这是建立空字典非空集合
print("打印     = ", x)
print("打印类别 = ", type(x))

执行结果

打印     =  {}
打印类别 =  <class 'dict'>

结果发现使用空的大括号{ }定义，获得的是空字典，下一小节笔者将会讲解定义空字典的方法。

10-1-2　使用set( )函数定义集合

除了以10-1-1节方式建立集合，也可以使用内置的set( )函数建立集合，set( )函数参数的内容可以是字符串(string)、列表(list)、元组(tuple)等。这时原先字符串(string)、列表(list)、元组(tuple)的元素将被转成集合元素。首先笔者回到建立空集合的主题，如果想建立空集合需使用set( )函数。

程序实例ch10_5.py：重新设计ch10_4.py，使用set( )函数建立空集合。

# ch10_5.py
empty_dict = {}                      # 这是建立空字典
print("打印类别 = ", type(empty_dict))
empty_set = set()                    # 这是建立空集合
print("打印类别 = ", type(empty_set))

执行结果

打印类别 =  <class 'dict'>
打印类别 =  <class 'set'>

程序实例ch10_6.py：使用字符串(string)建立与打印集合，同时列出集合的数据类型。

# ch10_6.py
x = set('DeepStone mean Deep Learning')
print(x)
print(type(x))

执行结果

{'t', 'L', 'i', 'o', 'n', 'm', 'e', ' ', 'g', 'r', 'D', 'a', 'p', 'S'}
<class 'set'>

由于集合元素具有唯一的特性，所以虽然程序第2行原先字符串有许多字母（例如，e）重复，经过set( )处理后，所有英文字母将没有重复。

程序实例ch10_7.py：使用列表(list)建立与打印集合。

# ch10_7.py
# 表达方式1
fruits = ['apple', 'orange', 'apple', 'banana', 'orange']
x = set(fruits)
print(x)
# 表达方式2
y = set(['apple', 'orange', 'apple', 'banana', 'orange'])
print(y)

执行结果

{'apple', 'orange', 'banana'}
{'apple', 'orange', 'banana'}

读者需留意2种不同的set( )函数使用方式，同时原先列表内容已经变为集合元素内容了。

程序实例ch10_8.py：使用元组(tuple)建立与打印集合。

# ch10_8.py
cities = set(('Beijing', 'Tokyo', 'Beijing', 'Taipei', 'Tokyo'))
print(cities)

执行结果

{'Tokyo', 'Taipei', 'Beijing'}

10-1-3　大数据与集合的应用

笔者的朋友在某知名企业工作，收集了海量数据使用列表保存，这里面有些数据重复出现，他曾经询问笔者应如何将重复的数据删除，笔者告知如果使用C语言可能需花几小时解决，但是如果了解Python的集合观念，只要花约1分钟就解决了。其实只要将列表数据使用set( )函数转为集合数据，再使用list( )函数将集合数据转为列表数据就可以了。

程序实例ch10_9.py：将列表内重复性的数据删除。

# ch10_9.py
fruits1 = ['apple', 'orange', 'apple', 'banana', 'orange']
x = set(fruits1)                # 将列表转成集合
fruits2 = list(x)               # 将集合转成列表
print("原先列表数据fruits1 = ", fruits1)
print("新的列表数据fruits2 = ", fruits2)

执行结果

原先列表数据fruits1 =  ['apple', 'orange', 'apple', 'banana', 'orange']
新的列表数据fruits2 =  ['banana', 'apple', 'orange']

10-2　集合的操作

10-2-1　交集(intersection)

有A和B两个集合，如果想获得相同的元素，则可以使用交集。例如，有数学(可想成A集合)与物理(可想成B集合)2个夏令营，如果想统计有哪些人同时参加这2个夏令营，则可以使用此功能。

在Python语言的交集符号是“&”，另外，也可以使用intersection( )方法完成这个工作。

程序实例ch10_10.py：有数学与物理2个夏令营，这个程序会列出同时参加这2个夏令营的成员。

# ch10_10.py 
math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
both = math & physics
print("同时参加数学与物理夏令营的成员 ",both)

执行结果

同时参加数学与物理夏令营的成员  {'Peter'}

程序实例ch10_11.py：使用intersection( )方法完成交集的应用。

# ch10_11.py
A = {1, 2, 3, 4, 5}         # 定义集合A
B = {3, 4, 5, 6, 7}         # 定义集合B
# 将intersection( )应用在A集合
AB = A.intersection(B)      # A和B的交集
print("A和B的交集是 ", AB)
# 将intersection( )应用在B集合
BA = B.intersection(A)      # B和A的交集
print("B和A的交集是 ", BA)

执行结果

A和B的交集是  {3, 4, 5}
B和A的交集是  {3, 4, 5}

10-2-2　并集(union)

有A和B两个集合，如果想获得所有的元素，则可以使用并集。例如，有数学(可想成A集合)与物理(可想成B集合)2个夏令营，如果想统计参加这2个夏令营的全部成员，则可以使用此功能。

在Python语言的并集符号是“|”，另外，也可以使用union( )方法完成这个工作。

程序实例ch10_12.py：有数学与物理2个夏令营，这个程序会列出参加这2个夏令营的所有成员。

# ch10_12.py 
math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
allmember = math | physics
print("同时参加数学与物理夏令营的成员 ",allmember)

执行结果

同时参加数学与物理夏令营的成员  {'Tom', 'Eric', 'Peter', 'Kevin', 'Nelson'}

程序实例ch10_13.py：使用union( )方法完成并集的应用。

# ch10_13.py
A = {1, 2, 3, 4, 5}             # 定义集合A
B = {3, 4, 5, 6, 7}             # 定义集合B
# 将union( )应用在A集合
AorB = A.union(B)               # A和B的联集
print("A和B的联集是 ", AorB)    
# 将union( )应用在B集合
BorA = B.union(A)               # B和A的联集
print("B和A的联集是 ", BorA)

执行结果

A和B的联集是  {1, 2, 3, 4, 5, 6, 7}
B和A的联集是  {1, 2, 3, 4, 5, 6, 7}

10-2-3　差集(difference)

有A和B两个集合，如果想获得属于A集合元素，同时不属于B集合则可以使用差集(A-B)。如果想获得属于B集合元素，同时不属于A集合则可以使用差集(B-A)。例如，有数学(可想成A集合)与物理(可想成B集合)2个夏令营，如果想了解参加数学夏令营但是没有参加物理夏令营的成员，则可以使用此功能。

如果想统计参加物理夏令营但是没有参加数学夏令营的成员，也可以使用此功能。

在Python语言的差集符号是“-”，另外，也可以使用difference( )方法完成这个工作。

程序实例ch10_14.py：有数学与物理2个夏令营，这个程序会列出参加数学夏令营但是没有参加物理夏令营的所有成员。另外也会列出参加物理夏令营但是没有参加数学夏令营的所有成员。

# ch10_14.py 
math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
math_only = math - physics
print("参加数学夏令营同时没有参加物理夏令营的成员 ",math_only)
physics_only = physics - math
print("参加数学夏令营同时没有参加物理夏令营的成员 ",physics_only)

执行结果

参加数学夏令营同时没有参加物理夏令营的成员  {'Eric', 'Kevin'}
参加数学夏令营同时没有参加物理夏令营的成员  {'Nelson', 'Tom'}

程序实例ch10_15.py：使用difference( )方法完成A-B差集与B-A差集的应用。

# ch10_15.py
A = {1, 2, 3, 4, 5}             # 定义集合A
B = {3, 4, 5, 6, 7}             # 定义集合B
# 将difference( )应用在A集合
A_B = A.difference(B)           # A-B的差集
print("A-B的差集是 ", A_B)    
# 将difference( )应用在B集合
B_A = B.difference(A)           # B-A的差集
print("B-A的差集是 ", B_A)

执行结果

A-B的差集是  {1, 2}
B-A的差集是  {6, 7}

10-2-4　对称差集(symmetric difference)

有A和B两个集合，如果想获得属于A或是B集合元素，但是排除同时属于A和B的元素，则可以使用对称差集。例如，有数学(可想成A集合)与物理(可想成B集合)2个夏令营，如果想统计参加数学夏令营或是参加物理夏令营的成员，但是排除同时参加这2个夏令营的成员，则可以使用此功能。更简单的解释是只参加一个夏令营的成员。

在Python语言的对称差集符号是“^”，另外，也可以使用symmetric_difference( )方法完成这个工作。

程序实例ch10_16.py：有数学与物理2个夏令营，这个程序会列出参加数学夏令营或参加物理夏令营，但是排除同时参加2个夏令营的所有成员。

# ch10_16.py 
math = {'Kevin', 'Peter', 'Eric'}       # 设定参加数学夏令营成员
physics = {'Peter', 'Nelson', 'Tom'}    # 设定参加物理夏令营成员
math_sydi_physics = math ^ physics
print("没有同时参加数学和物理夏令营的成员 ",math_sydi_physics)

执行结果

没有同时参加数学和物理夏令营的成员  {'Eric', 'Nelson', 'Tom', 'Kevin'}

程序实例ch10_17.py：使用symmetric_difference( )方法完成A和B与B和A对称差集的应用。

# ch10_17.py
A = {1, 2, 3, 4, 5}                     # 定义集合A
B = {3, 4, 5, 6, 7}                     # 定义集合B
# 将symmetric_difference( )应用在A集合
A_sydi_B = A.symmetric_difference(B)    # A和B的对称差集
print("A和B的对称差集是 ", A_sydi_B)    
# 将symmetric_difference( )应用在B集合
B_sydi_A = B.difference(A)              # B和A的对称差集
print("B和A的对称差集是 ", B_sydi_A)

执行结果

A和B的对称差集是  {1, 2, 6, 7}
B和A的对称差集是  {6, 7}

10-2-5　等于

等于的Python符号是“==”，可以得知2个集合是否相等，如果相等传回True，否则传回False。

程序实例ch10_18.py：测试2个集合是否相等。

# ch10_18.py
A = {1, 2, 3, 4, 5}                     # 定义集合A
B = {3, 4, 5, 6, 7}                     # 定义集合B
C = {1, 2, 3, 4, 5}                     # 定义集合C
# 列出A与B集合是否相等                              
print("A与B集合相等", A == B)
# 列出A与C集合是否相等                             
print("A与C集合相等", A == C)

执行结果

A与B集合相等 False
A与C集合相等 True

10-2-6　不等于

不等于的Python符号是“!=”，可以得知2个集合是否不相等，如果不相等传回True，否则传回False。

程序实例ch10_19.py：测试2个集合是否不相等。

# ch10_18.py
A = {1, 2, 3, 4, 5}                     # 定义集合A
B = {3, 4, 5, 6, 7}                     # 定义集合B
C = {1, 2, 3, 4, 5}                     # 定义集合C
# 列出A与B集合是否相等                              
print("A与B集合相等", A == B)
# 列出A与C集合是否相等                             
print("A与C集合相等", A == C)

执行结果

A与B集合相等 False
A与C集合相等 True

10-2-7　是成员in

Python的关键词in可以测试元素是否是集合的元素成员。

程序实例ch10_20.py：关键词in的应用。

# ch10_20.py
# 方法1
fruits = set("orange")
print("字符a是属于fruits集合?", 'a' in fruits)
print("字符d是属于fruits集合?", 'd' in fruits)
# 方法2
cars = {"Nissan", "Toyota", "Ford"}
boolean = "Ford" in cars
print("Ford in cars", boolean)
boolean = "Audi" in cars
print("Audi in cars", boolean)

执行结果

Ford in cars True
Audi in cars False

10-2-8　不是成员not in

Python的关键词not in可以测试元素是否不是集合的元素成员。

程序实例ch10_21.py：关键词notin的应用。

# ch10_21.py
# 方法1
fruits = set("orange")
print("字符a是不属于fruits集合?", 'a' not in fruits)
print("字符d是不属于fruits集合?", 'd' not in fruits)
# 方法2
cars = {"Nissan", "Toyota", "Ford"}
boolean = "Ford" not in cars
print("Ford not in cars", boolean)
boolean = "Audi" not in cars
print("Audi not in cars", boolean)

执行结果

Ford not in cars False
Audi not in cars True

10-3　适用集合的方法

10-3-1　add( )

add( )可以增加一个元素，它的语法格式如下：

 集合A.add(新增元素)

上述会将add( )参数的新增元素加到调用此方法的集合A内。

程序实例ch10_22.py：在集合内新增元素的应用。

# ch10_22.py
cities = { 'Taipei', 'Beijing', 'Tokyo'}
# 增加一般元素
cities.add('Chicago')
print('cities集合内容 ', cities)
# 增加已有元素并观察执行结果
cities.add('Beijing')
print('cities集合内容 ', cities)
# 增加元组元素并观察执行结果
tup = (1, 2, 3)
cities.add(tup)
print('cities集合内容 ', cities)

执行结果

cities集合内容  {'Taipei', 'Tokyo', 'Chicago', 'Beijing'}
cities集合内容  {'Taipei', 'Tokyo', 'Chicago', 'Beijing'}
cities集合内容  {'Taipei', 'Tokyo', (1, 2, 3), 'Chicago', 'Beijing'}

上述第7行，由于集合已经有‘Beijing’字符串，将不改变集合cities内容。另外，集合是无序的，你可能获得不同的排列结果。

10-3-2　copy( )

集合复制也会像6-8节的列表复制一样，有深复制(deep copy)与浅复制(shallow copy)，这个方法不需参数，语法格式如下：

新集合名称 = 旧集合名称.copy( )

copy( )是浅复制，经过复制后未来一个集合内容改变时，不会影响到另一个集合的内容。

程序实例ch10_23.py：浅复制与深复制的比较。

# ch10_23.py
# 深度拷贝deep copy
numset = {1, 2, 3}
deep_numset = numset
deep_numset.add(10)
print("深度拷贝 - 观察numset        ", numset)
print("深度拷贝 - 观察deep_numset   ", deep_numset)

# 浅拷贝shallow copy
shallow_numset = numset.copy( )
shallow_numset.add(100)
print("浅拷贝   - 观察numset        ", numset)
print("浅拷贝   - 观察shallow_numset", shallow_numset)

执行结果

深度拷贝 - 观察numset         {10, 1, 2, 3}
深度拷贝 - 观察deep_numset    {10, 1, 2, 3}
浅拷贝   - 观察numset         {10, 1, 2, 3}
浅拷贝   - 观察shallow_numset {1, 2, 3, 100, 10}

10-3-3　remove( )

如果指定删除的元素存在集合内，remove( )可以删除这个集合元素；如果指定删除的元素不存在集合内，将有KeyError产生。它的语法格式如下：

 集合A.remove(欲删除的元素)

上述会将集合A内remove( )参数指定的元素删除。

程序实例ch10_24.py：使用remove( )删除集合元素成功的应用。

# ch10_24.py
countries = {'Japan', 'China', 'France'}
print("删除前的countries集合 ", countries)
countries.remove('Japan')
print("删除后的countries集合 ", countries)

执行结果

删除前的countries集合  {'Japan', 'France', 'China'}
删除后的countries集合  {'France', 'China'}

程序实例ch10_25.py：使用remove( )删除集合元素失败的观察。

# ch10_25.py
animals = {'dog', 'cat', 'bird'}
print("删除前的animals集合 ", animals)
animals.remove('fish')        # 删除不存在的元素产生错误
print("删除后的animals集合 ", animals)

执行结果

删除前的animals集合  {'dog', 'cat', 'bird'}
Traceback (most recent call last):
  File "e:\桌面Desktop\Python王者归来\代码\ch10\ch10_25.py", line 4, in <module>
    animals.remove('fish')        # 删除不存在的元素产生错误
    ^^^^^^^^^^^^^^^^^^^^^^
KeyError: 'fish'

上述由于fish不存在于animals集合中，所以会产生错误。如果要避免这类错误，可以使用discard( )方法。

10-3-4　discard( )

discard( )可以删除集合的元素，如果元素不存在也不会有错误产生。

  ret_value = 集合A.discard(欲删除的元素)

上述会将集合A内，discard( )参数指定的元素删除。不论删除结果为何，这个方法会传回None，这个None在一些程序语言其实是称NULL，本书11-3节会介绍更多函数传回值与传回None的知识。

程序实例ch10_26.py：使用discard( )删除集合元素的应用。

# ch10_26.py
animals = {'dog', 'cat', 'bird'}
print("删除前的animals集合    ", animals)
# 欲删除元素有在集合内
animals.discard('cat')        
print("删除后的animals集合    ", animals)
# 欲删除元素没有在集合内 
animals.discard('pig')
print("删除后的animals集合    ", animals)
# 打印传回值
print("删除数据存在的传回值   ", animals.discard('dog'))
print("删除数据不存在的传回值 ", animals.discard('pig'))   

执行结果

删除前的animals集合     {'dog', 'bird', 'cat'}
删除后的animals集合     {'dog', 'bird'}
删除后的animals集合     {'dog', 'bird'}
删除数据存在的传回值    None
删除数据不存在的传回值  None

10-3-5　pop( )

pop( )是用随机方式删除集合元素，所删除的元素将被传回，如果集合是空集合则程序会产生TypeError错误。

  ret_element = 集合A.pop( )

上述会随机删除集合A内的元素，所删除的元素将被传回ret_element。

程序实例ch10_27.py：使用pop( )删除集合元素的应用。

# ch10_27.py
animals = {'dog', 'cat', 'bird'}
print("删除前的animals集合 ", animals)
ret_element = animals.pop( )        
print("删除后的animals集合 ", animals)
print("所删除的元素是      ", ret_element)

执行结果

删除前的animals集合  {'bird', 'cat', 'dog'}
删除后的animals集合  {'cat', 'dog'}
所删除的元素是       bird

10-3-6　clear( )

 clear( )可以删除集合内的所有元素，传回值是None。

程序实例ch10_28.py：使用clear( )删除集合所有元素的应用，这个程序会列出删除所有集合元素前后的集合内容，同时也列出删除空集合的结果。

# ch10_28.py
states = {'Mississippi', 'Idoho', 'Florida'}
print("删除前的states集合    ", states)
states.clear( )
print("删除前的states集合    ", states)

# 测试删除空集合
empty_set = set( )
print("删除前的empty_set集合 ", empty_set)
states.clear( )
print("删除前的empty_set集合 ", empty_set)

执行结果

删除前的states集合     {'Mississippi', 'Idoho', 'Florida'}
删除前的states集合     set()
删除前的empty_set集合  set()
删除前的empty_set集合  set()

10-3-7　isdisjoint( )

如果2个集合没有共同的元素会传回True，否则传回False。

 ret_boolean = 集合A.isdisjoint(集合B)

程序实例ch10_29.py：测试isdisjoint( )，下列是集合A、B和C的集合示意图。

# ch10_29.py
A = {'a', 'b', 'c'}
B = {'c', 'd', 'e'}
C = {'h', 'k', 'p'}
# 测试A和B集合
boolean = A.isdisjoint(B)       # 有共同的元素'c'
print("有共同的元素传回值是   ", boolean)

# 测试A和C集合
boolean = A.isdisjoint(C)       # 没有共同的元素
print("没有共同的元素传回值是 ", boolean)

执行结果

有共同的元素传回值是    False
没有共同的元素传回值是  True

10-3-8　issubset( )

这个方法可以测试一个函数是否是另一个函数的子集合，例如，A集合所有元素均可在B集合内发现，则A集合是B集合的子集合。如果是则传回True，否则传回False。

程序实例ch10_30.py：测试issubset( )，下列是A、B和C的集合示意图。

# ch10_30.py
A = {'a', 'b', 'c'}
B = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'k'}
C = {'k', 'm', 'n'}
# 测试A和B集合
boolean = A.issubset(B)         # 所有A的元素皆是B的元素
print("A集合是B集合的子集合传回值是 ", boolean)

# 测试C和B集合
boolean = C.issubset(B)         # 有共同的元素k
print("C集合是B集合的子集合传回值是 ", boolean)

执行结果

A集合是B集合的子集合传回值是  True
C集合是B集合的子集合传回值是  False

10-3-9　issuperset( )

这个方法可以测试一个函数是否是另一个函数的父集合，例如，B集合所有元素均可在A集合内发现，则A集合是B集合的父集合。如果是则传回True，否则传回False。

程序实例ch10_31.py：测试issuperset( )，下列是A、B和C的集合示意图。

# ch10_31.py
A = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'k'}
B = {'a', 'b', 'c'}
C = {'k', 'm', 'n'}
# 测试A和B集合
boolean = A.issuperset(B)           # 测试
print("A集合是B集合的父集合传回值是 ", boolean)

# 测试A和C集合
boolean = A.issuperset(C)           # 测试
print("A集合是C集合的父集合传回值是 ", boolean)

执行结果

A集合是B集合的父集合传回值是  True
A集合是C集合的父集合传回值是  False

10-3-10　intersection update( )

这个方法将传回集合的交集，它的语法格式如下：

 ret_value = A.intersection_update(*B)

上述B代表可以有1到多个集合，如果只有一个集合，例如是B，则执行后A将是A与B的交集。如果B代表(B, C)，则执行后A将是A、B与C的交集。

上述传回值是None，此值将设定给ret_value，接下来几个小节的方法皆会传回None，将不再叙述。

程序实例ch10_32.py：intersection_update( )的应用。

# ch10_32.py
A = {'a', 'b', 'c', 'd'}
B = {'a', 'k', 'c'}
C = {'c', 'f', 'w'}
# A将是A和B的交集
ret_value = A.intersection_update(B)
print(ret_value)
print("A集合 = ", A)
print("B集合 = ", B)

# A将是A, B和C的交集
ret_value = A.intersection_update(B, C)
print(ret_value)
print("A集合 = ", A)
print("B集合 = ", B)
print("C集合 = ", C)      

执行结果

A集合 =  {'a', 'c'}
B集合 =  {'k', 'a', 'c'}
None
A集合 =  {'c'}
B集合 =  {'k', 'a', 'c'}
C集合 =  {'w', 'f', 'c'}

10-3-11　update( )

可以将一个集合的元素加到调用此方法的集合内，它的语法格式如下：

  集合A.update(集合B)

上述是将集合B的元素加到集合A内。

程序实例ch10_33.py：update( )的应用。

# ch10_33.py
cars1 = {'Audi', 'Ford', 'Toyota'}
cars2 = {'Nissan', 'Toyota'}
print("执行update( )前列出cars1和cars2内容")
print("cars1 = ", cars1)
print("cars2 = ", cars2)
cars1.update(cars2)
print("执行update( )后列出cars1和cars2内容")
print("cars1 = ", cars1)
print("cars2 = ", cars2)

执行结果

执行update( )前列出cars1和cars2内容
cars1 =  {'Ford', 'Audi', 'Toyota'}
cars2 =  {'Nissan', 'Toyota'}
执行update( )后列出cars1和cars2内容
cars1 =  {'Ford', 'Nissan', 'Audi', 'Toyota'}
cars2 =  {'Nissan', 'Toyota'}

10-3-12　difference update( )

可以删除集合内与另一集合重复的元素，它的语法格式如下：

 集合A.difference_update(集合B)

上述是将集合A内与集合B重复的元素删除，结果存在A集合。

程序实例ch10_34.py：difference_update( )的应用，执行这个程序后，在集合A内与集合B重复的元素Toyota将被删除。

# ch10_34.py
cars1 = {'Audi', 'Ford', 'Toyota'}
cars2 = {'Nissan', 'Toyota'}
print("执行difference_update( )前列出cars1和cars2内容")
print("cars1 = ", cars1)
print("cars2 = ", cars2)
cars1.difference_update(cars2)
print("执行difference_update( )后列出cars1和cars2内容")
print("cars1 = ", cars1)
print("cars2 = ", cars2)

执行结果

执行difference_update( )前列出cars1和cars2内容
cars1 =  {'Ford', 'Audi', 'Toyota'}
cars2 =  {'Toyota', 'Nissan'}
执行difference_update( )后列出cars1和cars2内容
cars1 =  {'Ford', 'Audi'}
cars2 =  {'Toyota', 'Nissan'}

10-3-13　symmetric difference update( )

与10-2-4小节的对称差集观念一样，但是只更改调用此方法的集合。

  集合A.symmetric_difference_update(集合B)

程序实例ch10_35.py：symmetric_difference_update( )的基本应用。

# ch10_35.py
cars1 = {'Audi', 'Ford', 'Toyota'}
cars2 = {'Nissan', 'Toyota'}
print("执行symmetric_difference_update( )前列出cars1和cars2内容")
print("cars1 = ", cars1)
print("cars2 = ", cars2)
cars1.symmetric_difference_update(cars2)
print("执行symmetric_difference_update( )后列出cars1和cars2内容")
print("cars1 = ", cars1)
print("cars2 = ", cars2)

执行结果

执行symmetric_difference_update( )前列出cars1和cars2内容
cars1 =  {'Toyota', 'Ford', 'Audi'}
cars2 =  {'Toyota', 'Nissan'}
执行symmetric_difference_update( )后列出cars1和cars2内容
cars1 =  {'Ford', 'Audi', 'Nissan'}
cars2 =  {'Toyota', 'Nissan'}

10-4　适用集合的基本函数操作

10-4-1　max( )/min( )/sum( )

如果元素内容是数值，可以使用max( )列出最大值、min( )列出最小值和sum( )列出总合。如果元素内容是字符或字符串，可以使用max( )列出unicode码的最大值、min( )列出unicode码的最小值，sum( )则不可用在字符或字符串元素。

程序实例ch10_36.py：max( )、min( )和sum( )的基本应用。

# ch10_36.py
numList = {100, 99, 64, 101, 55}
chrList = {'a', 'x', 'R', 'z', 'b'}
# 数值所组成的集合运算
print("列出数值集合的最大值 = ", max(numList))
print("列出数值集合的最小值 = ", min(numList))
print("列出数值集合的总和   = ", sum(numList))

# 字符所组成的集合运算
print("列出字符集合的最大值 = ", max(chrList))
print("列出字符集合的最小值 = ", min(chrList))

执行结果

列出数值集合的最大值 =  101
列出数值集合的最小值 =  55
列出数值集合的总和   =  419
列出字符集合的最大值 =  z
列出字符集合的最小值 =  R

10-4-2　len( )

可以列出集合元素的数量。

程序实例ch10_37.py：列出不同元素组成集合的长度。

# ch10_37.py
# 集合由整数所组成
integer_set = {1, 2, 3, 4, 5}
# 集合由不同数据型态所组成
mixed_set = {1, 'Python', (2, 5, 10)}
print("interger_set长度 = ", len(integer_set))
print("mixed_set   长度 = ", len(mixed_set))

执行结果

interger_set长度 =  5
mixed_set   长度 =  3

10-4-3　sorted( )

6-5-3小节已经说明过sorted( )执行列表排序，我们可以将它应用在集合排序，将排序结果存在新列表对象，不过集合本身是不会更改的。
程序实例ch10_38.py：使用sorted( )将集合内容以排序方式传回。

# ch10_38.py
cars = {"Nissan", "Toyota", "Ford"}
carslist = sorted(cars)
carslist_reverse = sorted(cars,reverse = True)
print("由小到大排列 = ", carslist)
print("由大到小排列 = ", carslist_reverse)

执行结果

由小到大排列 =  ['Ford', 'Nissan', 'Toyota']
由大到小排列 =  ['Toyota', 'Nissan', 'Ford']

10-4-4　enumerate( )

可以传回连续整数配对的enumerate对象，在本书6-11节与7-4节对于enumerate对象已有做完整说明，本节将直接用实例说明应如何将enumerate对象应用在集合。
程序实例ch10_39.py：将集合转成enumerate对象并打印，然后再转成列表再打印，最后再将enumerate对象解析和打印。

# ch10_39.py
drinks = {"coffee", "tea", "wine"}
enumerate_drinks = enumerate(drinks)        # 数值初始是0
print(enumerate_drinks)                     # 传回enumerate对象所在内存
print("下列是输出enumerate对象类型")
print(type(enumerate_drinks))               # 列出对象类型
print("下列是转成列表输出")
print(list(enumerate_drinks))               # 转成列表再输出列表
print("下列是循环输出")
for item in enumerate(drinks):              # 循环输出
    print(item)

print("\n")
for count, item in enumerate(drinks):       # 将counter和元素内容分开输出
    print(count, item)

print("\n")
for count, item in enumerate(drinks, 10):   # 将counter起始值设为10输出
    print(count, item)

执行结果

<enumerate object at 0x000001B3CF76C900>
下列是输出enumerate对象类型
<class 'enumerate'>
下列是转成列表输出
[(0, 'coffee'), (1, 'wine'), (2, 'tea')]
下列是循环输出
(0, 'coffee')
(1, 'wine')
(2, 'tea')


0 coffee
1 wine
2 tea


10 coffee
11 wine
12 tea

10-5　冻结集合frozenset
set是可变集合，frozenset是不可变集合也可直译为冻结集合，这是一个新的类别(class)，只要设定元素后，这个冻结集合就不能再更改了。如果将元组(tuple)想成不可变列表(immutable list)，冻结集合就是不可变集合(immutable set)。
冻结集合的不可变特性优点是可以用它作字典的键(key)，也可以作为其他集合的元素。冻结集合的建立方式是使用frozenset( )函数，冻结集合建立完成后，不可使用add( )或remove( )更改冻结集合的内容。但是可以执行intersection( )、union( )、difference( )、symmetric_difference( )、copy( )、issubset( )、issuperset( )、isdisjoint( )等方法。
程序实例ch10_40.py：建立冻结集合与操作。

# ch10_40
X = frozenset([1, 3, 5])
Y = frozenset([5, 7, 9])
print(X)
print(Y)
print("交集  = ", X & Y)
print("联集  = ", X | Y)
A = X & Y
print("交集A = ", A)
A = X.intersection(Y)
print("交集A = ", A)

执行结果

frozenset({1, 3, 5})
frozenset({9, 5, 7})
交集  =  frozenset({5})
联集  =  frozenset({1, 3, 5, 7, 9})
交集A =  frozenset({5})
交集A =  frozenset({5})