Python编程语言核心特性与职业发展指南

1. Python语言概述与职业发展路径

Python作为一门诞生于1991年的编程语言，经过30余年的发展已经成为全球最受欢迎的编程语言之一。根据2023年Stack Overflow开发者调查报告显示，Python在"最常用编程语言"和"最想学习语言"两项排名中都稳居前三。这种持续的热度并非偶然，而是源于Python独特的设计哲学和广泛的应用场景。

1.1 Python的核心优势解析

Python之所以能够吸引如此多的开发者，主要归功于以下几个关键特性：

语法简洁优雅：Python采用缩进来定义代码块，强制保持代码整洁。相比其他语言中常见的大括号和分号，这种设计显著提升了代码可读性。例如实现一个简单的HTTP服务：

python复制from http.server import SimpleHTTPRequestHandler, HTTPServer

def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler):
    server_address = ('', 8000)
    httpd = server_class(server_address, handler_class)
    httpd.serve_forever()

run()

动态类型系统：变量无需声明类型，这使得快速原型开发成为可能。配合强大的类型提示(Type Hints)系统，可以在保持灵活性的同时获得良好的代码维护性。

丰富的标准库：Python自带"电池"(Batteries Included)哲学，标准库涵盖了文件处理(io)、系统操作(os)、网络请求(urllib)、数据压缩(zlib)等常见需求。例如用标准库快速实现文件哈希校验：

python复制import hashlib

def get_file_hash(filename):
    with open(filename, 'rb') as f:
        return hashlib.md5(f.read()).hexdigest()

跨平台兼容性：得益于解释型语言的特性，Python代码可以在Windows、Linux和macOS等不同操作系统上无缝运行，只需安装对应的解释器环境。

强大的生态系统：PyPI(Python Package Index)上托管了超过40万个第三方库，涵盖了从Web开发(Django, Flask)到数据科学(NumPy, Pandas)等各个领域。这种丰富的生态大大降低了开发者的重复造轮子成本。

1.2 Python主要应用领域深度剖析

1.2.1 Web开发与后端服务

Python在Web开发领域有着举足轻重的地位。Django和Flask等框架提供了完整的MVC架构，使得开发复杂的Web应用变得高效。以Django为例，其ORM系统可以让开发者用Python类定义数据库模型，而无需直接编写SQL：

python复制from django.db import models

class Blog(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    
    def __str__(self):
        return self.title

现代云原生架构中，Python也常用于开发微服务。FastAPI等新兴框架利用Python的类型提示和异步特性，可以轻松构建高性能API服务。

1.2.2 数据分析与科学计算

Python在数据科学领域的统治地位主要得益于NumPy、Pandas和Matplotlib这三大支柱：

• NumPy：提供高效的多维数组操作，是许多科学计算库的基础
• Pandas：强大的数据框(DataFrame)处理能力，支持复杂的数据清洗和转换
• Matplotlib：灵活的绘图系统，可生成各种统计图表

一个典型的数据分析工作流可能如下：

python复制import pandas as pd
import matplotlib.pyplot as plt

# 加载数据
df = pd.read_csv('sales_data.csv')

# 数据清洗
df = df.dropna()
df['date'] = pd.to_datetime(df['date'])

# 数据分析
monthly_sales = df.groupby(df['date'].dt.month)['amount'].sum()

# 可视化
monthly_sales.plot(kind='bar')
plt.title('Monthly Sales Report')
plt.show()

1.2.3 机器学习与人工智能

Python是机器学习领域的事实标准语言，这主要得益于：

• Scikit-learn：提供了从数据预处理到模型评估的全套工具
• TensorFlow/PyTorch：两大主流深度学习框架，支持GPU加速计算
• Hugging Face：丰富的预训练模型库，支持自然语言处理等任务

一个简单的图像分类模型训练示例：

python复制import tensorflow as tf
from tensorflow import keras

# 加载数据
(train_images, train_labels), (test_images, test_labels) = keras.datasets.cifar10.load_data()

# 构建模型
model = keras.Sequential([
    keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(32,32,3)),
    keras.layers.MaxPooling2D((2,2)),
    keras.layers.Flatten(),
    keras.layers.Dense(10, activation='softmax')
])

# 训练模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=10)

# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Test accuracy: {test_acc}')

1.2.4 自动化运维与DevOps

Python在运维自动化领域同样表现出色：

• Ansible：基于Python的自动化配置管理工具
• Fabric：简化服务器部署和任务自动化
• Prometheus Client：监控指标采集和上报

一个典型的服务器批量操作脚本：

python复制import paramiko

def execute_remote_command(host, command, username, key_filename):
    client = paramiko.SSHClient()
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    client.connect(host, username=username, key_filename=key_filename)
    
    stdin, stdout, stderr = client.exec_command(command)
    output = stdout.read().decode()
    error = stderr.read().decode()
    
    client.close()
    return output, error

# 批量执行命令
servers = ['server1', 'server2', 'server3']
for server in servers:
    out, err = execute_remote_command(server, 'df -h', 'admin', '~/.ssh/id_rsa')
    print(f"{server} disk usage:\n{out}")

1.3 Python开发者职业发展路径

1.3.1 岗位方向选择建议

后端开发工程师：

• 核心技能：Django/Flask、RESTful API设计、数据库优化
• 发展方向：系统架构师、技术负责人
• 薪资范围：初级15-25k，高级30-50k(一线城市)

数据分析师：

• 核心技能：Pandas、SQL、数据可视化
• 发展方向：数据科学家、商业分析师
• 薪资范围：初级12-20k，高级25-40k

机器学习工程师：

• 核心技能：TensorFlow/PyTorch、特征工程、模型调优
• 发展方向：AI算法专家、研究科学家
• 薪资范围：初级20-30k，高级40-80k

职业选择建议：初学者应从基础开发岗位入手，积累2-3年经验后再根据兴趣选择细分方向。数据科学虽然热门，但需要扎实的数学和统计学基础，不适合所有开发者。

1.3.2 技能成长路线图

初级阶段(0-1年)：

• 掌握Python基础语法和常用标准库
• 熟悉至少一个Web框架(Django/Flask)
• 了解基本的数据库操作(SQL/NoSQL)

中级阶段(1-3年)：

• 深入理解设计模式和软件架构
• 掌握性能优化和调试技巧
• 学习分布式系统设计

高级阶段(3-5年)：

• 精通特定领域的深度知识(如机器学习/高并发)
• 具备技术选型和架构设计能力
• 培养团队管理和项目规划能力

1.3.3 学习资源推荐

在线课程：

• Coursera: "Python for Everybody" (适合零基础)
• edX: "Introduction to Computer Science and Programming Using Python" (MIT出品)
• Udemy: "Complete Python Bootcamp" (实战导向)

书籍推荐：

• 《Python Crash Course》 (入门首选)
• 《Fluent Python》 (深入理解Python特性)
• 《Python Cookbook》 (实用技巧合集)

实践平台：

• LeetCode (算法练习)
• Kaggle (数据科学竞赛)
• Real Python (教程和文章)

2. Python语言基础精要

2.1 开发环境配置详解

2.1.1 Python解释器安装

Windows系统：

1. 访问Python官网下载最新稳定版
2. 安装时勾选"Add Python to PATH"选项
3. 验证安装：python --version

macOS系统：

bash复制# 推荐使用Homebrew安装
brew install python

# 验证安装
python3 --version

Linux系统：

bash复制# Ubuntu/Debian
sudo apt update
sudo apt install python3 python3-pip

# CentOS/RHEL
sudo yum install python3 python3-pip

2.1.2 虚拟环境管理

Python项目强烈建议使用虚拟环境隔离依赖：

bash复制# 创建虚拟环境
python -m venv myenv

# 激活环境
# Windows
myenv\Scripts\activate
# Unix/macOS
source myenv/bin/activate

# 安装包
pip install package_name

# 导出依赖
pip freeze > requirements.txt

# 退出环境
deactivate

2.1.3 开发工具选择

VS Code：

• 轻量级且功能强大
• 安装Python扩展后支持智能提示、调试等功能
• 集成终端和Git支持

PyCharm：

• 专业Python IDE
• 强大的代码分析和重构工具
• 支持Django等框架的深度集成

Jupyter Notebook：

• 交互式编程环境
• 适合数据分析和教学
• 支持Markdown和可视化输出

2.2 基础语法核心要点

2.2.1 变量与数据类型

Python是动态类型语言，但理解类型系统至关重要：

python复制# 基本类型
integer = 42          # 整型
floating = 3.14       # 浮点型
boolean = True        # 布尔型
string = "hello"      # 字符串
none_value = None     # 空值

# 类型转换
str(42)               # "42"
int("100")            # 100
float("3.14")         # 3.14
bool(1)               # True

# 类型检查
isinstance(42, int)   # True

2.2.2 运算符详解

算术运算符：

python复制10 + 3   # 13
10 - 3   # 7
10 * 3   # 30
10 / 3   # 3.333...
10 // 3  # 3 (整除)
10 % 3   # 1 (取模)
10 ** 3  # 1000 (幂运算)

比较运算符：

python复制10 == 10  # True
10 != 5   # True
10 > 5    # True
10 < 5    # False
10 >= 10  # True

逻辑运算符：

python复制True and False  # False
True or False   # True
not True        # False

2.2.3 控制结构

条件语句：

python复制age = 18

if age < 13:
    print("Child")
elif 13 <= age < 18:
    print("Teenager")
else:
    print("Adult")

循环结构：

python复制# for循环
for i in range(5):
    print(i)

# while循环
count = 0
while count < 5:
    print(count)
    count += 1

# 循环控制
for i in range(10):
    if i == 3:
        continue  # 跳过本次循环
    if i == 7:
        break     # 终止循环
    print(i)

2.3 函数编程基础

2.3.1 函数定义与调用

python复制def greet(name, greeting="Hello"):
    """返回问候语
    
    Args:
        name: 要问候的人名
        greeting: 问候语，默认为'Hello'
    
    Returns:
        拼接后的问候字符串
    """
    return f"{greeting}, {name}!"

# 调用函数
message = greet("Alice")
print(message)  # "Hello, Alice!"

# 使用关键字参数
greet(greeting="Hi", name="Bob")

2.3.2 参数传递机制

Python参数传递是"对象引用传递"，理解这一点至关重要：

python复制def modify_list(lst):
    lst.append(4)
    
my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # [1, 2, 3, 4]

def reassign_list(lst):
    lst = [7, 8, 9]
    
reassign_list(my_list)
print(my_list)  # 仍然是[1, 2, 3, 4]

2.3.3 变量作用域

python复制global_var = "I'm global"

def scope_test():
    local_var = "I'm local"
    print(global_var)  # 可以访问全局变量
    
    def inner_func():
        nonlocal local_var  # 声明使用外层函数的变量
        local_var = "Modified"
        
    inner_func()
    print(local_var)

scope_test()
print(global_var)
# print(local_var)  # 报错，局部变量不可访问

2.4 异常处理机制

健壮的程序需要妥善处理异常：

python复制try:
    result = 10 / 0
except ZeroDivisionError:
    print("不能除以零!")
except (TypeError, ValueError) as e:
    print(f"类型或值错误: {e}")
except Exception as e:
    print(f"未知错误: {e}")
else:
    print("没有发生异常")
finally:
    print("无论是否异常都会执行")

# 自定义异常
class MyError(Exception):
    pass

def check_value(value):
    if value < 0:
        raise MyError("值不能为负")
        
try:
    check_value(-5)
except MyError as e:
    print(f"捕获自定义异常: {e}")

3. Python数据结构深度解析

3.1 列表(List)全面掌握

3.1.1 列表创建与基本操作

python复制# 创建列表
empty_list = []
numbers = [1, 2, 3, 4, 5]
mixed = [1, "two", 3.0, [4, 5]]

# 访问元素
first = numbers[0]     # 1
last = numbers[-1]     # 5
sublist = numbers[1:4] # [2, 3, 4]

# 修改元素
numbers[0] = 10        # [10, 2, 3, 4, 5]

# 列表运算
combined = numbers + [6, 7]  # 连接
repeated = [0] * 3     # [0, 0, 0]

3.1.2 列表方法详解

python复制# 添加元素
numbers.append(6)      # 末尾添加
numbers.insert(1, 1.5) # 指定位置插入

# 删除元素
popped = numbers.pop() # 移除并返回最后一个元素
removed = numbers.pop(1) # 移除指定位置元素
numbers.remove(3)      # 移除第一个匹配的元素

# 其他操作
numbers.reverse()      # 反转列表
numbers.sort()         # 排序
count = numbers.count(2) # 计数
index = numbers.index(4) # 查找索引

3.1.3 列表生成式

python复制# 基本形式
squares = [x**2 for x in range(10)]

# 带条件过滤
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 嵌套循环
matrix = [[1, 2], [3, 4]]
flattened = [num for row in matrix for num in row]

# 字典生成式
square_dict = {x: x**2 for x in range(5)}

3.2 元组(Tuple)不可变序列

3.2.1 元组特性与应用场景

python复制# 创建元组
empty_tuple = ()
single_item = (1,)     # 注意逗号
coordinates = (10.0, 20.0)

# 不可变性
# coordinates[0] = 5.0  # 报错，元组不可修改

# 解包
x, y = coordinates
print(f"X: {x}, Y: {y}")

# 交换变量
a, b = 1, 2
a, b = b, a            # 优雅的交换方式

3.2.2 命名元组(NamedTuple)

python复制from collections import namedtuple

# 定义命名元组类型
Point = namedtuple('Point', ['x', 'y'])

# 创建实例
p = Point(10.0, 20.0)

# 访问字段
print(p.x, p.y)        # 比普通元组更可读

# 仍然支持元组操作
x, y = p

3.3 字典(Dict)键值对集合

3.3.1 字典基本操作

python复制# 创建字典
empty_dict = {}
person = {'name': 'Alice', 'age': 25}

# 访问元素
name = person['name']  # 'Alice'
age = person.get('age') # 25
height = person.get('height', 170) # 默认值

# 修改字典
person['age'] = 26
person['height'] = 165

# 删除元素
del person['height']
age = person.pop('age')

3.3.2 字典进阶用法

python复制# 遍历字典
for key in person:          # 遍历键
    print(key, person[key])

for key, value in person.items():  # 同时遍历键值
    print(key, value)

# 字典推导式
square_dict = {x: x**2 for x in range(5)}

# 合并字典 (Python 3.9+)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged = dict1 | dict2      # {'a': 1, 'b': 3, 'c': 4}

3.3.3 默认字典(DefaultDict)

python复制from collections import defaultdict

# 定义默认字典
word_counts = defaultdict(int)

# 计数时无需检查键是否存在
for word in ['apple', 'banana', 'apple']:
    word_counts[word] += 1

print(word_counts)  # {'apple': 2, 'banana': 1}

3.4 集合(Set)无序唯一元素

3.4.1 集合基本操作

python复制# 创建集合
empty_set = set()           # 不能用{}，这是字典
numbers = {1, 2, 3, 3, 4}   # {1, 2, 3, 4}

# 集合运算
a = {1, 2, 3}
b = {2, 3, 4}

union = a | b               # 并集 {1, 2, 3, 4}
intersection = a & b        # 交集 {2, 3}
difference = a - b          # 差集 {1}
symmetric_diff = a ^ b      # 对称差集 {1, 4}

3.4.2 集合应用实例

python复制# 去重
words = ['apple', 'banana', 'apple', 'orange']
unique_words = set(words)   # {'apple', 'banana', 'orange'}

# 成员测试
if 'apple' in unique_words:  # O(1)时间复杂度
    print("Found apple")

# 集合推导式
squares = {x**2 for x in range(5)}  # {0, 1, 4, 9, 16}

4. Python面向对象编程精要

4.1 类与对象基础

4.1.1 类定义与实例化

python复制class Dog:
    # 类属性
    species = "Canis familiaris"
    
    # 初始化方法
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def bark(self):
        return f"{self.name} says woof!"
    
    # 特殊方法
    def __str__(self):
        return f"{self.name} is {self.age} years old"

# 创建实例
buddy = Dog("Buddy", 5)
print(buddy)            # Buddy is 5 years old
print(buddy.bark())     # Buddy says woof!

4.1.2 属性访问控制

Python中没有真正的私有属性，但可以通过命名约定实现封装：

python复制class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner          # 公开属性
        self._balance = balance     # 受保护属性(约定)
        self.__pin = "1234"         # 名称修饰(伪私有)
        
    def get_balance(self):
        return self._balance
        
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
            
    def withdraw(self, amount):
        if 0 < amount <= self._balance:
            self._balance -= amount
            return amount
        return 0

account = BankAccount("Alice", 1000)
print(account._balance)       # 可以访问但不建议
# print(account.__pin)        # 报错，实际被重命名为_BankAccount__pin

4.2 继承与多态

4.2.1 继承基础

python复制class Animal:
    def __init__(self, name):
        self.name = name
        
    def speak(self):
        raise NotImplementedError("子类必须实现此方法")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says meow!"

animals = [Dog("Buddy"), Cat("Whiskers")]
for animal in animals:
    print(animal.speak())

4.2.2 多重继承与方法解析顺序(MRO)

python复制class A:
    def method(self):
        print("A method")

class B(A):
    def method(self):
        print("B method")
        super().method()

class C(A):
    def method(self):
        print("C method")
        super().method()

class D(B, C):
    def method(self):
        print("D method")
        super().method()

d = D()
d.method()
# 输出顺序: D -> B -> C -> A
print(D.__mro__)  # 查看方法解析顺序

4.3 特殊方法与运算符重载

Python通过特殊方法(双下划线方法)实现运算符重载：

python复制class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
        
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
        
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
        
    def __str__(self):
        return f"Vector({self.x}, {self.y})"
        
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
        
    def __len__(self):
        return 2

v1 = Vector(2, 3)
v2 = Vector(4, 5)
print(v1 + v2)      # Vector(6, 8)
print(v1 * 3)       # Vector(6, 9)
print(len(v1))      # 2

4.4 类装饰器与元类

4.4.1 类装饰器应用

python复制def singleton(cls):
    instances = {}
    
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
        
    return get_instance

@singleton
class Database:
    def __init__(self):
        print("Initializing database...")

db1 = Database()
db2 = Database()
print(db1 is db2)  # True

4.4.2 属性装饰器

python复制class Circle:
    def __init__(self, radius):
        self.radius = radius
        
    @property
    def diameter(self):
        return 2 * self.radius
        
    @diameter.setter
    def diameter(self, value):
        self.radius = value / 2
        
    @property
    def area(self):
        return 3.14159 * self.radius ** 2

circle = Circle(5)
print(circle.diameter)  # 10
circle.diameter = 14
print(circle.radius)    # 7
print(circle.area)      # 153.93791

5. Python函数式编程进阶

5.1 高阶函数应用

5.1.1 map/filter/reduce

python复制from functools import reduce

numbers = [1, 2, 3, 4, 5]

# map: 对每个元素应用函数
squares = list(map(lambda x: x**2, numbers))  # [1, 4, 9, 16, 25]

# filter: 过滤元素
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2, 4]

# reduce: 累积计算
sum_all = reduce(lambda x, y: x + y, numbers)  # 15

# 更Pythonic的方式
squares = [x**2 for x in numbers]              # 列表推导式
evens = [x for x in numbers if x % 2 == 0]     # 带条件的推导式

5.1.2 函数作为参数和返回值

python复制def apply_operation(func, a, b):
    return func(a, b)

def add(x, y):
    return x + y

def multiply(x, y):
    return x * y

print(apply_operation(add, 3, 4))       # 7
print(apply_operation(multiply, 3, 4))  # 12

def make_adder(n):
    def adder(x):
        return x + n
    return adder

add5 = make_adder(5)
print(add5(10))  # 15

5.2 闭包与装饰器

5.2.1 闭包原理与应用

python复制def counter():
    count = 0
    
    def increment():
        nonlocal count
        count += 1
        return count
        
    return increment

c = counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

5.2.2 装饰器实战

python复制import time
from functools import wraps

def timing_decorator(func):
    @wraps(func)  # 保留原函数元信息
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@timing_decorator
def slow_function(n):
    time.sleep(n)
    return "Done"

result = slow_function(2)
print(result)

5.3 生成器与协程

5.3.1 生成器基础

python复制def countdown(n):
    print("Starting countdown")
    while n > 0:
        yield n
        n -= 1
    print("Blast off!")

# 创建生成器
counter = countdown(5)

# 使用生成器
print(next(counter))  # 5
print(next(counter))  # 4

# 可以for循环遍历
for num in countdown(3):
    print(num)

5.3.2 生成器表达式

python复制# 类似列表推导式，但返回生成器
squares = (x**2 for x in range(10))

# 惰性求值，节省内存
for num in squares:
    print(num)

# 管道式处理
numbers = (x for x in range(100) if x % 2 == 0)
squares = (x**2 for x in numbers)
filtered = (x for x in squares if x % 3 == 0)

print(sum(filtered))  # 只计算最终需要的值

6. Python模块与包管理

6.1 模块系统详解

6.1.1 模块创建与导入

python复制# mymodule.py
def greet(name):
    return f"Hello, {name}!"

class Calculator:
    @staticmethod
    def add(a, b):
        return a + b

# main.py
import mymodule
from mymodule import greet, Calculator

print(mymodule.greet("Alice"))
print(greet("Bob"))
print(Calculator.add(3, 4))

6.1.2 模块搜索路径

Python解释器按以下顺序查找模块：

1. 当前目录
2. PYTHONPATH环境变量指定的目录
3. Python安装目录的标准库路径
4. 第三方库安装路径(site-packages)

python复制import sys
print(sys.path)  # 查看模块搜索路径

# 临时添加路径
sys.path.append("/path/to/your/module")

6.2 包(Package)组织

6.2.1 包结构设计

code复制my_package/
    __init__.py
    module1.py
    module2.py
    subpackage/
        __init__.py
        module3.py

__init__.py文件可以是空文件，也可以包含包的初始化代码或定义__all__变量控制导入行为。

6.2.2 相对导入

python复制# 在my_package/module1.py中
from . import module2          # 同级别模块
from .subpackage import module3  # 子包模块

6.3 依赖管理与虚拟环境

6.3.1 pip高级用法

bash复制# 安装包
pip install package_name

# 指定版本
pip install package_name==1.2.3

# 从requirements.txt安装
pip install -r requirements.txt

# 开发模式安装(可编辑模式)
pip install -e .

# 列出已安装包
pip list

# 生成requirements.txt
pip freeze > requirements.txt

6.3.2 虚拟环境最佳实践

bash复制# 创建虚拟环境
python -m venv venv

# 激活环境
# Windows
venv\Scripts\activate
# Unix/macOS
source venv/bin/activate

# 停用环境
deactivate

7. Python高级特性与性能优化

7.1 并发编程模型

7.1.1 多线程编程

python复制import threading
import time

def worker(num):
    print(f"Worker {num} started")
    time.sleep(1)
    print(f"Worker {num} finished")

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("All workers completed")

7.1.2 多进程编程

python复制from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())

def f(name):
    info('function f')
    print('hello', name)

if __name__ == '__main__':
    info('main line')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

7.1.3 异步IO(asyncio)

python复制import asyncio

async def fetch_data():
    print("Start fetching")
    await asyncio.sleep(2)  # 模拟IO操作
    print("Done fetching")
    return {'data': 1}

async def print_numbers():
    for i in range(10):
        print(i)
        await asyncio.sleep(0.25)

async def main():
    task1 = asyncio.create_task(fetch_data())
    task2 = asyncio.create_task(print_numbers())
    
    value = await task1
    print(value)
    await task2

asyncio.run(main())

7.2 性能优化技巧

7.2.1 使用内置函数和库

python复制# 不好的写法
result = []
for item in some_list:
    result.append(str(item))

# 更好的写法
result = list(map(str, some_list))

# 最佳写法
result = [str(item) for item in some_list]

7.2.2 避免不必要的对象创建

python复制# 不好的写法 - 每次循环都创建新列表
for i in range(1000):
    data = [x for x in range(1000)]
    process(data)

# 更好的写法 - 重用对象
data = [0] * 1000
for i in range(1000):
    for j in range(1000):
        data[j] = j
    process(data)

7.2.3 使用适当的数据结构

python复制from collections import deque

# 频繁在两端操作时使用deque
queue = deque(maxlen=100)
queue.append(1)
queue.appendleft(2)
item = queue.pop()

7.3 内存管理与垃圾回收

7.3.1 引用计数与循环引用

python复制import sys
import gc

a = []
b = []
a.append(b)
b.append(a)  # 创建循环引用

print(sys.getrefcount(a))  # 查看引用计数
gc.collect()              # 手动触发垃圾回收

7.3.2 弱引用(weakref)

python复制import weakref

class Data:
    def __init__(self, value):
        self.value = value

obj = Data(42)
weak_obj = weakref.ref(obj)

print(weak_obj().value)  # 42
del obj
print(weak_obj())        # None

8. Python项目实战与开发建议

8.1 项目结构与代码组织

8.1.1 典型项目结构

code复制project_name/
│
├── docs/                  # 文档
├── tests/                 # 测试代码
│   ├── __init