数据结构

列表详解

1. list.append(x)：向列表末尾添加一项
2. list.extend(iterable)：通过添加来自iterable中的所有项来扩展列表。
3. list.insert(i, x)：在索引 i 位置插入项 x。
4. list.remove(x)：删除列表中第一个值为 x 的项。如果没有这样的项，将引发 ValueError 异常。
5. list.pop([i])：删除索引 i 位置的项，并 返回该项。如果未指定索引，将删除并返回列表的最后一项。
6. list.clear()：删除列表中的所有项。
7. list.index(x[, start[, end]])：返回列表中第一个值为 x 的项的索引。如果没有这样的项，将引发 ValueError 异常。start和end为可选参数，用于指定搜索的范围。
8. list.count(x)：返回列表中值为 x 的项的数量。
9. list.sort(*, key=None, reverse=False)：对列表中的项进行排序。
10. list.reverse()：将列表中的项反转。
11. list.copy()：返回列表的浅拷贝。

# 列表

ages = [1, 2, 3, 4, 5]
counts = [12, 32, 11]

ages.append(6)
print("append：向列表末尾添加元素", ages)
ages.extend(counts)
print("extend：融合其他列表", ages)
ages.insert(1, 10)
print("insert：在指定索引位置插入元素", ages)
ages.remove(1)
print("remove：移除指定元素", ages)
ages.pop()  # 未指定位置时，移出最后一位
print("pop：移除最后一位", ages)
firstIndex = ages.index(4, 2)  # 返回元素第一次出现的索引，也可从指定位置开始
print("index：返回查询的元素第一次出现索引：", firstIndex)
numberCount = ages.count(2)
print("count：查询元素出现的次数", numberCount)
ages.sort()  # 排序列表元素
print("sort：排序列表，默认从小到大", ages)
ages.reverse()  # 反转列表元素
print("reverse：反转数组", ages)
agesCopy = ages.copy()
print("copy：浅拷贝列表", agesCopy)
ages.clear()
print("clear：清空列表", ages)

del 语句

del语句用于删除列表中的项或变量。

# del语句
ages = [1, 2, 3, 4, 5]
print("删除索引为2的元素：", ages)
del ages[2]
print(ages)

# 删除整个变量
del ages
print("删除整个变量ages：", ages) # 此时会报错，提示ages未定义

元组和序列

元组是不可变的序列，通常用于存储不同类型的元素。

# 元组：由多个用逗号隔开的值组成，元组不可变。
t = 1, True, "时游"
print(t)  # (1, True, '时游')

# 嵌套元组
u = t, (111, 222)
print(u)  # ((1, True, '时游'), (111, 222))

# 元组不可变
# u[0] = 111  TypeError: 'tuple' object does not support item assignment

# 序列解包：序列解包时，左侧数量应当和右侧一致
a, b, c = t
print(a, b, c) # 1 True 时游

集合

集合是无序的、不重复的元素集合。

# 集合：不重复元素组成的无序多项集，基本用法包括成员检测和消除重复元素。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)  # 自动移除重复项 {'pear', 'orange', 'banana', 'apple'}

# 交、并、差
a = set('abracadabra')
b = set('alacazam')
diffA = a - b  # 存在于 a 中但不存在于 b 中的字母
print("a中存在，b中不存在：", diffA)  # {'r', 'd', 'b'}
both = a | b
print("a和b中元素合集(去重后)：", both)  # {'m', 'r', 'l', 'a', 'z', 'c', 'b', 'd'}
same = a & b
print("a和b中同时存在：", same)  # {'a', 'c'}

字典

# 字典：键值对组合

person = {
    "name": "时游",
    "age": 28,
    "country": "CN"
}

print(person)  # {'name': '时游', 'age': 28, 'country': 'CN'}

# 查询
print(person.get("name"))  # 时游

# 修改值
person["age"] = 30  # {'name': '时游', 'age': 30, 'country': 'CN'}
print(person)

# 删除
del person["age"]
print(person)  # {'name': '时游', 'country': 'CN'}

# 返回键列表：返回该字典中所有键的列表
personList = list(person)
print(personList)  # ['name', 'country']

# 判断键是否存在
print('age' in person)  # False

# 循环
for key, v in person.items():
    print(key, v)  # name 时游、 country CN

循环技巧

# 循环

# 字典循环
knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

# 列表循环，同时取出索引
for i, v in enumerate(['tic', 'tac', 'toe']):
    print(i, v)

# 同时循环多个列表，使用zip函数
questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('What is your {0}?  It is {1}.'.format(q, a))

深拷贝与浅拷贝

拷贝（copy）与深拷贝（deepcopy）的区别在于：浅拷贝只复制容器本身，不复制容器中的子对象；深拷贝会连同子对象一起复制，两者完全独立。

import copy

src = [1, 2, [3, 4]]

# 浅拷贝：内外两层对象不同，但内层的子对象仍然是同一个引用
shallow = copy.copy(src)
shallow[2].append(5)
print("src：", src)  # [1, 2, [3, 4, 5]]，源数据的子对象也被修改了

# 深拷贝：递归复制所有层级，完全独立
deep = copy.deepcopy(src)
deep[2].append(6)
print("src：", src)  # [1, 2, [3, 4, 5]]，源数据不受影响
print("deep：", deep)  # [1, 2, [3, 4, 5, 6]]