容器数据类型

字符串

• 字符串是不可变的、有序的。
• 字符串中元素不可修改。
• 字符串使用单引号、双引号或三重引号定义。
• 字符串中每个值都有对应的位置值，称为索引或下标，索引从起始从0开始向后逐个递增，并且从末尾从-1开始逐个向前递减。

创建字符串

s1 = "hello world"

字符串相加

s1 = "hello"
s2 = "world"

print(s1 + s2) # helloworld

字符串乘法

s1 = "hello"
print(s1*2) # hellohello

检查成员是否为字符串中的元素

s1 = "hello"
print(h in s1) #True

原始字符串

所有的字符串按照字面意思处理，没有转义字符。需在字符串前加上r / R。

s1 = r"hello\nw" # 不换行
s1 = "hello\nw" # 换行
print(s1)

字符串的访问

s1 = "hello world"

print(s1[0])  # h
print(s1[-1])  # d
print(s1[1:3])  # el
print(s1[4:-3])  # o wo

字符串相关操作

函数	说明
str.replace(old, new[, max])	把将字符串中的 old 替换成 new，如果指定 max，则替换不超过 max 次
str.split([x][, n])	按 x 分隔字符串，默认按任何空白字符串分隔并在结果中丢弃空字符串。可指定最大分隔次数
str.rsplit([x][, n])	与 split() 类似，从右边开始分隔
x.join(seq)	以 x 作为分隔符，将序列中所有的字符串合并为一个新的字符串
str.strip([x])	截掉字符串两边的空格或指定字符
str.lstrip([x])	截掉字符串左边的空格或指定字符
str.rstrip([x])	截掉字符串右边的空格或指定字符
str.removeprefix()	截掉字符串指定前缀
str.removesuffix()	截掉字符串指定后缀
str.upper()	将所有字符转为大写
str.lower()	将所有字符转为小写
str.swapcase()	反转字符串中字母大小写
str.capitalize()	将字符串第一个字母变为大写，其他字母变为小写
str.title()	将字符串每个单词首字母大写
str.casefold()	返回适合无大小写比较的字符串版本
len(str)	返回字符串长度
max(str)	返回字符串中最大值
min(str)	返回字符串中最小值
str.find(x[, start][, end])	返回字符串中第一个 x 的索引值，不存在则返回 -1，可指定字符串开始结束范围
str.rfind(x[, start][, end])	与 find() 类似，从右边开始查找
str.index(x[, start][, end])	返回字符串中第一个 x 的索引值，不存在则报错，可指定字符串开始结束范围
str.rindex(x[, start][, end])	与 index() 类似，从右边开始查找
str.count(x[, start][, end])	返回字符串中 x 的个数，可指定字符串开始结束范围
str.startswith(x[, start][, end])	检查字符串是否以 x 开头，可指定字符串开始结束范围
str.endswith(x[, start][, end])	检查字符串是否以 x 结尾，可指定字符串开始结束范围
str.isspace()	检查字符串是否非空且只包含空白

# 大小写转换

s1 = "ABC"

print(s1.lower())  # 小写 abc

s2 = "abc"
print(s2.upper())  # 大写 ABC

# 字符串查找

s3 = "abcdefg"

print(s3.find("a"))  # 返回下标0
print(s3.find("z"))  # 找不到返回-1

print(s3.index("a"))  # 返回下标0
# print(s3.index("z"))  # 找不到就报错ValueError: substring not found

# 统计字符串出现的次数
s4 = "abacd"
print(s4.count("a"))  # 返回次数 2

元组

• 元组是一个不可变的、有序的元素集合。
• 不能对元组中的元素进行修改操作。
• 元组使用()定义，数据之间使用,分隔。
• 元组中每个元素都有对应的位置值，称为索引或下标，索引从起始从0开始向后逐个递增，并且从末尾从-1开始逐个向前递减。
• 元组中元素可以是不同的类型。
  元组的使用方式与列表类似。

元组创建

tuple = (100,200,300,400,500)

如果只有一个元素，必须添加逗号，否则括号会被当作运算符使用

tuple = (100,)

推导式创建:

• 与列表推导式类似，但使用小括号
• 生成的是生成器对象，需要转换为元组

访问元组

基本与list一致

tuple1 = (100,)
print(tuple1)  # <class 'tuple'>
print(type(tuple1))


# 推导式创建
tuple2 = tuple(x for x in range(0, 10))
print(tuple2)  # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# 访问
print(tuple2[0])  # 0

# 切片
print(tuple2[0:2])  # (0, 1)

元组计算

tuple1 = (100, 200, 300)
tuple2 = ("a", "b", "c")

# 元组相加
print(tuple1 + tuple2)  # (100, 200, 300, 'a', 'b', 'c')

# 元组乘法
print(tuple1 * 2)  # (100, 200, 300, 100, 200, 300)

元组的使用

tuple1 = (100, 200, 300, 400, 500, 600)

# 成员检测
print(800 in tuple1)  # False
print(100 in tuple1)  # True
print("-" * 20)
# 获取元组的长度
print(len(tuple1))  # 6
print("-" * 20)

# 求最大值、最小值、求和
print(max(tuple1))  # 600
print(min(tuple1))  # 100
print(sum(tuple1))  # 2100

print("-" * 20)

# 元组遍历
for i in tuple1:
    print(i)
print("-" * 20)

for i in range(len(tuple1)):
    print(tuple1[i])
print("-" * 20)

for index, value in enumerate(tuple1):
    print(f"下标：{index},值：{value}")

元组不可变

元组的不可变指的是元组所指向的内存中的内容不可变，但可以重新赋值。

tuple1 = (100, 200, 300, 400, 500, 600)

print(id(tuple1), tuple1)  # 4335970880 (100, 200, 300, 400, 500, 600)

tuple1 += ("a", "b", "c")

print(id(tuple1), tuple1)  # 4346593456 (100, 200, 300, 400, 500, 600, 'a', 'b', 'c')

如果元组中元素是可变数据类型，其嵌套项可以被修改。

tuple1 = (100, 200, 300, 400, 500, 600, [1, 2, 3, 4])
print(id(tuple1), tuple1)  # 4333843744 (100, 200, 300, 400, 500, 600, [1, 2, 3, 4])

tuple1[6].append(8)
print(id(tuple1), tuple1)  # 4333843744 (100, 200, 300, 400, 500, 600, [1, 2, 3, 4])

# 直接对元组元素赋值会报错，提示"tuple object does not support item assignment"
tuple1[5] = 900
print(tuple1)

集合Set

• 集合是无序的，且不包含重复元素。
• 集合使用 {} 定义，数据之间使用 , 分隔，也可以使用set()定义。
• 集合没有索引，所以不能通过切片方式访问集合元素。
• 集合中元素可以是不同的类型。
• 集合可以进行数学上的集合操作，如并集、交集和差集。

创建集合

set1 = {1, 2, 3}
print(set1)  # {1, 2, 3}
print(type(set1))  # <class 'set'>

print("-" * 20)
set2 = {1, 2, 2}
print(set2)  # {1, 2} 自动去除重复内容

print("-" * 20)

set3 = set([1, 2, 3])  # {1, 2, 3}使用set()函数从列表创建集合
print(set3)

print("-" * 20)

# 推导式创建
set4 = {x for x in range(0, 10)}
print(set4)

集合操作

set1 = {100, 200, 300, 400}

# 向集合中添加元素
set1.add(500)
print(set1)  # {100, 200, 300, 400, 500}

print("-" * 20)


# 删除集合中的元素
set2 = {100, 200, 300, 400}

set2.remove(100)

print(set2)  # {200, 400, 300}

print("-" * 20)
# 成员检测
set3 = {100, 200, 300, 400, 500}
print(900 in set3)  # False
print(100 in set3)  # True

print("-" * 20)
# 获取集合长度

print(len(set3))  # 5
print("-" * 20)

# 求集合中元素的最大值、最小值、加和
print(max(set3))  # 500
print(min(set3))  # 100
print(sum(set3))  # 1500
print("-" * 20)

# 遍历集合
set4 = {100, 200, 300, 400, 500}
for item in set4:
    print(item)

集合常用函数

函数	说明
set.add(x)	添加元素
set.update(x)	添加元素，x 可以为列表、元组、字符串、字典等可迭代对象
set.union(x)	添加元素后返回一个新的集合，x 可以为列表、元组、字符串、字典等可迭代对象
set.remove(x)	从集合中移除 x，x 不存在则报错
set.discard(x)	从集合中移除 x，x 不存在也不报错
set.pop()	随机取出集合中的一个元素，如果集合为空则报错
set.clear()	清空集合
set.difference(x1, ...)	求 set1 和 x1 的差集，返回一个新的集合
set.difference_update(x1, ...)	求 set1 和 x1 的差集
set.intersection(x1, ...)	求 set1 和 x1 的交集，返回一个新的集合
set.intersection_update(x1, ...)	求 set1 和 x1 的交集
set1 & set2	两集合求交集
set1 | set2	两集合求并集
set1 - set2	两集合求差集
set1.isdisjoint(set2)	判断两集合是否没有交集
set1.issubset(set2)	判断 set1 是否为 set2 的子集
set1.issuperset(set2)	判断 set2 是否为 set1 的子集（注：通常指 set1 是否包含 set2）
set1.symmetric_difference(set2)	求两集合中不重复的元素，返回一个新的集合
set1.symmetric_difference_update(set2)	求两集合中不重复的元素
set.copy()	拷贝集合
len(set)	返回集合元素个数
max(set)	求集合中元素的最大值
min(set)	求集合中元素的最小值
sum(set)	求集合中元素的加和

字典

• 一个无序的键值对集合，键是唯一的，而值可以重复。
• 字典使用 {} 定义，键（key）和值（value）使用 : 连接，每个键值对之间使用 , 分隔。如{key1 : value1, key2 : value2}
• 字典没有索引。
• 字典可以通过键来获取对应的值。
• 值可以取任何数据类型，但键必须是不可变的，如字符串、数字、元组。

创建字典

# 创建字典
dict1 = {}
dict2 = dict()

print(dict1, type(dict1))  # {} <class 'dict'>
print(dict2, type(dict2))  # {} <class 'dict'>
dict3 = {"name": "Jason", "age": 18, "gender": "male"}
dict4 = dict(name="Jason", age=18, gender="male")
dict5 = dict([("name", "Jason"), ("age", 18), ("gender", "male")])
# {'name': 'Jason', 'age': 18, 'gender': 'male'}
print(dict3)
print(dict4)
print(dict5)

# 推导式创建
dict6 = {
    x: x for x in range(0, 10)
}  # {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
print(dict6)

字典的常用操作

可通过 [] 访问字典中的元素。key不存在时会报错。

# 访问字典
dict1 = {"name": "Jason", "age": 18, "gender": "male"}

print(dict1["name"])  # Jason
print(dict1["age"])  # 18
print(dict1["gender"])  # male
# print(dict1["job"])  # 报错KeyError: 'job'
print("-" * 20)

# 使用get()函数获取对应的元素
print(dict1.get("name"))  # Jason
print(dict1.get("age"))  # 18
print(dict1.get("gender"))  # male

print(dict1.get("job"))  # key不存在时会返回None
print(dict1.get("job", "programmer"))  # key不存在时,可以指定默认值

print("-"*20)

# 添加和修改字典

dict2 = {"name": "Jason", "age": 18, "gender": "male"}

# 为字典指定的key赋值value，若key原本不存在则会被添加。

dict2["job"] = "programmer"

print(dict2)  # {'name': 'Jason', 'age': 18, 'gender': 'male', 'job': 'programmer'}

# 通过key修改对应的value。

dict2["name"] = "Bob"
print(dict2)  # {'name': 'Bob', 'age': 18, 'gender': 'male', 'job': 'programmer'}
print("-" * 20)


# 成员检测
# 只能检测key值，value检测不到
print("name" in dict2)  # True
print(18 in dict2)  # False

print("-" * 20)

# 获取字典的长度
print(len(dict2))  # 4

print("-" * 20)
dict3 = {"name": "Jason", "age": 18, "gender": "male"}
# 遍历所有的key
keys = dict3.keys()
print(keys)  # dict_keys(['name', 'age', 'gender'])
for k in keys:
    print(k)
# 遍历所有的value
values = dict3.values()
print(values)  # dict_values(['Jason', 18, 'male'])
for v in values:
    print(v)
# k-v遍历
keys1 = dict3.keys()
for k in keys:
    print(f"{k}---{dict3[k]}")

kv = dict3.items()
"""
('name', 'Jason')<class 'dict_items'>
('age', 18)<class 'dict_items'>
('gender', 'male')<class 'dict_items'>
"""
for i in kv:
    print(i, type(kv))

print("-" * 20)

dict4 = {"name": "Jason", "age": 18, "gender": "male"}

del dict4["name"]

print(dict4)  # {'age': 18, 'gender': 'male'}
dict4.clear()
print(dict4)  # {}
del dict4  # 删除字典
# print(dict4)  # 报错 #name 'dict4' is not defined.

字典的常用函数

函数	说明
del dict[key]	根据 key 删除键值对
dict.pop(key[, default])	获取 key 所对应的 value，同时删除该键值对，可设置默认值
dict.popitem()	取出字典中的最后插入的键值对，字典为空则报错
dict.clear()	清空字典
dict1.update(dict2)	将 dict2 中的键值对更新到 dict1 中
dict.get(key[, default])	获取字典中 key 对应 value，可设置默认值
dict.setdefault(key[, default])	获取字典中 key 对应 value，可设置默认值。若 key 不存在于字典中，将会添加 key 并将 value 设为默认值
dict.keys()	获取字典所有的 key，返回一个视图对象。字典改变，视图也会跟着变化
dict.values()	获取字典所有的 value，返回一个视图对象
dict.items()	获取字典所有的 (key, value)，返回一个视图对象
dict.copy()	拷贝字典
dict.fromkeys(seq[, default])	以序列 seq 中元素做字典的 key 创建一个新字典，可设置 value 的默认值

列表、元组、字典和集合的区别

可变性：
列表和字典可变，元组不可变
集合可变但元素不可变
重复性：
列表和元组允许重复元素
字典键不可重复，值可重复
集合元素不可重复
有序性：
列表和元组有序
Python 3.7+字典保持插入顺序
集合无序
定义符号：
列表：[]或list()
元组：()或tuple()
字典：{}或dict()
集合：{}或set()