Python 知识点详解（二）

五、复合数据类型

1. 列表（list）

列表是有序、可变的元素集合，用方括号[]表示，元素类型可以混合。

# 定义一个包含多种类型元素的列表
my_list = [1, 2, 'a', True, 3.14]
print(my_list)  # 输出：[1, 2, 'a', True, 3.14]
# 索引操作：通过索引获取元素（索引从0开始）
print(my_list[2])  # 输出：'a'，获取第三个元素
print(my_list[-1])  # 输出：3.14，负索引表示从末尾开始，-1为最后一个元素
# 切片操作：获取子列表，语法为list[start:end:step]，包含start，不包含end
print(my_list[1:4])  # 输出：[2, 'a', True]，从索引1到3（不包含4）
print(my_list[::2])  # 输出：[1, 'a', 3.14]，步长为2，间隔一个元素取一次
# 添加元素
my_list.append(5)  # 在列表末尾添加元素5
print(my_list)  # 输出：[1, 2, 'a', True, 3.14, 5]
my_list.insert(2, 'new')  # 在索引2处插入元素'new'
print(my_list)  # 输出：[1, 2, 'new', 'a', True, 3.14, 5]
# 删除元素
my_list.remove('a')  # 删除第一个值为'a'的元素
print(my_list)  # 输出：[1, 2, 'new', True, 3.14, 5]
removed_element = my_list.pop(3)  # 删除索引3处的元素，并返回该元素
print(removed_element)  # 输出：True
print(my_list)  # 输出：[1, 2, 'new', 3.14, 5]
# 其他操作
print(len(my_list))  # 输出：5，获取列表长度
my_list.sort()  # 对列表进行排序（注意：元素类型需一致才能排序，这里先处理为数字列表）
my_list = [1, 5, 3, 2]
my_list.sort()
print(my_list)  # 输出：[1, 2, 3, 5]
my_list.reverse()  # 反转列表
print(my_list)  # 输出：[5, 3, 2, 1]

2. 元组（tuple）

元组是有序、不可变的元素集合，用圆括号()表示。

# 定义元组
tup1 = (1, 'b', 3.14)
tup2 = (5,)  # 单个元素的元组必须加逗号，否则会被视为其他类型
print(tup1)  # 输出：(1, 'b', 3.14)
print(type(tup2))  # 输出：<class 'tuple'>
# 索引与切片（同列表）
print(tup1[1])  # 输出：'b'
print(tup1[0:2])  # 输出：(1, 'b')
# 拼接操作
tup3 = tup1 + tup2
print(tup3)  # 输出：(1, 'b', 3.14, 5)
# 元组不可修改，以下操作会报错
# tup1[0] = 2  # 报错：'tuple' object does not support item assignment

3. 字典（dict）

字典是由键值对组成的集合，用花括号{}表示，键需唯一且为不可变类型。

# 定义字典
info = {'name': 'Alice', 'age': 20, 'gender': 'female'}
print(info)  # 输出：{'name': 'Alice', 'age': 20, 'gender': 'female'}
# 访问值
print(info['name'])  # 输出：Alice，通过键访问值
print(info.get('age', 0))  # 输出：20，get方法，键不存在时返回默认值0
print(info.get('height', 160))  # 输出：160，键'height'不存在，返回默认值
# 添加/修改键值对
info['height'] = 165  # 添加新键值对
print(info)  # 输出：{'name': 'Alice', 'age': 20, 'gender': 'female', 'height': 165}
info['age'] = 21  # 修改已有键的值
print(info)  # 输出：{'name': 'Alice', 'age': 21, 'gender': 'female', 'height': 165}
# 删除操作
del info['gender']  # 删除指定键值对
print(info)  # 输出：{'name': 'Alice', 'age': 21, 'height': 165}
# info.clear()  # 清空字典，执行后info变为{}
# 视图操作
print(info.keys())  # 输出：dict_keys(['name', 'age', 'height'])，获取所有键
print(info.values())  # 输出：dict_values(['Alice', 21, 165])，获取所有值
print(info.items())  # 输出：dict_items([('name', 'Alice'), ('age', 21), ('height', 165)])，获取所有键值对

4. 集合（set）

集合是无序、无重复元素的集合，用花括号{}或set()创建。

# 定义集合
set1 = {1, 2, 3, 3}  # 自动去重
set2 = set([3, 4, 5, 5])
print(set1)  # 输出：{1, 2, 3}
print(set2)  # 输出：{3, 4, 5}
# 添加元素
set1.add(4)  # 添加单个元素
print(set1)  # 输出：{1, 2, 3, 4}
set1.update([5, 6])  # 添加多个元素
print(set1)  # 输出：{1, 2, 3, 4, 5, 6}
# 删除元素
set1.remove(3)  # 删除元素3
print(set1)  # 输出：{1, 2, 4, 5, 6}
set1.discard(7)  # 删除元素7，元素不存在也不报错
print(set1)  # 输出：{1, 2, 4, 5, 6}
# 集合运算
a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # 输出：{1, 2, 3, 4, 5}，并集
print(a & b)  # 输出：{3}，交集
print(a - b)  # 输出：{1, 2}，差集（a中有b中没有的元素）
print(a ^ b)  # 输出：{1, 2, 4, 5}，对称差集（a和b中不重复的元素）

六、函数进阶

1. 匿名函数（lambda）

用lambda关键字定义，适用于简单逻辑的函数。

# 定义匿名函数，实现两数相加
add = lambda a, b: a + b
result = add(2, 3)
print(result)  # 输出：5
# 匿名函数作为参数使用
numbers = [(1, 3), (4, 1), (2, 5)]
# 按元组中第二个元素排序
numbers.sort(key=lambda x: x[1])
print(numbers)  # 输出：[(4, 1), (1, 3), (2, 5)]

2. 高阶函数

接收函数作为参数或返回函数的函数。

# map()函数：对可迭代对象的每个元素应用函数
numbers = [1, 2, 3, 4]
# 将每个元素乘以2
mapped = map(lambda x: x * 2, numbers)
print(list(mapped))  # 输出：[2, 4, 6, 8]
# filter()函数：筛选出满足条件的元素
# 筛选出偶数
filtered = filter(lambda x: x % 2 == 0, numbers)
print(list(filtered))  # 输出：[2, 4]
# reduce()函数：对可迭代对象累积应用函数（需导入functools模块）
from functools import reduce
# 计算列表中所有元素的和
sum_result = reduce(lambda x, y: x + y, numbers, 0)  # 0为初始值
print(sum_result)  # 输出：10

3. 装饰器（decorator）

在不修改原函数代码的前提下扩展函数功能。

# 定义装饰器函数，用于打印函数调用信息
def log(func):
    # 定义包装函数，*args和**kwargs用于接收任意参数
    def wrapper(*args, **kwargs):
        print(f"调用函数：{func.__name__}")  # 打印函数名
        return func(*args, **kwargs)  # 调用原函数并返回结果
    return wrapper
# 使用装饰器
@log
def add(a, b):
    return a + b
# 调用被装饰的函数
result = add(2, 3)
# 先打印"调用函数：add"，再返回结果5
print(result)  # 输出：5

4. 递归函数

函数自身调用自身，需有终止条件。

# 计算阶乘的递归函数
def factorial(n):
    # 终止条件：n为1时返回1
    if n == 1:
        return 1
    # 递归调用：n! = n * (n-1)!
    return n * factorial(n - 1)
result = factorial(5)  # 计算5! = 5*4*3*2*1
print(result)  # 输出：120

七、模块与包

1. 模块（module）

一个.py文件就是一个模块，可包含函数、类、变量等。

# 导入整个模块
import math
# 使用模块中的函数
print(math.sqrt(16))  # 输出：4.0，计算平方根
# 从模块中导入指定成员
from math import pi
print(pi)  # 输出：3.141592653589793
# 导入模块并指定别名
import datetime as dt
# 使用别名调用模块中的类和方法
current_time = dt.datetime.now()
print(current_time)  # 输出当前时间，如：2023-10-01 12:00:00.123456

2. 包（package）

包含多个模块的目录，需包含init.py文件。

# 假设存在包mypackage，其中包含模块mymodule，模块中有函数myfunc
# 导入方式
from mypackage.mymodule import myfunc
# 调用函数
myfunc()

3. 常用标准库

# os模块：处理文件和目录
import os
# 判断路径是否存在
path = "test.txt"
print(os.path.exists(path))  # 输出：False（若文件不存在）
# datetime模块：处理日期时间
from datetime import datetime
# 获取当前时间
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 格式化输出：2023-10-01 12:00:00
# json模块：处理JSON数据
import json
# 将字典转为JSON字符串
data = {'name': 'Alice', 'age': 20}
json_str = json.dumps(data)
print(json_str)  # 输出：{"name": "Alice", "age": 20}
# 将JSON字符串转为字典
data2 = json.loads(json_str)
print(data2['name'])  # 输出：Alice

八、文件操作

1. 文件打开与关闭

使用open()函数打开文件，with语句可自动关闭文件。

# 使用with语句打开文件，自动关闭
with open('file.txt', 'w', encoding='utf-8') as f:
    f.write('Hello, World!')  # 写入内容
# 读取文件内容
with open('file.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)  # 输出：Hello, World!

2. 文件读写模式及操作

# 写入模式（w）：覆盖原有内容
with open('test.txt', 'w', encoding='utf-8') as f:
    f.write('第一行内容\n')
    f.write('第二行内容\n')
# 追加模式（a）：在文件末尾添加内容
with open('test.txt', 'a', encoding='utf-8') as f:
    f.write('第三行内容\n')
# 读取模式（r）：读取文件
with open('test.txt', 'r', encoding='utf-8') as f:
    # 读取所有内容
    print("读取所有内容：")
    print(f.read())
    # 移动文件指针到开头
    f.seek(0)
    # 读取一行
    print("\n读取一行：")
    print(f.readline())
    # 读取所有行，返回列表
    f.seek(0)
    print("\n读取所有行：")
    print(f.readlines())
# 二进制模式读取图片等文件
# with open('image.jpg', 'rb') as f:
#     image_data = f.read()