Python基础（中）

最近这几天一边学习其他知识，一边又把Python的基础知识接着整理了一下，这次主要就是整理了Python中比较重要的几个数据结构，分别是列表、字典、元组和集合，作者认为这几块是比较容易让人产生困惑的，以及可能在后续的学习中会弄混淆，所以特别抽出来写一篇Python（中），后续还会接着整理最后下部分的基础知识。

11. 列表

11.1 为什么需要列表

  • 变量可以存储一个元素，但是列表是一个“大容器”，可以存储N多个元素，程序可以方便地对这些数据进行整体操作
  • 列表相当于其它语言中的数组

11.2 列表的创建

  • 列表需要使用中括号[]，元素之间使用英文的逗号进行分割

  • lst = ['大圣', '孙悟空']

  • 列表的创建方式

    • 直接使用中括号 lst = ['大圣', '孙悟空']
    • 调用内置函数list() lst2 = list(['大圣', '孙悟空'])

11.3 列表的特点

  1. 列表元素按照顺序有序排序
  2. 索引映射唯一一个数据
  3. 列表可以存储重复数据
  4. 列表可以任意数据类型混存
  5. 根据需要动态分配和回收内存

11.4 列表的查询操作

  1. 获取列表中指定元素的索引index()
  • 如查列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
  • 如果查询的元素在列表中不存在，则会抛出ValueError
  • 还可以在指定的start和stop之间进行查找

下面用一个简单的代码例子来说明index()方法查询的三个特点

1
2
3
4
lst = ['hello', 'world', 985, 'hello']
print(lst.index('hello'))  # 如查列表中有相同元素，只返回相同元素中的第一个元素的索引
print(lst.index('python'))  # 如果不存在，则会抛出异常.ValueError: 'python' is not in list
print(lst.index('hello', 1, 3))  # 索引从1到3，但是不包括3.ValueError: 'hello' is not in list
  1. 获取列表中的单个元素
  • 正向索引从0到N-1 举例：lst[0]
  • 逆向索引从-N到-1 举例：lst[-N]
  • 指定索引不存在时，会抛出indexError

下面用一个简单的代码例子来说明获取单个元素的方法查询三个特点

1
2
3
4
5
6
7
lst = ['hello', 'world', 985, 'hello', 'world', 211]
# 获取索引为2的元素
print(lst[2])   # 985
# 获取索引为-3的元素
print(lst[-3])  # hello
# 获取索引为10的元素
print(lst[10])  # 报错提示列表超出范围，查询不到。IndexError: list index out of range
  1. 获取列表中的多个元素

语法格式：列表名[start : stop : step]

  • 切片的结果：原列表片段的拷贝
  • 切片的范围：[start, stop]
  • step默认为1：可以简写为[start: stop]
  • step为正数的时候
    • [: stop: step]：切片的第一个元素默认是列表中的第一个元素
    • [start: :step]：切片的最后一个元素默认是列表的最后一个元素
  • step为负数的时候
    • [: stop: step]：切片的第一个元素默认是列表中的最后一个元素
    • [start: :step]：切片的最后一个元素默认是列表的第一个元素

下面通过一个例子解释一下，如何获取列表中的多个元素，以及它们的不同形式写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
lst = [10, 20, 30, 40, 50, 60, 70, 80]
# start=1,stop=6,step=1
print(lst[1:6:1])   # [20, 30, 40, 50, 60]
print('原列表', id(lst))   # 原列表 2125077867328
lst2 = lst[1:6:1]
print('切的片段', id(lst2)) # 切的片段 2125077761664
# 默认步长为1    后面加一个冒号，step不填也默认步长为1
print(lst[1:6])     # [20, 30, 40, 50, 60]
print(lst[1:6:])    # [20, 30, 40, 50, 60]
# start=1，stop=6，step=2
print(lst[1:6:2])   # [20, 40, 60]
# stop=6,step=2,start采用默认
print(lst[:6:2])    # [10, 30, 50]
# start=1，step=2，stop采用默认
print(lst[1::2])    # [20, 40, 60, 80]
print('-------------------step步长为负数的情况-----------------------')
print(lst[::-1])    # [80, 70, 60, 50, 40, 30, 20, 10]
# start=7,stop省略，step=-1
print(lst[7::-1])   # [80, 70, 60, 50, 40, 30, 20, 10]
# start=6，stop=0，step=-1
print(lst[6:0:-2])  # [70, 50, 30]
  1. 判断指定元素在列表中是否存在
  • 元素 in 列表名
  • 元素 not in 列表名

下面是一个例子说明如何判断指定元素是否在列表中存在

1
2
3
4
5
lst = [10, 20, 'python', 'hello']
print(10 in lst)    # True
print(100 in lst)   # False
print(10 not in lst)    # False
print(100 not in lst)   # True
  1. 列表元素的遍历

for 迭代变量 in 列表名 ：

下面是一个例子说明如何操作对列表元素的遍历

1
2
3
4
5
6
7
8
9
10
11
lst = [10, 20, 'python', 'hello']
for item in lst:
    print(item)

    #输出结果
"""
10
20
python
hello
"""

11.5 列表的增加操作

列表元素的增加操作

方法/其它 操作描述
append() 在列表的末尾添加一个元素
extend() 在列表的末尾添加至少一个元素
insert() 在列表的任意位置添加一个元素
切片 在列表的任意位置添加至少一个元素

下面用一个代码例子来说明上面四种添加方法的不同之处

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
lst = [10, 20, 30]
# 向列表的末尾添加一个元素

lst2 = ['hello', 'world']
# lst.append(lst2)    # 将lst2作为一个元素添加到列表的末尾
print(lst)  # [10, 20, 30, 100, ['hello', 'world']]
lst.extend(lst2)    # 将lst2里面的各个元素作为单独元素添加到列表的末尾
print(lst)  # [10, 20, 30, 100, 'hello', 'world']
# 在任意位置上添加一个元素
lst.insert(1, 90)
print(lst)  # [10, 90, 20, 30, 100, 'hello', 'world']

lst3 = [True, False, 'hello']
# 在任意的位置上添加N多个元素
lst[1:] = lst3
print(lst)  # [10, True, False, 'hello']

11.6 列表的删除操作

方法/其它 操作描述
remove() 1. 一次删除一个元素
2. 重复元素只能删除第一个
3. 元素不存在抛出ValueError
pop() 1. 删除一个指定索引位置上的元素
2. 指定索引不存在抛出IndexError
3. 不指定索引，删除列表种最后一个元素
切片 一次至少删除一个元素
clear() 清空列表
del 删除列表

下面通过一个代码例子，来说明一下几种列表的删除操作的一些用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30)  # 从列表种移除一个元素，如果有重复的只移除第一个元素
print(lst)  # [10, 20, 40, 50, 60, 30]
# lst.remove(100) # ValueError: list.remove(x): x not in list

# pop()根据索引移除元素
lst.pop(1)
print(lst)  # [10, 40, 50, 60, 30]，将索引为1的元素20删除
# lst.pop(5)  # IndexError: pop index out of range，如果指定的索引位置不存在，将抛出异常
lst.pop()   # 如果不指定参数（索引），那么将删除列表种的最后一个元素
print(lst)  # [10, 40, 50, 60]

# 切片操作
"""切片操作，删除至少一个元素，将产生一个新的列表对象"""
new_list = lst[1:3]
print('原列表', lst)   # 原列表 [10, 40, 50, 60]
print('新列表', new_list)  # 新列表 [40, 50]
"""不产生新的列表对象，而是删除原列表中的内容"""
lst[1:3] = []
print(lst)  # [10, 60]

# 清除列表中的所有元素
lst.clear()
print(lst)  # []

# del语句会将列表对象删除
del lst
print(lst)  # NameError: name 'lst' is not defined

11.7 列表元素的修改操作

  • 为指定索引的元素赋予一个新值
  • 为指定的切片赋予一个新值

下面是一个代码例子，来参考学习一下列表元素的两种修改操作

1
2
3
4
5
6
7
lst = [10, 20, 30, 40]
# 一次修改一个值
lst[2] = 100
print(lst)  # [10, 20, 100, 40]
# 利用切片，一次修改多个值
lst[1: 3] = [300, 400, 500, 600]
print(lst)  # [10, 300, 400, 500, 600, 40]

11.8 列表元素的排序操作

列表元素的排序操作，常见的有两种方式

  • 调用sort()方法，列表中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序
  • 调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变

下面通过一个例子，了解一下两种不同函数进行排序操作的一些特点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst))   # 排序前的列表 [20, 40, 10, 98, 54] 2701818270784
# 开始排序，利用列表对象的sort方法，升序排序
lst.sort()
print('排序后的列表', lst, id(lst))   # 排序后的列表 [10, 20, 40, 54, 98] 2701818270784
# 通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)
print(lst)  # [98, 54, 40, 20, 10]
# ---------使用内置函数sorted()对列表进行排序，将产生一个新的列表对象-----------
lst = [20, 40, 10, 98, 54]
new_list = sorted(lst)
print(new_list)     # [10, 20, 40, 54, 98]
# 指定关键字参数，实现列表元素的降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)    # [98, 54, 40, 20, 10]

11.9 列表生成式

列表生成式简称“生成列表的公式”

下面通过一段代码，加深对列表生成式的理解

1
2
3
4
5
6
7
lst = [i for i in range(1, 10)]
print(lst)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst2 = [i*i for i in range(1, 10)]
print(lst2) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
"""列表中的元素的值为2，4，6，8，10"""
lst3 = [i*2 for i in range(1, 6)]
print(lst3) # [2, 4, 6, 8, 10]

由上述代码可见，其实真正决定lst的取值的就在于for前面的表达式为多少，如果是i，那就是range()本身迭代的元素，如果是i*2，那就要把迭代的元素全扩大2倍，就如注意事项说的一样，i*i表示为列表元素的表达式。

12 字典

12.1 什么是字典

  • Python内置的数据结构之一，与列表一样是一个可变序列

    • 可变就是指可以执行增删改操作

  • 以键值对的方式存储数据，字典是一个无序的序列

  • scores = {'张山': 100, '李四': 98, '王五': 45}

    • 他们分别由字典名、花括号、逗号、键、冒号、值一一对应组成

12.2 字典的原理

字典的实现原理

字典的实现原理与查字典类似，查字典是先根据部首或者拼音查找对应的页码，而Python中的字典是根据key查找value所在的位置

12.3 字典的创建与删除

  1. 字典的创建
  • 最常用的方式：使用花括号
    • scores = {'张山': 100, '李四': 98, '王五': 45}
  • 使用内置函数dict()
    • dict(name = 'jack', age = 20)

下面通过一段代码，来了解一下

12.4 字典的查询操作

字典中元素的获取有两种方式

  1. [] ——> 举例：scores['张三']
  2. get()方法 ——> 举例：scores.get('张三')

两种方法有着一些区别之处

  • []：如果字典中不存在指定的key，抛出KeyError异常
  • get()方法取值：如果字典中不存在指定的key，并不会抛出KeyError，而是返回None，可以通过参数设置默认的value，以便指定的key不存在时返回

下面通过一段代码，了解一下字典的查询操作

1
2
3
4
5
6
7
8
9
"""获取字典中的元素"""
scores = {'张三': 100, '李四': 98, '王五': 45}
# 第一种方式，使用[]
print(scores['张三'])     # 100
print(scores['陈六'])     # KeyError: '陈六'
# 第二种方式，使用get()方法
print(scores.get('张三'))     # 100
print(scores.get('陈六'))     # 并不会报错，而是输出None
print(scores.get('麻七', 99)) # 99是在查找‘麻七’时，所对应的value不存在时，提供的一个默认值

12.5 字典元素的增、删、改操作

1. key的判断

key的判断 解释 举例
in 指定的key在字典中存在返回True '张三' in scores
not in 指定的key在字典中不存在返回True 'Marry' not in scores 
1
2
3
4
scores = {'张三': 100, '李四': 98, '王五': 45}
"""key值的判断"""
print('张三' in scores)       # True
print('张三' not in scores)   # False

2. 字典元素的删除

  • del scores['张三']
1
2
3
4
5
6
scores = {'张三': 100, '李四': 98, '王五': 45}
"""字典的删除"""
del scores['张三']    # 删除指定的键值对（key-value）
print(scores)   # {'李四': 98, '王五': 45}
scores.clear()  # 清空字典中的所有元素
print(scores)   # {}

3. 字典元素的新增

  • scores['jack'] = 90
1
2
3
4
5
6
7
scores = {'李四': 98, '王五': 45}
"""字典元素的新增"""
scores['陈六'] = 98   # 新增元素
print(scores)   # {'李四': 98, '王五': 45, '陈六': 98}
"""字典元素的修改"""
scores['陈六'] = 100
print(scores)   # {'李四': 98, '王五': 45, '陈六': 100}

值得注意的是，字典元素的新增也可以作为修改来运行，只需把括号里面的键改成自己需要修改的元素，即可对他的value进行修改

4. 获取字典视图的三个方法

  • keys() ——>获取字典中所有的key
  • values() ——>获取字典中所有value
  • items() ——>获取字典中所有key，value对
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
scores = {'张三': 100, '李四': 98, '王五': 45}
# 获取所有的key
keys = scores.keys()
print(keys)             # dict_keys(['张三', '李四', '王五'])
print(type(keys))       # <class 'dict_keys'>
print(list(keys))       # ['张三', '李四', '王五']，将所有的key组成的试图转成列表

# 获取所有的value
values = scores.values()
print(values)           # dict_values([100, 98, 45])
print(type(values))     # <class 'dict_values'>
print(list(values))     # [100, 98, 45]

# 获取所有的key-value对
items=scores.items()
print(items)            # dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(type(items))      # <class 'dict_items'>
print(list(items))      # [('张三', 100), ('李四', 98), ('王五', 45)]，转换之后的列表元素是有元组组成的

5. 字典元素的遍历

代码格式：

1
2
for item in scores:
    print(item)

下面是一个代码例子，用来理解一下元素的遍历方法的使用

1
2
3
4
5
6
7
8
9
10
scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:
    print(item, scores[item], scores.get(item))
    
"""
张三 100 100
李四 98 98
王五 45 45
"""

由代码例子可见，遍历的时候，获取value的值也是和上面的方法类似，可以直接使用[]方法，也可以使用get()方法。但是使用[]方法的时候可能会抛出异常，而get()方法不会抛出异常，只会输出None

12.6 字典的特点

  • 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
  • 字典中的元素是无序的
  • 字典中的key必须是不可变对象
  • 字典也可以根据需要动态地伸缩
  • 字典会浪费较大的内存，是一种使用空间换时间的数据结构

12.7字典推导式

items = ['Fruits', 'Books', 'Others'] prices = [96, 78, 85]

{'Fruits': 96,'Books': 78, 'Others': 85}

  • 内置函数zip()
    • 用于将可迭代对象作为参数，将对象中对应的元素打包成一个元组，然后返回由这些元组组成的列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85]
lst = zip(items, prices)
print(list(lst))    # [('Fruits', 96), ('Books', 78), ('Others', 85)]

d = {item: price for item, price in zip(items, prices)}
print(d)    # {'Fruits': 96, 'Books': 78, 'Others': 85}

items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85, 100, 200]
d = {item: price for item, price in zip(items, prices)}
print(d)    # {'Fruits': 96, 'Books': 78, 'Others': 85}

d = {item.upper(): price for item, price in zip(items, prices)}
print(d)    # {'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

根据上述代码的演示，可以发现，就是利用两个列表合并，用for循环遍历生成了一个字典，其中使用到了内置函数zip()，包括使用到了str.upper()函数，这个函数的意思为将小写字母变成大写字母

13. 元组

13.1 什么是元组

  • t = ('Python', 'hello', 90)

  • 元组：Python内置的数据结构之一，是一个不可变序列

  • 不可变序列和可变序列

    • 不可变序列：字符串、元组
      • 不可变序列没有增删改的操作
    • 可变序列：列表、字典
      • 可变序列可以对序列执行增删改操作，对象地址不发生更改

13.2 元组的创建方式

  1. 直接小括号

t = ('Python', 'hello', 90)

  1. 使用内置函数tuple()

t = tuple(('Python', 'hello', 90))

  1. 只包含一个元组的元素需要使用逗号和小括号

t = (10, )

下面是几段代码，来解释一下元组的创建方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 第一种创建方式
t = ('Python', 'hello', 90)
print(t)                # ('Python', 'hello', 90)
print('t', type(t))     # t <class 'tuple'>

t2 = 'Python', 'hello', 90  # 省略了小括号
print(t2)               # ('Python', 'hello', 90)
print('t2', type(t2))   # t2 <class 'tuple'>

t3 = ('python', )       # 如果元组种只有一个元素，逗号不能省略
print(t3)               # ('python',)
print('t3', type(t3))   # t3 <class 'tuple'>

# 第二种创建方式，使用内置函数tuple()
t4 = tuple(('Python', 'hello', 90))
print(t4)               # ('Python', 'hello', 90)
print('t4', type(t4))   # t4 <class 'tuple'>

# 空列表的创建方式
lst = []
lst1 = list()
print('空列表', lst, lst1)     # 空列表 [] []

# 空字典的创建方式
d = {}
d1 = dict()
print('空字典', d, d1)         # 空字典 {} {}

# 空元组的创建方式
t = ()
t1 = tuple()
print('空元组', t, t1)         # 空元组 () ()

上面代码种也提到了一些注意事项，例如元组只有一个元素的时候，应该怎么创建，在后面加上逗号。另外，还提到了空列表、空字典、空元组的创建方式

13.3 元组的遍历

元组是可迭代对象，所以可以使用for in进行遍历

1
2
3
t = (10, [20, 30], 9)
for item in t:
    print(item)

13.4 为什么将元组设计成不可变序列

  • 在多任务环境下，同时操作对象时不需要加锁
  • 因此，在程序种尽量使用不可变序列

注意事项：

  • 元组种存储的是对象的引用
    • 如果元组中对象本身是不可对象，则不能再引用其他对象
    • 如果元组种的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

下面是一段代码例子，用来说明一下注意事项中的两条

1
2
3
4
5
6
7
8
9
10
11
12
13
14
t = (10, [20, 30], 9)
print(id(t))    # 1505236190656
print(t)  # (10, [20, 30], 9)
print(type(t))  # <class 'tuple'>
print(t[0], type(t[0]), id(t[0]))  # 10 <class 'int'> 2168335919696
print(t[1], type(t[1]), id(t[1]))  # [20, 30] <class 'list'> 1505235036864
print(t[2], type(t[2]), id(t[2]))  # 9 <class 'int'> 2168335919664

"""尝试将t[1]修改成100"""
print(id(100))
# t[1] = 100      # 元组是不允许修改元素的
# 由于[20，30]是列表，而列表是可变序列，所以可以向列中添加元素，但是列表的内存地址不变
t[1].append(100)  # 向列表中添加元素
print(t, id(t[1]))  # (10, [20, 30, 100], 9) 1505235036864

由此可见，如果元组对象中的是不可变对象，比如10，9，那么他们就不能再引用其他对象，因为他们的id是固定的，如果是t[1]，[20, 30]，本身是一个可变的列表，那么它的引用是不可变的，因为它的id是固定的。但是可以再列表后面接着追加变量，例如append(100)，此时它的id仍然是没有变化

14. 集合

14.1 什么是集合

  • Python语言提供的内置数据结构
  • 与列表、字典一样都属于可变类型的序列
  • 集合是没有value的字典

14.2 集合的创建

  • 直接{}
    • s = {'python', 'hello', 90}
  • 使用内置函数set()

下面通过一些代码例子，来了解一下集合的创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 第一种创建方式，使用{}
s = {2, 3, 4, 5, 5, 6, 7, 7}    # 集合中的元素不允许重复
print(s)    # {2, 3, 4, 5, 6, 7}

# 第二种创建方式，使用内置函数set()
s1 = set(range(6))
print(s1, type(s1))     # {0, 1, 2, 3, 4, 5} <class 'set'>
s2 = set([1, 2, 4, 5, 5, 6, 6])     # 将列表中的元素转换成集合
print(s2, type(s2))     # {1, 2, 4, 5, 6} <class 'set'>
s3 = set((1, 2, 4, 5, 5, 65))     # 元组是无序的，所以打印出来的数字顺序变化
print(s3, type(s3))     # {65, 1, 2, 4, 5} <class 'set'>
s4 = set('python')      # 将str类型的元素转换成集合
print(s4, type(s4))     # {'h', 'o', 'p', 'n', 't', 'y'} <class 'set'>
s5 = set({1, 31, 23, 45, 22, 45})   # 将集合中的元素转换成另外一个集合，元素的顺序发成变化
print(s5, type(s5))     # {1, 22, 23, 45, 31} <class 'set'>

# 定义一个空集合
s6 = {}     # 直接定义一个花括号，类型是字典，并不是集合
print(type(s6))     # <class 'dict'>
s7 = set()  # 用set()定义的时候才是集合
print(type(s7))     # <class 'set'>

14.3 集合的增删查改操作

1. 集合元素的判断操作

  • in或者not in
1
2
3
4
5
s = {10, 20, 30, 40, 50}
# 集合元素的判断操作
print(10 in s)      # True
print(100 in s)     # False
print(10 not in s)  # False

2. 集合元素的新增操作

  • 调用add()方法，一次添加一个元素
  • 调用update()方法，至少添加一个元素
1
2
3
4
5
6
7
8
9
s = {10, 20, 30, 40, 50}
# 集合元素的新增操作
s.add(80)   # 一次添加一个元素
print(s)    # {80, 50, 20, 40, 10, 30}
s.update({100, 200, 300})   # 一次添加至少一个元素
print(s)    # {100, 40, 200, 10, 300, 80, 50, 20, 30}
s.update([100, 101])
s.update((201, 202))
print(s)    # {100, 101, 40, 200, 10, 201, 300, 202, 80, 50, 20, 30}

3. 集合元素的删除操作

  • 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在，则抛出KeyError异常
  • 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在，不抛出异常
  • 调用pop()方法，一次只删除一个任意元素
  • 调用clear()方法，清空集合
1
2
3
4
5
6
7
8
9
10
11
s = {100, 101, 40, 200, 10, 201, 300, 202, 80, 50, 20, 30}
# 集合元素的删除操作
s.remove(100)
print(s)    # {101, 40, 200, 10, 201, 300, 202, 80, 50, 20, 30}
# s.remove(500)   # KeyError: 500
s.discard(101)
s.discard(500)  # 集合中没有500，但是程序也没有报错没有抛出异常
print(s)    # {40, 200, 10, 201, 300, 202, 80, 50, 20, 30}
s.pop()     # 随机把40删除了，pop()函数是没有参数的，删除的元素也是随机的
print(s)    # {200, 10, 201, 300, 202, 80, 50, 20, 30}
s.clear()   # 直接把集合清空了

14.4 集合之间的关系

  • 两个集合是否相等
    • 可以使用运算符==或者!=进行判断
1
2
3
4
5
# 判断两个集合是否相等
s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2)  # True
print(s != s2)  # False
  • 一个集合是否是另一个集合的子集
    • 可以调用方法issubset进行判断
    • B是A的子集
1
2
3
4
5
6
# 一个集合是否是另一个集合的子集
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.issubset(s1))  # True
print(s3.issubset(s1))  # False
  • 一个集合是否是另一个集合的超集
    • 可以调用方法issuperset进行判断
    • A是B的超集
1
2
3
4
5
6
# 一个集合是否是另一个集合的超集
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s1.issuperset(s2))    # True
print(s1.issuperset(s3))    # False
  • 两个集合是否没有交集
    • 可以调用方法isdisjoint进行判断
1
2
3
4
5
6
7
# 两个集合是否没有交集
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.isdisjoint(s3))    # False     有交集为False
s4 = {100, 200, 300, 400}
print(s2.isdisjoint(s4))    # True  s2和s4是没有交集的，没有交集为True

14.5 集合的数据操作

交集、并集、差集、对称差集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# （1）交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50}
print(s1.intersection(s2))  # {40, 20, 30}
print(s1 & s2)  # {40, 20, 30}      intersection()和 & 等价，都是交集操作

# （2）并集
print(s1.union(s2))     # {40, 10, 50, 20, 30}
print(s1 | s2)  # {40, 10, 50, 20, 30}      union()和 | 等价，都是并集操作

# （3）差集
print(s1.difference(s2))    # {10}
print(s1-s2)    # {10}      difference()和 - 等价，都是差集操作

# （4）对称差集
print(s1.symmetric_difference(s2))  # {10, 50}

14.6 集合生成式

  • 用于生成集合的公式
    • {i * i for i in range(1, 10)}
    • i*i中的i表示集合元素的表达式，第二个i是自定义变量，range是可迭代对象
  • 将{}修改为[]就是列表生成式
  • 没有元素生成式
1
2
3
4
5
6
7
# 列表生成式
lst = [i*i for i in range(6)]
print(lst)      # [0, 1, 4, 9, 16, 25]

# 集合生成式
s = {i*i for i in range(10)}
print(s)        # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

15. 列表、字典、元组、集合总结

数据结构 是否可变 是否重复 是否有序 定义符号
列表（list） 可变 可重复 有序 []
元组（tuple） 不可变 可重复 有序 ()
字典（dict） 可变 key不可重复
value可重复		 无序 {key: value}
集合（set） 可变 不可重复 无序 {}

元组与集合的知识总结

Python
日常学习 Python

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！