列表
列表(List)是Python中最常用的数据结构之一,它是一个可变的、有序的元素集合。
1. 列表的创建
1.1 使用方括号创建
最常见的创建列表的方式是使用方括号:
代码语言：javascript复制list1 = [1, 2, 3, 4, 5]
list2 = ['a', 'b', 'c']
list3 = [1, 'hello', 3.14, True]
1.2 使用list()函数
可以使用list()函数将其他可迭代对象转换为列表:
代码语言：javascript复制tuple1 = (1, 2, 3)
list4 = list(tuple1)
string1 = "hello"
list5 = list(string1) # ['h', 'e', 'l', 'l', 'o']
1.3 列表推导式
列表推导式提供了一种简洁的方式来创建列表:
代码语言：javascript复制squares = [x**2 for x in range(10)]
2. 访问列表元素
2.1 索引访问
使用索引可以访问列表中的单个元素:
代码语言：javascript复制list1 = [10, 20, 30, 40, 50]
print(list1[0]) # 输出: 10
print(list1[-1]) # 输出: 50
2.2 切片
可以使用切片操作来访问列表的一部分:
代码语言：javascript复制list1 = [10, 20, 30, 40, 50]
print(list1[1:3]) # 输出: [20, 30]
print(list1[:3]) # 输出: [10, 20, 30]
print(list1[2:]) # 输出: [30, 40, 50]
print(list1[::2]) # 输出: [10, 30, 50]
3. 列表操作
3.1 添加元素
- append(): 在列表末尾添加一个元素
- insert(): 在指定位置插入一个元素
- extend(): 将一个列表的所有元素添加到另一个列表末尾
list1 = [1, 2, 3]
list1.append(4)
list1.insert(0, 0)
list1.extend([5, 6])
print(list1) # 输出: [0, 1, 2, 3, 4, 5, 6]
3.2 删除元素
- remove(): 删除第一个匹配的元素
- pop(): 删除并返回指定位置的元素
- del: 删除指定位置的元素或切片
list1 = [1, 2, 3, 2, 4]
list1.remove(2)
popped = list1.pop(1)
del list1[0]
print(list1) # 输出: [2, 4]
3.3 修改元素
可以直接通过索引修改列表元素:
代码语言：javascript复制list1 = [1, 2, 3]
list1[1] = 20
print(list1) # 输出: [1, 20, 3]
3.4 列表连接和重复
使用 运算符连接列表,使用*运算符重复列表:
代码语言：javascript复制list1 = [1, 2]
list2 = [3, 4]
list3 = list1 list2
list4 = list1 * 3
print(list3) # 输出: [1, 2, 3, 4]
print(list4) # 输出: [1, 2, 1, 2, 1, 2]
4. 列表方法
Python列表提供了多种内置方法:
- sort(): 对列表进行排序
- reverse(): 反转列表
- count(): 计算元素在列表中出现的次数
- index(): 返回元素在列表中的索引
- clear(): 清空列表
list1 = [3, 1, 4, 1, 5, 9, 2]
list1.sort()
print(list1) # 输出: [1, 1, 2, 3, 4, 5, 9]
list1.reverse()
print(list1) # 输出: [9, 5, 4, 3, 2, 1, 1]
print(list1.count(1)) # 输出: 2
print(list1.index(4)) # 输出: 2
list1.clear()
print(list1) # 输出: []
5. 列表解包
可以将列表中的元素解包到多个变量中:
代码语言：javascript复制list1 = [1, 2, 3]
a, b, c = list1
print(a, b, c) # 输出: 1 2 3
# 使用*解包剩余元素
list2 = [1, 2, 3, 4, 5]
first, *middle, last = list2
print(first, middle, last) # 输出: 1 [2, 3, 4] 5
6. 列表推导式和生成器表达式
6.1 列表推导式
列表推导式提供了一种简洁的方式来创建列表:
代码语言：javascript复制squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]
6.2 生成器表达式
生成器表达式类似于列表推导式,但它们返回一个生成器对象:
代码语言：javascript复制gen = (x**2 for x in range(10))
7. 列表的应用
7.1 栈和队列
列表可以用作栈(后进先出)或队列(先进先出):
代码语言：javascript复制# 栈
stack = []
stack.append(1)
stack.append(2)
print(stack.pop()) # 输出: 2
# 队列
from collections import deque
queue = deque([])
queue.append(1)
queue.append(2)
print(queue.popleft()) # 输出: 1
7.2 矩阵
列表的列表可以表示矩阵:
代码语言：javascript复制matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
print(matrix[1][1]) # 输出: 5
8. 列表的性能考虑
- 在列表末尾添加或删除元素(append, pop)的时间复杂度为O(1)
- 在列表开头或中间插入或删除元素(insert, pop, del)的时间复杂度为O(n)
- 访问元素的时间复杂度为O(1)
- 搜索元素的时间复杂度为O(n)
对于大量数据或频繁的插入/删除操作,可能需要考虑使用其他数据结构,如deque。
元组
元组(tuple)是Python中的一种基本数据结构,与列表类似,但元组是不可变的。虽然它们看似简单,但在适当的场景下使用元组可以带来诸多好处,如提高代码的可读性和执行效率。
1. 元组的创建
1.1 使用圆括号创建
最常见的创建元组的方式是使用圆括号:
代码语言：javascript复制tup1 = (1, 2, 3)
tup2 = ('a', 'b', 'c')
1.2 不使用圆括号
Python也允许省略圆括号来创建元组:
代码语言：javascript复制tup3 = 1, 2, 3
tup4 = 'a', 'b', 'c'
1.3 使用tuple()函数
可以使用tuple()函数将其他可迭代对象转换为元组:
代码语言：javascript复制list1 = [1, 2, 3]
tup5 = tuple(list1)
1.4 创建单元素元组
创建只包含一个元素的元组时,需要在元素后加一个逗号:
代码语言：javascript复制tup6 = (42,) # 正确
tup7 = (42) # 错误,这是一个整数
2. 访问元组元素
2.1 索引访问
使用索引可以访问元组中的单个元素:
代码语言：javascript复制tup = (1, 2, 3, 4, 5)
print(tup[0]) # 输出: 1
print(tup[-1]) # 输出: 5
2.2 切片
可以使用切片操作来访问元组的一部分:
代码语言：javascript复制tup = (1, 2, 3, 4, 5)
print(tup[1:3]) # 输出: (2, 3)
print(tup[:3]) # 输出: (1, 2, 3)
print(tup[2:]) # 输出: (3, 4, 5)
3. 元组操作
3.1 连接
可以使用 运算符连接两个或多个元组:
代码语言：javascript复制tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
tup3 = tup1 tup2
print(tup3) # 输出: (1, 2, 3, 4, 5, 6)
3.2 重复
使用*运算符可以重复元组:
代码语言：javascript复制tup = (1, 2) * 3
print(tup) # 输出: (1, 2, 1, 2, 1, 2)
3.3 解包
可以将元组中的元素解包到多个变量中:
代码语言：javascript复制tup = (1, 2, 3)
a, b, c = tup
print(a, b, c) # 输出: 1 2 3
4. 元组方法
虽然元组是不可变的,但它们仍然有一些内置方法:
4.1 count()
返回指定元素在元组中出现的次数:
代码语言：javascript复制tup = (1, 2, 2, 3, 2)
print(tup.count(2)) # 输出: 3
4.2 index()
返回指定元素在元组中首次出现的索引:
代码语言：javascript复制tup = (1, 2, 3, 2)
print(tup.index(2)) # 输出: 1
5. 元组的不可变性
元组的一个关键特性是不可变性。这意味着一旦创建,就不能修改元组的内容:
代码语言：javascript复制tup = (1, 2, 3)
# tup[0] = 4 # 这会引发TypeError
然而,如果元组包含可变对象(如列表),这些对象的内容可以被修改:
代码语言：javascript复制tup = ([1, 2], [3, 4])
tup[0][0] = 5
print(tup) # 输出: ([5, 2], [3, 4])
6. 元组的应用
6.1 返回多个值
函数可以使用元组来返回多个值:
代码语言：javascript复制def get_coordinates():
return (10, 20)
x, y = get_coordinates()
6.2 字典键
元组可以作为字典的键,而列表不行:
代码语言：javascript复制dict1 = {(1, 2): 'value'}
6.3 数据保护
由于元组是不可变的,它们可以用来存储不应被修改的数据:
代码语言：javascript复制DAYS = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')
7. 元组与列表的比较
元组和列表有很多相似之处,但也有一些关键区别:
- 不可变性: 元组是不可变的,列表是可变的。
- 语法: 元组使用圆括号,列表使用方括号。
- 性能: 元组通常比列表快,因为它们是不可变的。
- 用途: 元组通常用于异构数据,列表用于同类数据。
字典
字典是Python中最有用和最灵活的数据结构之一。它允许我们存储键值对,并通过键快速访问、修改或删除值。本文将全面介绍Python字典的创建、基本操作、高级技巧以及最佳实践。
1. 字典的创建
在Python中创建字典有多种方法:
代码语言：javascript复制# 使用花括号
dict1 = {'name': 'Alice', 'age': 25}
# 使用dict()函数
dict2 = dict(name='Bob', age=30)
# 使用列表的键值对
dict3 = dict([('name', 'Charlie'), ('age', 35)])
# 使用字典推导式
dict4 = {x: x**2 for x in range(5)}
2. 基本操作
2.1 访问元素
代码语言：javascript复制my_dict = {'name': 'David', 'age': 40}
# 使用键访问值
print(my_dict['name']) # 输出: David
# 使用get()方法(推荐,因为它可以提供默认值)
print(my_dict.get('age', 0)) # 输出: 40
print(my_dict.get('height', 180)) # 输出: 180 (默认值)
2.2 修改和添加元素
代码语言：javascript复制my_dict = {'name': 'Eva', 'age': 45}
# 修改现有键的值
my_dict['age'] = 46
# 添加新的键值对
my_dict['city'] = 'New York'
print(my_dict) # 输出: {'name': 'Eva', 'age': 46, 'city': 'New York'}
2.3 删除元素
代码语言：javascript复制my_dict = {'name': 'Frank', 'age': 50, 'city': 'Paris'}
# 使用del关键字
del my_dict['age']
# 使用pop()方法
city = my_dict.pop('city')
# 删除并返回最后插入的项
last_item = my_dict.popitem()
print(my_dict) # 输出: {}
3. 字典方法
Python字典提供了多种有用的方法:
代码语言：javascript复制my_dict = {'a': 1, 'b': 2, 'c': 3}
# keys(), values(), items()
print(my_dict.keys()) # 输出: dict_keys(['a', 'b', 'c'])
print(my_dict.values()) # 输出: dict_values([1, 2, 3])
print(my_dict.items()) # 输出: dict_items([('a', 1), ('b', 2), ('c', 3)])
# clear()
my_dict.clear()
print(my_dict) # 输出: {}
# copy() - 浅拷贝
original = {'x': 1, 'y': 2}
copied = original.copy()
# update()
original.update({'z': 3, 'y': 20})
print(original) # 输出: {'x': 1, 'y': 20, 'z': 3}
4. 高级操作和技巧
4.1 合并字典
在Python 3.5 中,我们可以使用**操作符来合并字典:
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged = {**dict1, **dict2}
print(merged) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
4.2 默认字典
defaultdict是dict的一个子类,它可以为不存在的键提供默认值:
from collections import defaultdict
dd = defaultdict(list)
dd['fruits'].append('apple')
dd['fruits'].append('banana')
print(dd) # 输出: defaultdict(<class 'list'>, {'fruits': ['apple', 'banana']})
4.3 有序字典
从Python 3.7开始,常规字典保留了插入顺序。但对于更早的版本,我们可以使用OrderedDict:
from collections import OrderedDict
od = OrderedDict()
od['first'] = 1
od['second'] = 2
od['third'] = 3
print(od) # 输出: OrderedDict([('first', 1), ('second', 2), ('third', 3)])
4.4 字典推导式
字典推导式提供了一种简洁的方式来创建字典:
代码语言：javascript复制squares = {x: x**2 for x in range(6)}
print(squares) # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 条件字典推导式
even_squares = {x: x**2 for x in range(6) if x % 2 == 0}
print(even_squares) # 输出: {0: 0, 2: 4, 4: 16}
5. 最佳实践和性能考虑
使用in操作符检查键是否存在:
if 'key' in my_dict:
# 处理键存在的情况
使用dict.get()方法安全地获取值,避免KeyError:
value = my_dict.get('key', default_value)
对于大型字典,使用items()方法进行迭代更高效:
for key, value in my_dict.items():
# 处理键值对
使用collections.Counter快速计数:
from collections import Counter
my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
count_dict = Counter(my_list)
print(count_dict) # 输出: Counter({4: 4, 3: 3, 2: 2, 1: 1})
对于需要频繁修改的大型字典,考虑使用collections.defaultdict或collections.Counter以提高性能。
