Python数据类型

数据类型是一个值的集合以及定义在这个值集上的一组操作。变量有名字和数据类型两种属性。数据类型决定了如何将代表这些值的位存储到计算机的内存中，以及可以对这些值进行的操作。

Python的数据类型包括简单数据类型、列表、元组、字典和集合。简单数据类型就是数和字符串。

2.2.1 简单数据类型转换

Python在定义变量时，不需要指定其数据类型，而是根据每次给变量所赋的值决定其数据类型。但也可以使用一组函数对常量和变量进行类型转换，以便对它们进行相应的操作。

1. 转换为数字

可以将字符串常量或变量转换为数字，包括如下的情形。

（1）使用int()函数将字符串转换为整数，语法如下：

int(x [,base ])

参数x是待转换的字符串，参数base为可选参数，指定转换后整数的进制，默认为10进制。

（2）使用long()函数将字符串转换为长整数，语法如下：

llong(x [,base ])

参数的含义与int()函数相同。

（3）使用float()函数将字符串或数字转换为浮点数，语法如下：

float (x)

参数x是待转换的字符串或数字。

（4）使用eval ()函数计算字符串中的有效Python表达式并返回结果，语法如下：

eval(str)

参数str是待计算的Python表达式字符串。

【例2-9】 下面是一个类型转换的例子。

a = "1"; 
b = int(a)+1; 
print(b);

变量a被赋值”1″，此时它是字符串变量。然后使用int()函数将变量转换为整数并加上1再赋值给变量b。最后使用print ()函数输出变量b。运行结果为2。

【例2-10】 使用eval ()函数的例子。

a = "1+2"; 
print(eval(a));

运行结果为3。

2. 转换为字符串

可以将数字常量或变量转换为字符串，包括如下的情形。

（1）使用str ()函数将数值转换为字符串，语法如下：

str(x)

参数x是待转换的数值。

（2）使用repr ()函数将对象转换为可打印字符串，语法如下：

repr(obj)

参数obj是待转换的对象。

（3）使用chr ()函数将一个整数转换为可对应ASCII码的字符，语法如下：

chr(整数)

（4）使用ord()函数将一个字符转换为对应的ASCII码，语法如下：

ord(字符)

【例2-11】 使用chr ()函数和ord()函数的例子。

print(chr(65)); 
print(ord('A'));

运行结果为：

A 
65

（5）使用hex()函数将一个整数转换为一个十六进制字符串，语法如下：

hex(整数)

（6）使用oct()函数将一个整数转换为一个八进制字符串，语法如下：

oct(整数)

【例2-12】 使用hex()函数和oct()函数打印8的十六进制字符串和八进制字符串。

print(hex(8)); 
print(oct(8));

输出的结果如下：

0x8 
0o10

十六进制字符串以0x开头，八进制字符串以0o开头。

2.2.2 列表

列表（List）是一组有序存储的数据。例如，饭店点餐的菜单就是一种列表。列表具有如下特性：

• 和变量一样，每个列表都有唯一标识它的名称。

• 一个列表的元素应具有相同的数据类型。

• 每个列表元素都有索引和值两个属性，索引是一个从0开始的整数，用于标识元素在列表中的位置；值当然就是元素对应的值。

1. 定义列表

下面就是一个列表的定义。

languagelist = [‘C++’, ‘C#’, ‘Java’, ‘Python’]

2. 打印列表

可以直接使用print()函数打印列表，方法如下：

print(列表名)
【例2-13】 打印列表的内容。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
print(languagelist)

运行结果如下：

['C++', 'C#', 'Java', 'Python']

3. 获取列表长度

列表长度指列表中元素的数量。可以通过len()函数获取列表的长度，方法如下：

len(数组名)

4. 访问列表元素

列表由列表元素组成。对列表的管理就是对列表元素的访问和操作。可以通过下面的方法获取列表元素的值：

列表名[index]
index是元素索引，第1个元素的索引是0，最后一个元素的索引是列表长度−1。

【例2-14】 访问列表元素的例子。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
print(languagelist [0]) 
print(languagelist [3])

程序打印列表中索引为0和3的元素，运行结果如下：

C++ 
Python

5. 添加列表元素

可以通过append()函数在列表尾部添加元素，具体方法如下：

列表.append(新值)
【例2-15】 通过append()函数添加列表元素的例子。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
languagelist.append('javascript') 
print(languagelist)

程序调用append()函数在列表menulist的尾部添加元素’ javascript ‘，运行结果如下：

['C++', 'C#', 'Java', 'Python', 'javascript']

还可以通过insert()函数在列表的指定位置插入一个元素，具体方法如下：

列表. insert(插入位置, 新值)
【例2-16】 通过insert()函数添加列表元素的例子。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
languagelist.insert(1, ' javascript') 
print(languagelist)

程序调用insert()函数在列表languagelist索引为1的位置插入元素’ javascript ‘，运行结果如下：

['C++', 'javascript', 'C#', 'Java', 'Python']

还可以通过extend()函数将一个列表中的每个元素分别添加到另一个列表中，具体方法如下：

列表1.extend(列表2)
【例2-17】 通过extend()函数添加列表元素的例子。

languagelist1 = ['javascript', 'Java'] 
languagelist2 = ['C++', 'C#'] 
languagelist1.extend(languagelist2) 
print(languagelist1)

程序调用extend()函数将列表languagelist2中的每个元素分别添加到列表languagelist1，运行结果如下：

['javascript', 'Java', 'C++', 'C#']

6. 合并两个列表

可以使用+将两个列表合并，得到一个新的列表，具体方法如下：

列表3=列表1 + 列表2
【例2-18】 合并2个列表的例子。

languagelist1 = ['javascript', 'Java', 'Python'] 
languagelist2 = ['C++', 'C#', 'Python'] 
languagelist3 = languagelist1 + languagelist2 
print(languagelist3)

运行结果如下：

['javascript', 'Java', 'Python', 'C++', 'C#', 'Python']

可以看到，使用操作符“+”合并两个列表后重复的元素同时出现在新列表中。

7. 删除列表元素

使用del语句可以删除指定的列表元素，具体方法如下：

del 列表名[索引]
【例2-19】 使用del语句删除列表元素的例子。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
del languagelist[0] 
print(languagelist)

运行结果如下：

['C#', 'Java', 'Python']

可以看到，列表中的第一个元素已经被删除。

8. 定位列表元素

可以使用index()函数获取列表中某个元素的索引。其基本语法如下：

列表.index(元素值)
函数返回元素值在列表中某个元素的索引，如果不存在，则会报异常。

【例2-20】 使用index ()函数的例子。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
print(languagelist.index('Java')) 
print(languagelist.index(' Python '))

运行结果如下：

0 
2

9. 遍历列表元素

遍历列表就是一个一个地访问列表元素，这是使用列表时的常用操作。

可以使用for语句和range()函数遍历列表索引，然后通过索引依次访问每个列表元素，方法如下：

for i in range(len(list)):
访问list[i]
【例2-21】 for语句和range()函数遍历列表。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
for i in range(len(languagelist)): 
print(languagelist[i]);

程序的运行结果如下：

C++ 
C# 
Java 
Python

也可以使用for语句和enumerate()函数同时遍历列表的元素索引和元素值，方法如下：

for索引, 元素值in enumerate(list):
访问索引和元素值
【例2-22】 for语句和enumerate()函数遍历列表。

languagelist = ['C++', 'C#', 'Java', 'Python'] 
for index,value in enumerate(languagelist): 
print("第%d个元素值是【%s】" %(index, value));

程序的运行结果如下：

第0个元素值是【C++】 
第1个元素值是【C#】 
第2个元素值是【Java】 
第3个元素值是【Python】

10. 列表排序

列表排序操作值按列表元素值的升序、降序或反序重新排列列表元素的位置。

可以使用sort()函数对列表进行升序排列，其语法如下：

列表.sort()
调用sort()函数后，列表被排序。

【例2-23】 使用sort()函数对列表进行升序排列。

list = ['banana', 'apple', 'pear', 'grape']; 
list.sort() 
print(list)

程序的运行结果如下：

['apple', 'banana', 'grape', 'pear']

可以使用reverse()函数对列表进行反序排列，其语法如下：

列表.reverse()
调用reverse ()函数后，列表元素被反序排列。

【例2-24】 使用reverse ()函数对列表进行反序排列。

list = ['apple', 'Banana', 'pear', 'grape']; 
list.reverse() 
print(list)

程序的运行结果如下：

['grape', 'pear', 'Banana', 'apple']

如果希望对列表元素进行降序排列，则可以先使用sort()函数进行升序排列，然后调用reverse()函数对列表进行反序排列。

【例2-25】 对列表进行反序排列。

list = ['apple', 'banana', 'pear', 'grape']; 
list.sort() 
list.reverse() 
print(list)

程序的运行结果如下：

['pear', 'grape', 'banana', 'apple']

11. 产生一个数值递增列表

使用range()函数可以产生一个数值递增列表，它的基本语法结构如下：

range(start, end)
参数说明如下。

start：一个整数，指定产生的列表的起始元素值。为可选参数，默认值为0。

end：一个整数，指定产生的列表的结束元素值。

range()函数返回一个列表，该列表由从start开始至end结束的整数组成。

【例2-26】 使用range()函数产生一个数值递增列表的应用实例。

list1 = range(10) 
list2 = range(11, 20) 
#打印list1 
for index,value in enumerate(list1): 
print("list1 的第%d个元素值是【%s】" %(index, value)); 
#打印list2 
for index,value in enumerate(list2): 
print("list2 的第%d个元素值是【%s】" %(index, value));

程序的运行结果如下：

list1的第0个元素值是【0】 
list1的第1个元素值是【1】 
list1的第2个元素值是【2】 
list1的第3个元素值是【3】 
list1的第4个元素值是【4】 
list1的第5个元素值是【5】 
list1的第6个元素值是【6】 
list1的第7个元素值是【7】 
list1的第8个元素值是【8】 
list1的第9个元素值是【9】 
list2的第0个元素值是【11】 
list2的第1个元素值是【12】 
list2的第2个元素值是【13】 
list2的第3个元素值是【14】 
list2的第4个元素值是【15】 
list2的第5个元素值是【16】 
list2的第6个元素值是【17】 
list2的第7个元素值是【18】 
list2的第8个元素值是【19】

12. 定义多维列表

可以将多维列表视为列表的嵌套，即多维列表的元素值也是一个列表，只是维度比其父列表小一。二维列表的元素值是一维列表，三维列表的元素值是二维列表，以此类推。

【例2-27】 一个定义二维数列表的例子。

list2 = [[“CPU”, “内存”], [“硬盘”,”声卡”]];
此时列表list2的内容如图2-3所示。

图2-3 例2-27中列表list2的内容

【例2-28】 打印二维列表。

list2 = [["CPU", "Memory"], ["Harddisk"," Sound Card"]]; 
for i in range(len(list2)): 
print(list2[i]);

运行结果如下：

['CPU', 'Memory'] 
['Harddisk', ' Sound Card']

【例2-29】 也可以使用嵌套for语句打印二维列表的每一个元素，代码如下：

list2 = [["CPU", "Memory"], ["Harddisk"," Sound Card"]]; 
for i in range(len(list2)): 
list1 = list2[i]; 
for j in range(len(list1)): 
print(list1[j])

运行结果如下：

CPU 
Memory 
Harddisk 
Sound Card

二维列表比一维列表多一个索引，可以使用下面的方法获取二维列表元素的值：

列表名[索引1] [索引2]
【例2-30】 使用嵌套2个索引访问二维列表的每一个元素，代码如下：

list2 = [["CPU", "Memory"], ["Harddisk"," Sound Card"]]; 
for i in range(len(list2)): 
for j in range(len(list2[i])): 
print(list2[i][j])

运行结果与例2-29相同。

2.2.3 元组

元组（Tuple）与列表非常相似，它具有以下特性：

（1）一经定义，元组的内容不能改变。

（2）元组元素可以存储不同类型的数据，可以是字符串、数字，甚至是元组。

（3）元组元素由圆括号括起来，例如：

t = (1, 2, 3, 4)

1. 访问元组元素

与列表一样，可以使用索引访问元组元素，方法如下：

元组[索引]
【例2-31】 访问元组元素的例子。

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

程序打印元组中索引为0和3的元素，运行结果如下：

1 
4

2. 获取元组长度

元组长度指元组中元素的数量。可以通过len()函数获取元组的长度，方法如下：

len(元组名)
【例2-32】 打印元组的长度。

t = (1, 2, 3, 4) 
print(len(t))

运行结果为:

4

3. 遍历元组元素

与列表一样，可以使用for语句和range()函数遍历列表索引，然后通过索引依次访问每个元组元素，方法如下：

for i in range(len(tuple)):
访问tuple [i]
【例2-33】 for语句和range()函数遍历列表。

t = ('C++', 'C#', 'Java', 'Python'); 
for i in range(len(t)): 
print(t[i]);

程序的运行结果如下：

C++ 
C# 
Java 
Python

也可以使用for语句和enumerate()函数同时遍历列表的元素索引和元素值，方法如下：

for索引, 元素值in enumerate(list):
访问索引和元素值
【例2-34】 for语句和enumerate()函数遍历元组。

t = ('C++', 'C#', 'Java', 'Python'); 
for index,value in enumerate(list): 
print("第%d个元素值是【%s】" %(index, value));

程序的运行结果如下：

第0个元素值是【C++】 
第1个元素值是【C#】 
第2个元素值是【Java】 
第3个元素值是【Python】

4. 排序

因为元组的内容不能改变，所以元组没有sort()函数。可以将元组转换为列表，然后再对列表进行排序，最后将排序后的列表赋值给元组。

可以使用下面的方法将元组转换为列表。

列表对象 = list(元组对象)
将列表转换为元组的方法如下：

元组对象 = tuple(列表对象)
【例2-35】 对元组进行排列。

t = ('C++', 'C#', 'Java', 'Python'); 
l = list(t); 
l.sort(); 
t = tuple(l); 
print(t)

程序的运行结果如下：

('C#', 'C++', 'Java', 'Python')

可以使用reverse()函数对元组进行反序排列，其语法如下：

元组.reverse()
调用reverse ()函数后，元组元素被反序排列。

【例2-36】 使用reverse ()函数对元组进行反序排列。

t = ('C#', 'C++', 'Java', 'Python'); 
l = list(t); 
l.reverse() 
t = tuple(l); 
print(t)

2.2.4 字典

字典也是在内存中保存一组数据的数据结构，与列表不同的是：每个字典元素都有键（Key）和值（Value）两个属性。键用于定义和标识字典元素，键可以是一个字符串，也可以是一个整数；值就是字典元素对应的值。因此，字典元素就是一个“键/值对”。

图2-4是字典的示意图。灰色方块中是数组元素的键，白色方块中是数组元素的值。

图2-4 字典的示意图

1. 定义字典

字典元素使用｛｝括起来，例如，下面的语句可以定义一个空字典。

d1 = ｛｝;

也可以在定义字典时指定里面的元素，每个元素由键和值组成，键和值之间用冒号（：）分隔，元素间用逗号（，）分隔。例如：

d2=｛’name’:’小明’, ‘sex’:’男’,’age’:’18’, ‘score’:’80’｝

2. 打印字典

可以直接使用print()函数打印字典，方法如下：

print(字典名)

【例2-37】 打印字典的内容。

d=｛'name':'Johney', 'sex':'Male','age':'18', 'score':'80'｝ 
print(d)

运行结果如下：

｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝

3. 获取字典长度

字典长度指字典中元素的数量。可以通过len()函数获取字典的长度，方法如下：

len(字典名)

【例2-38】 打印字典的长度。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
print(len(d))

运行结果为:

4

4. 访问字典元素

字典由字典元素组成。对字典的管理就是对字典元素的访问和操作。可以通过下面的方法获取字典元素的值：

字典名[key]

key是元素的键。

【例2-39】 访问字典元素的例子。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
print(d['name']) 
print(d['sex']) 
print(d['age']) 
print(d['score'])

程序打印字典中各键的元素值，运行结果如下：

5. 添加字典元素

可以通过赋值在字典中添加元素，具体方法如下：

字典[键] = 值

如果字典中不存在指定键，则添加；否则修改键值。

【例2-40】 添加字典元素的例子。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
d['score'] = '100' 
print(d)

运行结果如下：

｛'age': '18', 'score': '100', 'name': 'Johney', 'sex': 'Male'｝

6. 合并两个字典

可以使用update()函数将两个字典合并，具体方法如下：

字典1.update(字典2)

【例2-41】 合并两个字典的例子。

d1=｛'name': 'Johney', 'sex': 'Male'｝ 
d2=｛'age':'18', 'score': '80'｝ 
d1.update(d2) 
print(d1)

运行结果如下：

｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝

可以看到，d2的元素被合并到d1中。

7. 删除字典元素

使用pop()方法可以删除指定的字典元素，并返回删除的元素值。具体方法如下：

字典名.pop(键)

【例2-42】 使用pop()方法删除字典元素的例子。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
d.pop('score') 
print(d)

运行结果如下：

｛'age': '18', 'name': 'Johney', 'sex': 'Male'｝

可以看到，字典中键为’score’的元素已经被删除。

8. 判断字典是否存在元素

可以使用in关键字判断字典中是否存在指定键的元素。其基本语法如下：

键in字典

如果字典中存在指定键的元素，则表达式返回True；否则返回False。

【例2-43】 使用in关键字的例子。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
if 'name1' in d: 
print(d['name1']) 
else: 
print('不包含键位name1的元素')

运行结果如下：

不包含键位name1的元素

9. 遍历字典元素

可以使用for…in语句遍历字典的键和值，方法如下：

for key in字典.keys(): # 遍历字典的键
访问 字典[key]
for key in 字典.values(): # 遍历字典的值
访问 字典[key]

【例2-44】 使用for…in语句遍历字典的键。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
for key in d.keys(): # 遍历字典的键 
print('键'+key+ '的值：'+ d[key]);

程序的运行结果如下：

键age的值：18 
键score的值：80 
键name的值：Johney 
键sex的值：Male

【例2-45】 使用for…in语句遍历字典的值。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
for value in d.values(): # 遍历字典的值 
print(value);

程序的运行结果如下：

18 
80 
Johney 
Male

10. 清空字典

使用clear()方法可以清空指定的字典所有元素。具体方法如下：

字典名.clear()

【例2-46】 使用clear ()方法清空字典元素的例子。

d = ｛'age': '18', 'score': '80', 'name': 'Johney', 'sex': 'Male'｝ 
d. clear() 
print(d)

运行结果如下：

｛｝

可以看到，字典已经被清空。

11. 字典的嵌套

字典里面还可以嵌套字典，例如：

｛’name’:｛’first’:’Johney’,’last’:’Lee’｝,’age’:40｝

可以通过下面的方式访问嵌套字典。

字典[键][键]

【例2-47】 使用嵌套字典的例子。

d=｛'name':｛'first':'Johney','last':'Lee'｝,'age':40｝ 
print(d['name'][ 'first'])

运行结果如下：

Johney

2.2.5 集合

集合由一组无序排列的元素组成，可以分为可变集合（set）和不可变集合（frozenset）。可变集合创建后可以添加、修改和删除元素，而不可变集合创建后则不能改变。

1. 创建集合

可以使用set()方法创建可变集合，例如：

s = set(‘python’)

【例2-48】 创建可变集合的例子。

s = set('python') 
print(type(s)) 
print(s)

运行结果如下：

<type 'set'> 
set(['h', 'o', 'n', 'p', 't', 'y'])

可以看到生成的集合s的类型是类set，s中元素是无序的。

可以使用frozenset ()方法创建不可变集合，例如：

s = frozenset(‘python’)

【例2-49】 创建不可变集合的例子。

fs = frozenset('python') 
print(type(fs)) 
print(fs)

运行结果如下：

<class 'frozenset'> 
frozenset(｛'n', 'y', 'h', 'o', 'p', 't'｝)

可以看到生成的集合fs的类型是类frozenset，fs中元素是无序的。

2. 获取集合长度

集合长度指集合中元素的数量。可以通过len()函数获取集合的长度，方法如下：

len(集合名)

【例2-50】 打印集合的长度。

s = set('python') 
print(len(s))

运行结果为：

6

3. 访问集合元素

由于集合本身是无序的，所以不能为集合创建索引或切片操作，只能循环遍历集合元素。

【例2-51】 遍历集合元素的例子。

s = set('python') 
for e in s: 
print(e)

运行结果如下：

n 
o 
t 
y 
h 
p

4. 添加集合元素

可以通过调用add()方法在集合中添加元素，具体方法如下：

集合.add(值)
注意
只能在可变集合中添加元素，不能在不可变集合中添加元素。

【例2-52】 添加一个集合元素的例子。

s = set('python') 
s.add('0') 
print(s)

运行结果如下：

｛'t', 'y', 'h', 'p', 'o', '0', 'n'｝

可以看到，’0’出现在集合s中。
也可以使用update()方法将另外一个集合的元素添加到指定集合中，具体方法如下：

集合. update(值)

【例2-53】 添加多个集合元素的例子。

s = set([1, 2, 3]) 
s.update([4, 5, 6]) 
print(s)

运行结果如下：

｛1, 2, 3, 4, 5, 6｝

5. 删除集合元素

可以使用remove()方法删除指定的集合元素，具体方法如下：

集合名. remove(值)

使用clear()方法可以清空指定的集合所有元素，具体方法如下：

集合名.clear()

【例2-54】 删除集合元素的例子。

s = set([1, 2, 3]) 
s.remove(1) 
print(s) 
s.clear() 
print(s)

运行结果如下：

｛2 ,3｝ 
set()

可以看到，用remove()方法删除了元素1，调用clear()方法后集合被清空。

6. 判断集合是否存在元素

可以使用in判断集合中是否存在指定键的元素。其基本语法如下：

值in集合

如果集合中存在指定值的元素，则表达式返回True；否则返回False。

【例2-55】 判断集合是否存在元素的例子。

s = set([1, 2, 3]) 
if 2 in s: 
print('exist') 
else: 
print('not exist')

运行结果如下：

exist

7. 遍历集合元素

可以使用for… in语句遍历集合的值，方法如下：

for element in集合:
访问element

【例2-56】 使用for… in语句遍历集合。

s = set([1, 2, 3]) 
for e in s: # 遍历集合 
print(e);

程序的运行结果如下：

1 
2 
3

8. 子集和超集

有两个集合A与B，如果集合A的任何一个元素都是集合B的元素，就说集合A包含于集合B，或集合B包含集合A，也可以说集合A是集合B的子集。如果集合A的任何一个元素都是集合B的元素，而集合B中至少有一个元素不属于集合A，则称集合A是集合B的真子集。空集是任何集合的子集。任何一个集合是它本身的子集，空集是任何非空集合的真子集。

如果集合A是集合B的子集，则称集合B是集合A的超集。

可以使用表2-2所示的操作符判断两个集合的关系。

表2-2 判断两个集合关系的操作符

【例2-57】 判断两个集合关系。

s1 = set([1, 2]) 
s2 = set([1, 2, 3]) 
if s1!=s2: 
if s1<s2: 
print('s1 是s2的真子集'.decode('utf-8').encode('gbk')) 
if s2>s1: 
print('s2 是s1的超集'.decode('utf-8').encode('gbk'))

运行结果如下：

s1是s2的真子集 
s2是s1的超集

9. 集合的并集

集合的并集由所有属于集合A或集合B的元素组成。

可以使用|操作符计算两个集合的并集。例如：

s = s1 | s2

【例2-58】 使用|操作符计算两个集合的并集。

s1 = set([1, 2]) 
s2 = set([3, 4]) 
s = s1 | s2 
print(s)

运行结果如下：

｛1, 2, 3, 4｝

也可以使用union()方法计算两个集合的并集。例如：

s = s1.union(s2)

【例2-59】 使用union()方法计算两个集合的并集。

s1 = set([1, 2]) 
s2 = set([3, 4]) 
s = s1.union(s2) 
print(s)

运行结果如下：

｛1, 2, 3, 4｝

10. 集合的交集

集合的交集由所有既属于集合A又属于集合B的元素组成。

可以使用&操作符计算两个集合的交集。例如：

s = s1 & s2

【例2-60】 使用&操作符计算两个集合的交集。

s1 = set([1, 2, 3]) 
s2 = set([3, 4]) 
s = s1 & s2 
print(s)

运行结果如下：

｛3｝

也可以使用intersection ()方法计算两个集合的交集。例如：

s = s1. intersection (s2)

【例2-61】 使用intersection()方法计算两个集合的交集。

s1 = set([1, 2, 3]) 
s2 = set([3, 4]) 
s = s1.intersection(s2) 
print(s)

11. 集合的差集

集合的差集由所有属于集合A但不属于集合B的元素组成。

可以使用−操作符计算两个集合的差集。例如：

s = s1 – s2

【例2-62】 使用−操作符计算两个集合的差集。

s1 = set([1, 2, 3]) 
s2 = set([3, 4]) 
s = s1 - s2 
print(s)

运行结果如下：

｛1, 2｝

也可以使用difference ()方法计算两个集合的差集。例如：

s = s1. difference(s2)

【例2-63】 使用difference()方法计算两个集合的差集。

s1 = set([1, 2, 3]) 
s2 = set([3, 4]) 
s = s1. difference(s2) 
print(s)

12. 集合的对称差分

集合的对称差分由所有属于集合A和集合B，并且不同时属于集合A和集合B的元素组成。

可以使用^操作符计算两个集合的对称差分。例如：

s = s1 ^ s2

【例2-64】 使用^操作符计算两个集合的对称差分。

s1 = set([1, 2, 3]) 
s2 = set([3, 4]) 
s = s1 ^ s2 
print(s)

运行结果如下：

｛1, 2, 4｝

也可以使用symmetric_difference ()方法计算两个集合的对称差分。例如：

s = s1. symmetric_difference (s2)

【例2-65】 使用symmetric_difference()方法计算两个集合的对称差分。

s1 = set([1, 2, 3])
s2 = set([3, 4])
s = s1.symmetric_difference(s2)
print(s)