理想国Python基础教程之常用容器

01.字符串

what：是什么

• 字符串是Python中最常用的一种数据结构
• 字符串是一种序列容器，存储的是单个字符

why：为什么学习

• 基础必知必会
• 字符串几乎存在于每一个程序中

where：在哪里用

• 有输入输出的地方一般都有字符串
• 很多信息都需要用字符串存储

when：什么时候用

• 输入输出的时候

how：怎么使用

• 定义字符串
• 字符串切片
• 字符串方法

02.字符串切片

定义字符串的四种方式

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 定义字符串
s1 = 'abc'
s2 = "abc"
s3 = '''abc'''
s4 = """abc"""

# 使用type查看变量的数据类型
print(s1, type(s1))
print(s2, type(s2))
print(s3, type(s3))
print(s4, type(s4))

字符串切片：字符串[开始索引：结束索引：步长]

• 和range函数一样，有开始值，结束值，步长
• 字符串的索引即就是字符串每个字符所代表的位置，从左到右，是从0开始的有序数字
• 字符串切片支持倒着切
• 字符串所有支持负数，-1表示最后一个字符的索引

练习1：有一个字符串"abcde"，请倒序输出

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习1：有一个字符串"abcde"，请倒序输出

s = "abcde"
print(s[::-1])

练习2：有一个字符串"a1b2c3d4e5"，提取出里面的英文字母并打印

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习2：有一个字符串"a1b2c3d4e5"，提取出里面的英文字母并打印
s = "a1b2c3d4e5"
print(s[::2])

练习3：有一个字符串"abc123abc456"，提取出里面的数字并打印

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习3：有一个字符串"abc123abc456"，提取出里面的数字并打印
s = "abc123abc456"
result = s[3:3 + 3] + s[-3:]
print(result)

03.字符串方法

查看字符串的所有方法

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 查看字符串所有方法
for i in dir(str):
    if not i.startswith('_'):
        print(i, end=' ')

修改字符串
capitalize：将字符串首字母大写
encode：编码字符串
expandtabs：将\t从4个空格变成8个空格
join：将字符串数组转换为字符串
lower：字符串小写
upper：字符串大写
lstrip：去除字符串左边空格
rstrip：去除字符串右边空格
strip：去除字符串左右两边空格
maketrans：按照给定的字典或者两个列表制作翻译表，共translate调用
translate：按照翻译表翻译数据
replace：替换
split：分割
rsplit：从右分割
splitlines：按空格分割
swapcase：交换大小写
title：每个单词首字母大写
zfill：用0填充字符串
casefold：返回没有大小写比较的字符串
partition：分割字符串，返回元组（分隔符左边字符串，分隔符，分隔符右边字符串）
rpartition ：从右分割字符串，返回元组（分隔符左边字符串，分隔符，分隔符右边字符串）

调整字符串输出格式
center：居中
format：格式化输出
format_map：按照映射格式化输出
ljust：左对齐
rjust：右对齐

统计字符串
count：统计子字符串出现的次数

判断字符串
startswith：是否以子字符串开头
endswith：是否以子字符串结尾
isalnum：是否为英文字符加数字
isalpha：是否为英文字符
isascii：是否为ascii编码
isdecimal：是否为十进制数字
isdigit：是否为数字
isidentifier：是否为有效的标识符
islower：是否全小写
isnumeric：是否为数字
isprintable：是否可打印
isspace：是否为空格
istitle：是否为标题
isupper：是否全大写

查找字符串
find：查询索引，不存在返回-1
index：查询索引，不存在报错
rfind：从右查询索引
rindex：从右查询索引

04.修改字符串

在ipython中校验以下代码

capitalize：将字符串首字母大写

s = 'abc'
s.capitalize()

encode：编码字符串

s.encode()

expandtabs：将\t从4个空格变成8个空格

s = "a \t b"
s.expandtabs()

join：将字符串数组转换为字符串

s = ['a', 'b', 'c']
','.join(s)

lower：字符串小写

s = 'Hello world'
s.lower()

upper：字符串大写

s.upper()

lstrip：去除字符串左边空格

s = '        abc            '
s.lstrip()

rstrip：去除字符串右边空格

s.rstrip()

strip：去除字符串左右两边空格

s.strip()

maketrans：按照给定的字典或者两个列表制作翻译表，共translate调用
translate：按照翻译表翻译数据

s = str.maketrans({'1':'一','2':'二','3':'三'})
str.translate('3', s)

replace：替换

s = 'abc'
s.replace('b','BBB')

split：分割

s = 'a,b,c'
s.split(',')

rsplit：从右分割

s.rsplit(',', 1)

splitlines：按空格分割

s = 'a\nb\r\nc'
s.splitlines()

swapcase：交换大小写

s = 'Hello world'
s.swapcase()

title：每个单词首字母大写

s.title()

zfill：用0填充字符串

s = '1'
s.zfill(6)

casefold：返回没有大小写比较的字符串

s = 'AbcDefGG'
s.casefold() # 全小写

partition：分割字符串，返回元组（分隔符左边字符串，分隔符，分隔符右边字符串）

s = 'a bbb c'
s.partition('bbb')

rpartition ：从右分割字符串，返回元组（分隔符左边字符串，分隔符，分隔符右边字符串）

s = 'a bbb bbb c'
s.rpartition('bbb')

05.调整字符串输出格式

使用ipython校验下面的代码

center：居中

s = 'abc'
s.center(20)
s.center(33, '-')
s.center(44, '#')

format：格式化输出

s = '{}: {}'
s.format('name', 'lxgzhw')

format_map：按照映射格式化输出

student = {'name':'小明','class':'20190301','score':597.5}
s1 = '{class}班{name}总分：{score}'.format_map(student)

ljust：左对齐

s = 'abc'
s.ljust(20)
s.ljust(33, '-')
s.ljust(44, '#')

rjust：右对齐

s = 'abc'
s.rjust(20)
s.rjust(33, '-')
s.rjust(44, '#')

06.统计字符串

count：统计子字符串出现的次数

s = 'hello world'
s.count('o')

07.判断字符串

startswith：是否以子字符串开头

url = 'http://lxgzhw520.com'
url.startswith('http')

endswith：是否以子字符串结尾

file_name = 'test.png'
file_name.endswith('png')

isalnum：是否为英文字符加数字

s = 'abc123'
s.isalnum()

isalpha：是否为英文字符

s = 'hello world' # 有空格也不行
s.isalpha()

isascii：是否为ascii编码

s = 'abc'
s.isascii()

isdecimal：是否为十进制数字

num = '01010101'
num.isdecimal()

isdigit：是否为数字

num = '01010101'
num.isdigit()

isidentifier：是否为有效的标识符

s = 'while'
s.isidentifier()

islower：是否全小写

s = 'abc'
s.islower()

isnumeric：是否为数字

s = '1000'
s.isnumeric()

isprintable：是否可打印

s = 'abc'
s.isprintable()

isspace：是否为空格

s = '\t'
s.isspace()

istitle：是否为标题

s = 'Hello World'
s.istitile()

isupper：是否全大写

s = 'ABC'
s.isupper()

07.查找字符串

find：查询索引，不存在返回-1

s = 'abc'
s.find('aa')

index：查询索引，不存在报错

s = 'abc'
s.index('a')
s.index('aa')

rfind：从右查询索引

s = 'abc'
s.rfind('a')
s.rfind('aa')

rindex：从右查询索引

s = 'abc'
s.rindex('a')
s.rindex('aa')

08.列表

what：是什么

• 列表是一种线性结构的序列容器
• 列表和字符串一样，都有自己的索引，都可以切片
• 字符串不可变，列表可变
• 字符串只能存储字符，列表可以存储任何内容
• 列表可以嵌套

why：为什么使用列表

• 列表能够很方便的帮我们存储同类型的数据
• 比如：存储1000个数，存储100个网址，30个人物信息

where：在哪里使用

• 在需要存储相同类型数据的时候都可以使用

when：什么时候用

• 当需要存储相同类型数据的时候

how：如何使用

• 基本用法
• 所有方法

列表的基本用法

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 定义列表
l01 = []  # 空列表
l02 = [1, 2, 3, 4, 5]  # 有数据的列表
l03 = list('abc')  # 字符串转列表

# 通过索引访问数组元素
print(l02[0], l03[1])

# 通过切片访问元素
print(l02[:2], l03[::-1])

# 添加元素
l01.append('hello')
print(l01)

# 修改元素
l01[0] = 'world'
print(l01)

# 删除元素
del l01[0]  # del关键字删除
print(l01)

# pop删除最后一个
l02.pop()
print(l02)

# pop删除指定元素
l03.pop(1)
print(l03)

查看列表的所有方法

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

for i in dir(list):
    if not i.startswith('_'):
        print(i, end=' ')

09.列表所有方法

append：追加元素到列表最后
clear：清空列表元素
copy：列表浅复制
count：统计列表某元素个数
extend：添加另一个列表所有元素
index：查找某个元素的索引
insert：向指定位置插入元素
pop：删除最后一个元素或者指定位置元素
remove：删除指定元素
reverse：列表反转
sort：列表排序

示例

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""
l01 = []
# append：追加元素到列表最后
l01.append('a')
print(l01)

# clear：清空列表元素
l01.clear()
print(l01)

# copy：列表浅复制
l02 = l01.copy()
l02.append('abc')
print(l01, l02)

# extend：添加另一个列表所有元素
l02.extend(['a', 'a', 'b', 'c'])
print(l02)

# count：统计列表某元素个数
print(l02.count('a'))

# index：查找某个元素的索引
print(l02.index('b'))

# insert：向指定位置插入元素
l02.insert(0, 'aa')
print(l02)

# pop：删除最后一个元素或者指定位置元素
l02.pop()
l02.pop(0)
print(l02)

# remove：删除指定元素
l02.remove('abc')
print(l02)

# reverse：列表反转
l02.reverse()
print(l02)

# sort：列表排序
l02.sort()
print(l02)

10.列表练习

练习1：生成一个列表，该列表元素为1000以内3,5,7的公倍数

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习1：生成一个列表，该列表元素为1000以内3,5,7的公倍数
num_list = []
for i in range(3, 1000, 3):
    if i % 5 == 0 and i % 7 == 0:
        num_list.append(i)
print(num_list)

输出结果

[105, 210, 315, 420, 525, 630, 735, 840, 945]

练习2：已知列表l01 = [1, 2, [3, 4, [5, 6, 7, [8, 9, 10], 'a', 'b'], 'c'], 'dd', 'ee']。取出其中的10，‘a’,‘b’，然后删除10，将’a’改为’abc’，将’b’改为索引0和1所在位置之数的和的10次方。

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 已知列表`l01 = [1, 2, [3, 4, [5, 6, 7, [8, 9, 10], 'a', 'b'], 'c'], 'dd', 'ee']`。
l01 = [1, 2, [3, 4, [5, 6, 7, [8, 9, 10], 'a', 'b'], 'c'], 'dd', 'ee']

# 取出其中的10，'a','b'，
print(l01[2][2][3][2])  # 10
print(l01[2][2][4])  # a
print(l01[2][2][5])  # b

# 然后删除10
del l01[2][2][3][2]
print(l01)

# 将'a'改为'abc'
l01[2][2][4] = 'abc'
print(l01)

# 将'b'改为索引0和1所在位置之数的和的10次方
l01[2][2][5] = (l01[0] + l01[1]) ** 10
print(l01)

练习3：生成由0-100所有整数和，100-1000所有整数和，1000-10000所有整数和，以及33-44之间每个数的平方乘以100后得到的数组成的列表。然后将20-30之间的累加和（20,20+21,20+21+22，…，21+22+23+…+30）组成的列表中的每一个元素追加到前一个列表。最后计算该列表的总和，平均值，最大值，最小值，并将计算的值组成新的列表插入到该列表的第一个元素之前。

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习3：生成由0-100所有整数和，100-1000所有整数和，1000-10000所有整数和，以及33-44之间每个数的平方乘以100后得到的数组成的列表。
num_list = []
num_list.append(sum(range(101)))  # 0-100所有整数和
num_list.append(sum(range(100, 1001)))  # 100-1000所有整数和
num_list.append(sum(range(1000, 10001)))  # 1000-10000所有整数和
for i in range(33, 45):  # 以及33-44之间每个数的平方乘以100后得到的数组成的列表
    num_list.append(i ** 2 * 100)
print(num_list)

# 然后将20-30之间的累加和（20,20+21,20+21+22，...，21+22+23+...+30）组成的列表中的每一个元素追加到前一个列表。
temp_list = []
for i in range(20, 31):
    temp_list.append(sum(range(20, i + 1)))
print(temp_list)
num_list.extend(temp_list)
print(num_list)

# 最后计算该列表的总和，平均值，最大值，最小值
num_list_sum = sum(num_list)
num_list_avg = num_list_sum / float(len(num_list))
num_list_max = max(num_list)
num_list_min = min(num_list)
print(f'总和：{num_list_sum}，平均值：{num_list_avg}，最大值：{num_list_max}，最小值：{num_list_min}')

# 并将计算的值组成新的列表插入到该列表的第一个元素之前。
num_list.insert(0, [num_list_sum, num_list_avg, num_list_max, num_list_min])
print(num_list)

11.字典

what：是什么

• 字典也是一种容器，存储的是键值对类型的结构
• 列表是有序的，字典是无序的
• 字典的键要求唯一且不可变，一般是字符串，可以是元组，数字等不可变数据类型

why：为什么使用字典

• 字典能够存储键值对类型的结构
• 比如人的姓名，年龄，性别

where：在哪里使用

• 几乎可以在程序的任何需要的地方使用

when：什么时候使用

• 需要存储对象的时候一般都可以使用字典

how：如何使用

• 基本操作
• 所有方法

基本操作

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 字典基本操作
d01 = {}  # 创建空字典
d02 = {'name': 'zhangdapeng', 'age': 22, 'sex': 'male'}  # 创建有值的字典

# 添加数据
d01['name'] = '张大鹏'
print(d01)

# 修改数据
d01['name'] = '张三'
print(d01)

# 获取数据
print(d01.get('name'))

# 删除数据
del d01['name']
print(d01)

查看字典的所有方法

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 查看字典的所有方法
for i in dir(dict):
    if not i.startswith('_'):
        print(i, end=' ')

12.字典所有的方法

clear：清空字典
copy：字典浅拷贝
fromkeys：将序列容器的值作为键生成新的字典
get：根据键获取值
items：获取字典所有的键值对
keys：获取字典所有的键
pop：根据键删除
popitem：随机删除
setdefault：如果不存在则赋值，存在则不操作
update：根据另一个字典修改字典
values：获取字典所有的值

示例代码

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""
d01 = {'name': 'zhangsan'}
# clear：清空字典
d01.clear()
print(d01)

# copy：字典浅拷贝
d02 = d01.copy()
d02['name'] = 'lisi'
print(d01, d02)

# fromkeys：将序列容器的值作为键生成新的字典
d03 = dict.fromkeys(['a', 'b', 'c'])
d04 = dict.fromkeys('abc')
print(d03, d04)

# get：根据键获取值
print(d02.get('name'))

# items：获取字典所有的键值对
print(d03.items(), type(d03.items()))

# keys：获取字典所有的键
print(d04.keys())

# pop：根据键删除
d03.pop('a')
d03.pop('b')
print(d03)

# popitem：随机删除
d04.popitem()
print(d04)

# setdefault：如果不存在则赋值，存在则不操作
d01.setdefault('age', 22)
d01.setdefault('age', 33)
print(d01)

# update：根据另一个字典修改字典
print(d02)
d01.update(d02)
print(d01)

# values：获取字典所有的值
print(d01.values())

13.字典练习

练习1：循环从控制台录入学生信息（姓名，年龄，性别）。将每个学生的信息使用字典保存，然后将学生信息存储在学生列表中。停止录入后，计算学生的平均年龄，男生和女生的比率。

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习1：循环从控制台录入学生信息（姓名，年龄，性别）。将每个学生的信息使用字典保存，然后将学生信息存储在学生列表中。
# 停止录入后，计算学生的平均年龄，男生和女生的比率。
student_list = []
while True:
    name = input("请输入学生姓名：")
    age = int(input("请输入学生年龄："))
    sex = input("请输入学生性别（1.男 2.女）：")
    student_list.append({'name': name, 'age': age, 'sex': sex})

    if input('录入成功，是否继续录入？(y/n)：') != 'y':
        break

age_avg = 0  # 平均年龄
age_sum = 0  # 年龄总和
count_sex_1 = 0  # 男生个数
count_sex_2 = 0  # 女生个数

for student in student_list:
    age_sum += student['age']
    if student['sex'] == '1':
        count_sex_1 += 1
    else:
        count_sex_2 += 1
len_student_list = float(len(student_list))  # 学生个数
age_avg = age_sum / len_student_list  # 平均年龄
male_percent = count_sex_1 / len_student_list  # 男生比率
femal_percent = count_sex_2 / len_student_list  # 女生比率

print('学生平均年龄：{}，男生比率：{:.2f}，女生比率：{:.2f}'.format(
    age_avg, male_percent, femal_percent
))

练习2：存在一个字典num_dict，将所有的水仙花数存储在该字典中。将100-200之间的所有质数存在该字典中。将100到200之间所有以9或者8或者6结尾的数存储在该字典中。计算该字典中所有数的和并输出。计算该字典中每一个键对应的值的列表和，比较最大的是什么并输出。

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习2：存在一个字典`num_dict`，将所有的水仙花数存储在该字典中。
num_dict = {}
num_dict['水仙花数'] = []
for i in range(100, 1000):
    temp_str = str(i)
    temp = 0
    for j in temp_str:
        temp += int(j) ** 3
    if temp == i:
        # print(temp)
        num_dict['水仙花数'].append(temp)

# 将100-200之间的所有质数存在该字典中。
num_dict['100-200之间的所有质数'] = []
for i in range(100, 201):
    flag = True
    for j in range(2, i):
        if i % j == 0:
            flag = False  # 不是质数
            break
    if flag:
        # print(i)
        num_dict['100-200之间的所有质数'].append(i)

# 将100到200之间所有以9或者8或者6结尾的数存储在该字典中。
num_dict['100到200之间所有以9或者8或者6结尾的数'] = []
for i in range(100, 201):
    temp = str(i)
    if temp.endswith('9') or temp.endswith('8') or temp.endswith('6'):
        # print(i)
        num_dict['100到200之间所有以9或者8或者6结尾的数'].append(i)

# 计算该字典中所有数的和并输出。
num_sum = 0
for i in num_dict.values():
    num_sum += sum(i)
print(num_sum)

# 计算该字典中每一个键对应的值的列表和，比较最大的是什么并输出。
value_list = []
for v in num_dict.values():
    value_list.append(sum(v))
print(max(value_list))

练习3：循环从控制台输入数字。将数字作为键，该数字乘以该数字录入的次序数（1,2,3…)的3次方作为值存入一个字典中。停止循环后，求该字典中最大的值以及该值对应的索引。

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 练习3：循环从控制台输入数字。
num_dict = {}
count = 1
while True:
    # 将数字作为键，该数字乘以该数字录入的次序数（1,2,3...)的3次方作为值存入一个字典中。
    num = float(input("请输入一个数字："))
    num_dict[num] = num * (count ** 3)
    count += 1

    if input("是否继续？(y/n)：") == 'n':
        break

# 停止循环后，求该字典中最大的值以及该值对应的索引。
max_value = max(num_dict.values())
for k in num_dict.keys():
    if max_value == num_dict.get(k):
        print(f'最大值的索引是：{k}，最大值为：{max_value}')
        break

14.元组

what：是什么

• 元组是一种存储相同类型数据的不可变数据类型
• 元组一旦定义，就不能修改
• 元组的元素也是通过索引去访问

why：为什么使用

• 元组是Python特别的概念，在大部分其他语言中都没有
• 元组在Python中使用较为频繁，比如函数的参数，函数的返回值是多个的时候也默认为元组

where：在哪里使用

• 作为函数的参数
• 作为函数的返回值
• 存储普通的不可变同类数据

when：什么时候使用

• 当数据结构类似于列表，但是又不希望再改变的时候

how：怎么使用

• 基本用法
• 所有方法

基本用法

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""

# 元组的基本用法
t01 = tuple()  # 定义空的元组
t02 = tuple([1, 2, 3, 4, 5, 6, 7])  # 将列表转换为元组
t03 = tuple('abc')  # 将字符串转换为元组
t04 = (1,)  # 定义只有一个元素的元组
t05 = (11, 22, 3, 44)  # 定义有多个元素的元组

# 访问元组元素
print(t02[0])  # 索引
print(t02[0:5:2])  # 切片

# 遍历
for i in t03:
    print(i, end=' ')

查看元组的所有方法

#! /usr/bin/python
"""
作者：张大鹏
描述：元组的所有方法
"""
for i in dir(tuple):
    if not i.startswith('_'):
        print(i, end=' ')

元组的所有方法

count：统计元素出现的次数
index：查看元素的索引

示例

#! /usr/bin/python
"""
作者：张大鹏
描述：练习
"""
t01 = (1, 2, 3, 4, 4, 5, 6, 66, 6)

# count：统计元素出现的次数
print(t01.count(6))

# index：查看元素的索引
print(t01.index(4))

15.集合

what：是什么

• 集合是一种不可重复的，无序的数据容器
• 有自动去重的功能

why：为什么使用

• Python是一门数学工具语言，比如操作集合，提供了很多简便的方法
• 能够自动去重

where：在哪里使用

• 外部作用域
• 方法参数，方法内部作用域，方法返回值

when：什么时候使用

• 当需要操作集合的时候
• 当需要给数据去重的时候

how：怎么用

• 基本使用
• 所有方法

基本使用

#! /usr/bin/python
"""
作者：张大鹏
描述：集合的基本使用
"""

# 创建
d01 = {1, 2, 3}  # 创建集合
d02 = dict()  # 创建空集合

# 添加
d01.add(33)

# 修改：不提供修改功能，可以先删除后增加
# 查看：遍历
for i in d01:
    print(i, end=' ')

查看所有方法

#! /usr/bin/python
"""
作者：张大鹏
描述：查看集合的所有方法
"""

for i in dir(set):
    if not i.startswith('_'):
        print(i, end=' ')

# 基本操作
add：添加元素
clear：清空集合
difference_update：从这个集合中删除另一个集合的所有元素
intersection_update：用它自己和另一个的交集来更新一个集合
pop：移除并返回任意的set元素。如果集合为空，则抛出KeyError
remove：从集合中删除一个元素，它必须是一个成员。如果元素不是成员，则引发KeyError
symmetric_difference_update：用自身和另一个集合的对称差来更新集合
update：用集合本身和其他集合的联合来更新集合

# 基本运算
copy：集合浅拷贝
difference：将两个或多个集合的差值作为一个新集合返回
discard：如果一个元素是集合的成员，则从集合中删除该元素。如果元素不是成员，什么也不做
intersection：求交集
union：求并集
symmetric_difference：求对称差集（并集 - 交集）

# 判断方法
isdisjoint：如果两个集合有空交集返回True
issubset：报告另一个集合是否包含此集合
issuperset：报告这个集合是否包含另一个集合

16.集合基本操作

使用ipython校验以下代码

add：添加元素

s = set()
s.add(1)
s
s.add(1)
s
s.add(2)
s
s.add(3)
s

clear：清空集合

s.clear()
s

difference_update：从这个集合中删除另一个集合的所有元素

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s1.difference_update(s2)
s1

intersection_update：用它自己和另一个的交集来更新一个集合

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s1.intersection_update(s2)
s1

pop：移除并返回任意的set元素。如果集合为空，则抛出KeyError

s = {1, 2, 3}
s
s.pop()
s
s.pop()
s

remove：从集合中删除一个元素，它必须是一个成员。如果元素不是成员，则引发KeyError

s = {1, 2, 3}
s.remove(1)
s

symmetric_difference_update：用自身和另一个集合的对称差来更新集合

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s1.symmetric_difference_update(s2) # 并集 - 交集
s1

update：用集合本身和其他集合的联合来更新集合

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s1.update(s2) # 取并集
s1

17.集合基本运算

使用ipython校验下面的代码

copy：集合浅拷贝

s1 = {1, 2, 3}
s2 = s1.copy()
s2

difference：将两个或多个集合的差值作为一个新集合返回

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s3 = s1.difference(s2) # s1 - s1与s2的交集
s3

discard：如果一个元素是集合的成员，则从集合中删除该元素。如果元素不是成员，什么也不做

s = {1, 2, 3}
s.discard(3)
s
s.discard(3)
s

intersection：求交集

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s3 = s1.intersection(s2) # 交集
s3

union：求并集

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s3 = s1.union(s2) # 并集
s3

symmetric_difference：求对称差集（并集 - 交集）

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s3 = s1.symmetric_difference(s2) # 对称差集
s3

18.集合判断方法

使用ipython校验以下代码

isdisjoint：如果两个集合有空交集返回True

s1 = {1, 2, 3}
s2 = {4, 5, 6}
s.isdisjoint(s2)

issubset：报告另一个集合是否包含此集合

s1 = {1, 2, 3}
s2 = {1, 2, 3, 4, 5, 6}
s1.issubset(s2)

issuperset：报告这个集合是否包含另一个集合

s1 = {1, 2, 3, 4, 5, 6}
s2 = {1, 2, 3}
s1.issuperset(s2)

19.集合运算符

|   求并集
&   求交集
^   求对称差集
-   求差集

使用ipython校验以下代码

s1 = {1, 2, 3}
s2 = {3, 4, 5}
s3 = {2, 3}

s1 | s2 # 并集
s1 & s2 # 交集
s1 ^ s2 # 对称差集
s1 - s2 # 差集

教程结束

• 谢谢大家的阅读，创业不易，如果您感觉对您有帮助，请打赏我一点
• 我微信18010070052，欢迎加我交流
• QQ交流群：630377015
• 零基础想要学python或者Java全栈的同学欢迎报名跟我学习
• 有基础想要学微服务或者RESTFul API，前后端分离开发，小程序的同学也可以找我报名学习哦