C++ 开发者转 Python：完整学习与实战指南

# Python: 同样的功能
from collections import Counter

with open('data.txt') as file:
    words = file.read().split()
    word_count = Counter(words)

for word, count in word_count.items():
    print(f"{word}: {count}")

代码行数: C++ 18 行 vs Python 6 行（减少 67%）

1.2.2 技术栈互补

C++ 和 Python 并非竞争关系，而是互补：

最佳实践: 很多项目采用"C++ 核心 + Python 胶水"的架构，用 Python 调用 C++ 编写的高性能模块。

1.2.3 新的编程视野

Python 会让你体验到：

• 简洁之美: "能用一行代码解决就不用两行"
• 动态类型: 快速迭代，少写样板代码
• 函数式编程: map, filter, lambda 等函数式特性
• 鸭子类型: "如果它走起来像鸭子，叫起来像鸭子，那它就是鸭子"
• 丰富生态: 30 万 + 开源包，几乎所有问题都有现成方案

2. 思维转换：两种语言的设计哲学

在深入学习 Python 语法之前，理解两种语言的设计哲学至关重要。这将帮助你避免用"C++ 思维写 Python 代码"的误区。

2.1 语言设计哲学对比

C++ 的哲学："给专家提供工具"

// C++: 给你完全的控制权
template<typename T>
class MyVector {
private:
    T* data;
    size_t capacity;
    size_t size;
public:
    // 手动管理内存
    MyVector() : data(new T[10]), capacity(10), size(0) {}
    ~MyVector() { delete[] data; }
    // 提供多种方式：引用、指针、迭代器...
    T& operator[](size_t index) { return data[index]; }
    T* begin() { return data; }
    T* end() { return data + size; }
};

Python 的哲学："简洁优雅" - The Zen of Python

在 Python 中输入 import this 会显示 Python 之禅：

import this
# 部分输出：
# Beautiful is better than ugly.
# Explicit is better than implicit.
# Simple is better than complex.
# Readability counts.
# There should be one-- and preferably only one --obvious way to do it.

# Python: 简洁就是力量
my_list = [1, 2, 3, 4, 5] # 就这么简单，不需要管理内存

2.2 编译型 vs 解释型

这是两种语言最根本的差异之一：

graph LR
    subgraph "C++ 编译型语言"
        A1[源代码<br/>main.cpp] --> B1[编译器<br/>g++/clang]
        B1 --> C1[机器码<br/>a.out/exe]
        C1 --> D1[运行]
    end
    subgraph "Python 解释型语言"
        A2[源代码<br/>main.py] --> B2[解释器<br/>python]
        B2 --> C2[字节码<br/>.pyc]
        C2 --> D2[虚拟机<br/>PVM]
        D2 --> E2[运行]
    end
    style C1 fill:#ffe1e1
    style D2 fill:#e1ffe1

实际体验对比：

# C++ 开发流程
$ vim hello.cpp
$ g++ hello.cpp
$ ./a.out

# Python 开发流程
$ vim hello.py
$ python hello.py

2.3 静态类型 vs 动态类型

这可能是 C++ 开发者最需要适应的转变。

静态类型（C++）

// C++: 必须声明类型
int number = 42; // 类型是 int，永远是 int
std::string text = "hello"; // 类型是 string，永远是 string
std::vector<int> numbers;

// 编译时错误！
number = "hello"; // ❌ 错误：不能将 string 赋值给 int

动态类型（Python）

# Python: 变量只是标签，可以指向任何类型
number = 42       # 现在是整数
number = "hello"  # 现在是字符串，完全 OK！
number = [1, 2, 3] # 现在是列表，也 OK！
number = lambda x: x * 2 # 现在是函数，仍然 OK！

类型提示（Type Hints）- 两者的结合

Python 3.5+ 引入了类型提示，让你可以获得静态类型的部分好处：

# Python 3.5+: 类型提示（可选）
def greet(name: str) -> str:
    return f"Hello, {name}"

age: int = 25
scores: list[int] = [95, 87, 92]

# 类型提示不会强制执行！
age = "twenty-five" # Python 允许，但工具会警告

使用 mypy 进行静态类型检查：

$ mypy mycode.py # 类似 C++ 的编译时类型检查

2.4 内存管理模式

C++: 手动内存管理 + RAII

// C++: 你需要管理内存
void processData() {
    // 栈上分配（自动管理）
    int x = 42;
    // 堆上分配（手动管理）
    int* ptr = new int(100);
    // RAII: 资源获取即初始化
    std::unique_ptr<int> smart_ptr(new int(200));
    // 必须手动释放
    delete ptr; // 忘记这行 = 内存泄漏！
    // smart_ptr 自动释放，无需 delete
}

// 文件操作也需要手动关闭
std::ifstream file("data.txt");
// ... 使用 file
file.close(); // 必须记得关闭

Python: 自动垃圾回收

# Python: 完全自动，你不需要关心
def process_data():
    # 所有对象都自动管理
    x = 42
    data = [1, 2, 3, 4, 5]
    text = "Hello" * 1000
    # 函数结束，所有对象自动清理
    # 无需 delete，无需 close（大多数情况）
    # 文件操作：with 语句自动关闭
    with open('data.txt') as file:
        content = file.read()
    # 自动关闭，即使发生异常也会关闭！

思维转换：

• 从 "我需要管理内存" 到 "我只需要使用对象"
• 从 "何时释放资源" 到 "使用 with 语句"
• 从 "担心内存泄漏" 到 "专注业务逻辑"

2.5 "Pythonic"思维

"Pythonic"指的是符合 Python 风格的代码编写方式。

❌ 非 Pythonic（C++ 思维写 Python）

# C++ 思维：使用索引遍历
numbers = [1, 2, 3, 4, 5]
for i in range(len(numbers)): # ❌ 不够 Pythonic
    print(numbers[i])

# C++ 思维：手动检查条件
if len(my_list) > 0: # ❌ 繁琐
    first = my_list[0]

# C++ 思维：用 flag 变量
found = False # ❌ 不简洁
for item in items:
    if item == target:
        found = True
        break
if found:
    print("Found")

✅ Pythonic 方式

# Pythonic: 直接迭代
numbers = [1, 2, 3, 4, 5]
for number in numbers: # ✅ 清晰简洁
    print(number)

# Pythonic: 直接判断真值
if my_list: # ✅ 简洁（空列表是 False）
    first = my_list[0]

# Pythonic: 使用 in 运算符
if target in items: # ✅ 一行搞定
    print("Found")

# Pythonic: 列表推导
squares = [x**2 for x in range(10)] # ✅ 优雅
# vs C++ 风格
squares = []
for x in range(10):
    squares.append(x**2) # ❌ 繁琐

Pythonic 的核心原则

1. 简洁明了: 能用一行，不用三行
2. 直接表达: 代码即意图
3. 利用内置特性: 不要重新发明轮子
4. 可读性优先: 代码是写给人看的

# 示例：交换两个变量
# C++ 思维
temp = a
a = b
b = temp

# Pythonic
a, b = b, a # ✅ 优雅的元组解包

2.6 思维转换总结

graph TD
    A[C++ 思维] -->|转换| B[Python 思维]
    A1[我要控制每个细节] -->|转换| B1[我要表达业务逻辑]
    A2[性能优先] -->|转换| B2[可读性优先]
    A3[类型安全] -->|转换| B3[灵活动态]
    A4[编译时检查] -->|转换| B4[快速迭代]
    A5[手动管理资源] -->|转换| B5[自动管理资源]
    A6[多种实现方式] -->|转换| B6[唯一最佳方式]
    style A fill:#ffe1e1
    style B fill:#e1ffe1

关键转变：

3. 核心语法对比：快速入门

掌握 Python 的基础语法是第一步。本章将通过大量对比示例，帮助你快速建立 C++ 到 Python 的语法映射。

3.1 Hello World 对比

让我们从最简单的程序开始：

C++:

#include <iostream>
int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Python:

print("Hello, World!")

关键差异：

• ❌ Python 无需包含头文件
• ❌ Python 无需 main 函数
• ❌ Python 无需分号结尾
• ❌ Python 无需返回值
• ✅ Python 代码更简洁（从 5 行到 1 行）

3.2 变量和数据类型

变量声明

C++: 必须声明类型

// 基本类型
int age = 25;
double price = 99.99;
char grade = 'A';
bool is_valid = true;
std::string name = "Alice";

// C++11 auto 类型推导
auto count = 10; // 推导为 int
auto pi = 3.14; // 推导为 double

Python: 动态类型，无需声明

# 直接赋值
age = 25          # int
price = 99.99     # float
grade = 'A'       # str (注意：Python 没有单字符类型)
is_valid = True   # bool (注意大小写)
name = "Alice"    # str

# 类型提示（可选，不强制）
age: int = 25
price: float = 99.99

基本数据类型对照表

示例：整数大小

// C++: 整数有大小限制
long long big = 9223372036854775807LL; // 64 位最大值
// 超过这个值会溢出！

# Python: 整数可以无限大！
big = 9223372036854775807
bigger = big ** 100 # 完全 OK，不会溢出
print(bigger) # 可以打印出来

类型转换

C++: 显式转换

int x = 10;
double y = static_cast<double>(x);
std::string s = std::to_string(x);
int z = std::stoi("42");

Python: 使用内置函数

x = 10
y = float(x) # 转为浮点数
s = str(x)   # 转为字符串
z = int("42") # 字符串转整数
b = bool(x)  # 转为布尔值（非 0 即 True）

3.3 控制流

if-else 语句

C++:

int score = 85;
if (score >= 90) {
    std::cout << "A" << std::endl;
} else if (score >= 80) {
    std::cout << "B" << std::endl;
} else if (score >= 70) {
    std::cout << "C" << std::endl;
} else {
    std::cout << "D" << std::endl;
}

Python:

score = 85
if score >= 90: # 注意：用冒号，不用括号和大括号
    print("A") # 用缩进表示代码块
elif score >= 80: # 是 elif，不是 else if
    print("B")
elif score >= 70:
    print("C")
else:
    print("D")

关键差异：

• ✅ Python 用冒号代替大括号
• ✅ Python 用缩进表示代码块（通常 4 个空格）
• ✅ Python 用 elif 而不是 else if
• ✅ Python 条件表达式不需要括号（但可以加）

三元运算符：

// C++
int max = (a > b) ? a : b;

# Python
max_val = a if a > b else b

for 循环

C++: 传统 for 循环

// 方式 1：索引循环
for (int i = 0; i < 5; i++) {
    std::cout << i << std::endl;
}

// 方式 2：范围 for (C++11)
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
    std::cout << num << std::endl;
}

// 方式 3：迭代器
for (auto it = numbers.begin(); it != numbers.end(); ++it) {
    std::cout << *it << std::endl;
}

Python: 更简洁的 for 循环

# 方式 1：range 循环（类似 C++ 的索引循环）
for i in range(5): # 0, 1, 2, 3, 4
    print(i)

# 方式 2：直接迭代（最 Pythonic）
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

# 方式 3：enumerate（需要索引时）
for index, num in enumerate(numbers):
    print(f"{index}: {num}")

# 方式 4：带步长的 range
for i in range(0, 10, 2): # 0, 2, 4, 6, 8
    print(i)

range 函数对比：

// C++: 需要自己写循环
for (int i = start; i < end; i += step) {
    // ...
}

# Python: range 函数
range(stop)      # 0 到 stop-1
range(start, stop) # start 到 stop-1
range(start, stop, step) # 带步长

while 循环

C++:

int i = 0;
while (i < 5) {
    std::cout << i << std::endl;
    i++;
}
// do-while 循环
int j = 0;
do {
    std::cout << j << std::endl;
    j++;
} while (j < 5);

Python:

i = 0
while i < 5:
    print(i)
    i += 1 # 注意：Python 没有 i++

# Python 没有 do-while，可以这样模拟
while True:
    print(i)
    i += 1
    if i >= 5:
        break

switch vs match (Python 3.10+)

C++: switch 语句

int day = 3;
switch (day) {
    case 1: std::cout << "Monday" << std::endl; break;
    case 2: std::cout << "Tuesday" << std::endl; break;
    case 3: std::cout << "Wednesday" << std::endl; break;
    default: std::cout << "Other day" << std::endl;
}

Python 3.9 及以下：使用 if-elif

day = 3
if day == 1:
    print("Monday")
elif day == 2:
    print("Tuesday")
elif day == 3:
    print("Wednesday")
else:
    print("Other day")

# 或者使用字典
day_names = {
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday"
}
print(day_names.get(day, "Other day"))

Python 3.10+: match 语句（结构模式匹配）

day = 3
match day:
    case 1:
        print("Monday")
    case 2:
        print("Tuesday")
    case 3:
        print("Wednesday")
    case _: # 默认情况（类似 default）
        print("Other day")

3.4 函数定义

基本函数

C++:

// 函数声明（可选，在头文件中）
int add(int a, int b);

// 函数定义
int add(int a, int b) {
    return a + b;
}

// 调用
int result = add(3, 5);

Python:

# 函数定义（无需声明）
def add(a, b):
    return a + b

# 调用
result = add(3, 5)

# 带类型提示的版本
def add(a: int, b: int) -> int:
    return a + b

默认参数

C++:

// 默认参数必须在函数声明中
void greet(std::string name, std::string greeting = "Hello") {
    std::cout << greeting << ", " << name << std::endl;
}
greet("Alice"); // Hello, Alice
greet("Bob", "Hi"); // Hi, Bob

Python:

# 默认参数直接在定义中
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}")

greet("Alice") # Hello, Alice
greet("Bob", "Hi") # Hi, Bob
greet("Bob", greeting="Hi") # 命名参数

可变参数

C++: 变长参数

// C 风格
#include <cstdarg>
int sum(int count, ...) {
    va_list args;
    va_start(args, count);
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += va_arg(args, int);
    }
    va_end(args);
    return total;
}

// C++11: 可变参数模板
template<typename... Args>
int sum(Args... args) {
    return (args + ...); // C++17 折叠表达式
}

Python: 更简单的可变参数

# *args: 可变位置参数（元组）
def sum_all(*numbers):
    return sum(numbers)

print(sum_all(1, 2, 3, 4, 5)) # 15

# **kwargs: 可变关键字参数（字典）
def print_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="NYC")

Lambda 表达式

C++:

// C++11 lambda
auto add = [](int a, int b) { return a + b; };
int result = add(3, 5);

// 带捕获
int x = 10;
auto add_x = [x](int a) { return a + x; };

// 排序中使用
std::vector<int> nums = {3, 1, 4, 1, 5};
std::sort(nums.begin(), nums.end(), [](int a, int b) { return a > b; }); // 降序

Python:

# Python lambda（单行表达式）
add = lambda a, b: a + b
result = add(3, 5)

# 自动捕获外部变量
x = 10
add_x = lambda a: a + x

# 排序中使用
nums = [3, 1, 4, 1, 5]
sorted_nums = sorted(nums, key=lambda x: -x) # 降序

# 复杂逻辑用 def，不要用 lambda
# ❌ 不推荐
calc = lambda x: x**2 if x > 0 else -x**2

# ✅ 推荐
def calc(x):
    if x > 0:
        return x ** 2
    else:
        return -x ** 2

3.5 命名空间和作用域

命名空间

C++:

// 定义命名空间
namespace math {
    int add(int a, int b) { return a + b; }
}
namespace utils {
    int add(int a, int b) { return a + b + 1; // 不同的实现 }
}

// 使用
int result1 = math::add(3, 5);
int result2 = utils::add(3, 5);

// using 声明
using namespace math;
int result3 = add(3, 5); // 使用 math::add

Python: 模块即命名空间

# math_utils.py
def add(a, b):
    return a + b

# utils.py
def add(a, b):
    return a + b + 1

# main.py
import math_utils
import utils
result1 = math_utils.add(3, 5)
result2 = utils.add(3, 5)

# from import
from math_utils import add
result3 = add(3, 5)

# 别名
import math_utils as mu
result4 = mu.add(3, 5)

作用域规则

C++: 块作用域

int x = 10; // 全局作用域
void func() {
    int x = 20; // 局部作用域，遮蔽全局 x
    if (true) {
        int x = 30; // 块作用域，遮蔽局部 x
        std::cout << x << std::endl; // 30
    }
    std::cout << x << std::endl; // 20
}

Python: LEGB 规则

x = 10 # Global（全局）
def outer():
    x = 20 # Enclosing（闭包）
    def inner():
        x = 30 # Local（局部）
        print(x) # 30
    inner()
    print(x) # 20
outer()
print(x) # 10

# LEGB: Local -> Enclosing -> Global -> Built-in

修改外部变量：

// C++: 直接修改外部变量
int x = 10;
void modify() {
    x = 20; // 直接修改全局变量
}

# Python: 需要声明 global 或 nonlocal
x = 10
def modify():
    global x # 声明要修改全局变量
    x = 20

def outer():
    x = 10
    def inner():
        nonlocal x # 声明要修改闭包变量
        x = 20
    inner()
    print(x) # 20

3.6 注释和文档

C++:

// 单行注释
/*
 * 多行注释
 * 第二行
 */
/**
 * Doxygen 文档注释
 * @param name 参数说明
 * @return 返回值说明
 */
std::string greet(std::string name) {
    return "Hello, " + name;
}

Python:

# 单行注释
"""
多行注释（实际上是字符串）
第二行
"""

def greet(name):
    """函数文档字符串（Docstring）
    Args:
        name (str): 要问候的人名
    Returns:
        str: 问候语
    Examples:
        >>> greet("Alice")
        'Hello, Alice'
    """
    return f"Hello, {name}"

# 访问文档字符串
print(greet.__doc__)
help(greet)

3.7 语法对照速查表

3.8 常用操作对比

打印输出

// C++
#include <iostream>
std::cout << "Hello " << name << "!" << std::endl;

// C++20: format
std::cout << std::format("Hello {}!", name) << std::endl;

# Python
print("Hello", name, "!")
print(f"Hello {name}!") # f-string（推荐）
print("Hello {}!".format(name))

用户输入

// C++
#include <iostream>
#include <string>
int age;
std::string name;
std::cout << "Enter age: ";
std::cin >> age;
std::cout << "Enter name: ";
std::cin.ignore(); // 清除缓冲区
std::getline(std::cin, name);

# Python（更简单）
age = int(input("Enter age: ")) # input 返回字符串，需转换
name = input("Enter name: ")

字符串操作

// C++
#include <string>
#include <algorithm>
std::string s = "hello";
s += " world"; // 拼接
int len = s.length(); // 长度
std::string upper = s; // 转大写需要算法库
std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);

# Python（更方便）
s = "hello"
s += " world" # 拼接
s = s + " world" # 或这样
length = len(s) # 长度
upper = s.upper() # 转大写
lower = s.lower() # 转小写
s.startswith("he") # 检查开头
s.endswith("ld") # 检查结尾
s.split() # 分割
" ".join(["a", "b"]) # 连接

学习建议：

1. 先掌握基础语法，不要纠结于细节
2. 多写小程序练习，形成肌肉记忆
3. 记住 Python 的简洁哲学：代码应该直观易读
4. 善用 Python 的交互式解释器（REPL）快速试验代码

4. 数据结构：从 STL 到 Python 内置类型

Python 的内置数据结构功能强大且易用，相当于 C++ STL 的"开箱即用"版本。本章将帮助你建立 STL 到 Python 的映射关系。

4.1 序列类型

vector vs list (列表)

C++: std::vector

#include <vector>

// 创建和初始化
std::vector<int> numbers;
std::vector<int> nums = {1, 2, 3, 4, 5};
std::vector<int> zeros(10, 0); // 10 个 0

// 添加元素
numbers.push_back(10);
numbers.push_back(20);

// 访问元素
int first = numbers[0];
int last = numbers.back();

// 插入和删除
numbers.insert(numbers.begin() + 2, 99); // 在索引 2 处插入
numbers.erase(numbers.begin() + 1); // 删除索引 1 的元素

// 大小
size_t len = numbers.size();
bool empty = numbers.empty();

Python: list

# 创建和初始化
numbers = []
nums = [1, 2, 3, 4, 5]
zeros = [0] * 10 # 10 个 0

# 添加元素
numbers.append(10)
numbers.append(20)

# 访问元素
first = numbers[0]
last = numbers[-1] # 负索引！从后往前

# 插入和删除
numbers.insert(2, 99) # 在索引 2 处插入
del numbers[1] # 删除索引 1 的元素
numbers.remove(10) # 删除第一个值为 10 的元素
popped = numbers.pop() # 删除并返回最后一个元素

# 大小
length = len(numbers)
is_empty = len(numbers) == 0 # 或 not numbers

列表切片（Python 特色）：

# Python 独有的强大切片功能
nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
nums[2:5]      # [2, 3, 4] - 索引 2 到 4
nums[:3]       # [0, 1, 2] - 前 3 个
nums[7:]       # [7, 8, 9] - 从索引 7 到末尾
nums[-3:]      # [7, 8, 9] - 后 3 个
nums[::2]      # [0, 2, 4, 6, 8] - 步长为 2
nums[::-1]     # [9, 8, 7, ..., 0] - 反转！

# 修改切片
nums[2:5] = [20, 30, 40] # 替换一段

// C++ 中实现切片需要自己写代码
std::vector<int> nums = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int> slice(nums.begin() + 2, nums.begin() + 5); // [2, 3, 4]
// 反转
std::reverse(nums.begin(), nums.end());

array vs tuple (元组)

C++: std::array (C++11)

#include <array>
std::array<int, 3> point = {1, 2, 3}; // 固定大小
int x = point[0];
point[1] = 5; // 可修改

Python: tuple

# 元组是不可变的
point = (1, 2, 3)
x = point[0]
# point[1] = 5 # ❌ 错误！元组不可修改

# 元组解包（非常实用！）
x, y, z = point # x=1, y=2, z=3

# 交换变量
a, b = b, a # 优雅！

# 函数返回多值
def get_coordinates():
    return (10, 20, 30)

x, y, z = get_coordinates()

4.2 关联容器

map vs dict (字典)

C++: std::map 和 std::unordered_map

#include <map>
#include <unordered_map>

// std::map（有序，红黑树）
std::map<std::string, int> scores;
scores["Alice"] = 95;
scores["Bob"] = 87;
scores.insert({"Charlie", 92});

// 访问（不存在会创建）
int alice_score = scores["Alice"];

// 安全访问
auto it = scores.find("David");
if (it != scores.end()) {
    std::cout << it->second << std::endl;
}

// 遍历
for (const auto& pair : scores) {
    std::cout << pair.first << ": " << pair.second << std::endl;
}

// std::unordered_map（无序，哈希表，更快）
std::unordered_map<std::string, int> fast_scores;

Python: dict

# 字典（基于哈希表，Python 3.7+ 保持插入顺序）
scores = {}
scores["Alice"] = 95
scores["Bob"] = 87
scores = {"Alice": 95, "Bob": 87, "Charlie": 92} # 字面量创建

# 访问
alice_score = scores["Alice"]

# 安全访问
david_score = scores.get("David") # 不存在返回 None
david_score = scores.get("David", 0) # 不存在返回默认值 0

# 检查键是否存在
if "Alice" in scores:
    print(scores["Alice"])

# 遍历
for name, score in scores.items(): # items() 返回键值对
    print(f"{name}: {score}")

for name in scores.keys(): # 只遍历键
    print(name)

for score in scores.values(): # 只遍历值
    print(score)

# 字典推导（Pythonic！）
squares = {x: x**2 for x in range(5)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

set vs set (集合)

C++: std::set 和 std::unordered_set

#include <set>
#include <unordered_set>

std::set<int> numbers = {1, 2, 3, 4, 5};
numbers.insert(3); // 重复元素不会添加

// 查找
bool contains = numbers.find(3) != numbers.end();

// 删除
numbers.erase(2);

// 集合运算需要算法库
std::set<int> a = {1, 2, 3};
std::set<int> b = {2, 3, 4};
std::set<int> union_set;
std::set_union(a.begin(), a.end(), b.begin(), b.end(), std::inserter(union_set, union_set.begin()));

Python: set

# 集合
numbers = {1, 2, 3, 4, 5}
numbers.add(3) # 重复元素不会添加

# 查找
contains = 3 in numbers # ✅ 简洁！

# 删除
numbers.remove(2) # 不存在会报错
numbers.discard(2) # 不存在不报错

# 集合运算（内置！）
a = {1, 2, 3}
b = {2, 3, 4}
union = a | b      # {1, 2, 3, 4} 并集
intersection = a & b # {2, 3} 交集
difference = a - b   # {1} 差集
sym_diff = a ^ b     # {1, 4} 对称差集

# 集合推导
evens = {x for x in range(10) if x % 2 == 0} # {0, 2, 4, 6, 8}

4.3 字符串处理

C++: std::string

#include <string>
#include <algorithm>

std::string s = "Hello, World!";

// 基本操作
int len = s.length();
s += " Welcome"; // 拼接
std::string sub = s.substr(0, 5); // "Hello"

// 查找
size_t pos = s.find("World"); // 查找位置
if (pos != std::string::npos) {
    // 找到了
}

// 替换
s.replace(7, 5, "Python"); // 替换从位置 7 开始的 5 个字符

// 转大写（需要算法）
std::transform(s.begin(), s.end(), s.begin(), ::toupper);

// 分割需要自己实现或用库

Python: str

s = "Hello, World!"

# 基本操作
length = len(s)
s += " Welcome" # 拼接
sub = s[0:5] # "Hello" 切片

# 查找
pos = s.find("World") # 查找位置，找不到返回 -1
contains = "World" in s # ✅ 更简单的方式

# 替换
s = s.replace("World", "Python") # 字符串不可变，返回新字符串

# 大小写
upper = s.upper()
lower = s.lower()
title = s.title() # 标题格式
capitalized = s.capitalize() # 首字母大写

# 分割和连接
words = s.split() # 按空白分割
words = s.split(',') # 按逗号分割
" ".join(words) # 用空格连接

# 去除空白
trimmed = s.strip() # 去除两端空白
left = s.lstrip() # 去除左边
right = s.rstrip() # 去除右边

# 字符串格式化
name = "Alice"
age = 25
msg = f"My name is {name} and I'm {age} years old" # f-string
msg = "My name is {} and I'm {} years old".format(name, age)
msg = "My name is %s and I'm %d years old" % (name, age) # 旧式

4.4 容器操作

列表推导和生成器

C++: 传统循环

// C++: 创建平方数列表
std::vector<int> squares;
for (int i = 0; i < 10; i++) {
    squares.push_back(i * i);
}

// C++: 筛选偶数
std::vector<int> evens;
for (int num : numbers) {
    if (num % 2 == 0) {
        evens.push_back(num);
    }
}

// C++20: ranges（更接近 Python）
#include <ranges>
auto squares = std::views::iota(0, 10) | std::views::transform([](int x) { return x * x; });

Python: 推导式（Pythonic！）

# 列表推导
squares = [x**2 for x in range(10)] # [0, 1, 4, 9, ..., 81]

# 带条件的推导
evens = [x for x in numbers if x % 2 == 0]

# 嵌套推导
matrix = [[i+j for j in range(3)] for i in range(3)] # [[0, 1, 2], [1, 2, 3], [2, 3, 4]]

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

# 集合推导
unique_lens = {len(word) for word in words}

# 生成器表达式（节省内存）
squares_gen = (x**2 for x in range(10)) # 使用 () 而不是 []
# 不会立即计算，只在迭代时计算

常用操作对比

排序：

// C++
#include <algorithm>
std::vector<int> nums = {3, 1, 4, 1, 5, 9};
std::sort(nums.begin(), nums.end()); // 原地排序，升序

// 降序
std::sort(nums.begin(), nums.end(), std::greater<int>());

// 自定义比较
std::sort(nums.begin(), nums.end(), [](int a, int b) { return a > b; });

# Python
nums = [3, 1, 4, 1, 5, 9]

# 原地排序
nums.sort() # 升序
nums.sort(reverse=True) # 降序

# 返回新列表
sorted_nums = sorted(nums) # 升序
sorted_nums = sorted(nums, reverse=True) # 降序

# 自定义排序键
words = ["apple", "pie", "a", "zoo"]
sorted_words = sorted(words, key=len) # 按长度排序
sorted_words = sorted(words, key=lambda x: x[-1]) # 按最后一个字母

查找：

// C++
#include <algorithm>
auto it = std::find(nums.begin(), nums.end(), 4);
if (it != nums.end()) {
    // 找到了
    size_t index = std::distance(nums.begin(), it);
}

// 计数
int count = std::count(nums.begin(), nums.end(), 1);

# Python
# 查找
if 4 in nums: # 简单！
    index = nums.index(4) # 获取索引

# 计数
count = nums.count(1)

4.5 数据结构性能对比

*均摊时间复杂度

使用场景建议：

4.6 高级数据结构

Python 额外提供的便利工具 (collections模块)：

from collections import defaultdict, Counter, deque, namedtuple

# defaultdict: 带默认值的字典
word_count = defaultdict(int) # 默认值为 0
for word in words:
    word_count[word] += 1 # 不需要检查键是否存在！

# Counter: 计数器（非常实用！）
from collections import Counter
nums = [1, 2, 2, 3, 3, 3, 4]
counter = Counter(nums)
print(counter) # Counter({3: 3, 2: 2, 1: 1, 4: 1})
most_common = counter.most_common(2) # [(3, 3), (2, 2)]

# deque: 双端队列
dq = deque([1, 2, 3])
dq.appendleft(0) # 左端添加
dq.pop() # 右端删除
dq.popleft() # 左端删除

# namedtuple: 命名元组
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x, p.y) # 10 20

C++ 中需要自己实现或使用库：

// C++: 需要更多代码实现类似功能
#include <map>
#include <queue>

// defaultdict 的效果需要手动检查或用 map 的 [] 操作符
std::map<std::string, int> word_count;
for (const auto& word : words) {
    word_count[word]++; // [] 会创建默认值
}

// 计数需要手动统计

// 双端队列有 std::deque

// 命名元组可以用 struct

4.7 推导式专题（Python 独有）

Python 的推导式是非常强大且 Pythonic 的特性：

# 列表推导：基础
squares = [x**2 for x in range(10)]

# 列表推导：带条件
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 列表推导：多重条件
result = [x for x in range(20) if x % 2 == 0 if x % 3 == 0]

# 列表推导：嵌套循环
pairs = [(x, y) for x in range(3) for y in range(3)]
# [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2)]

# 字典推导
word_lengths = {word: len(word) for word in ["apple", "banana", "cherry"]}
# {'apple': 5, 'banana': 6, 'cherry': 6}

# 集合推导
unique_lengths = {len(word) for word in words}

# 生成器表达式（惰性求值）
gen = (x**2 for x in range(1000000)) # 不会立即计算所有值
first_ten = [next(gen) for _ in range(10)]

关键差异总结：

1. Python 的数据结构是内置的，C++ 需要包含头文件
2. Python 的操作更简洁，如 in 运算符、切片、推导式
3. Python dict 和 set 基于哈希表，通常比 C++ map/set (红黑树) 更快
4. Python 字符串操作更丰富，不需要额外的库或算法
5. Python 的列表更灵活，可以存储不同类型的元素

5. 面向对象：不同的实现方式

C++ 和 Python 都支持面向对象编程，但实现方式有显著差异。

5.1 类的定义

C++:

class Person {
private:
    std::string name;
    int age;
public:
    // 构造函数
    Person(std::string n, int a) : name(n), age(a) {}
    // 析构函数
    ~Person() { /* 清理资源 */ }
    // 成员函数
    void introduce() {
        std::cout << "I'm " << name << ", " << age << " years old" << std::endl;
    }
    // Getter
    std::string getName() const { return name; }
    // Setter
    void setAge(int a) { age = a; }
};

// 使用
Person p("Alice", 25);
p.introduce();

Python:

class Person:
    def __init__(self, name, age): # 构造函数
        self.name = name # self 相当于 C++ 的 this
        self.age = age

    def introduce(self):
        print(f"I'm {self.name}, {self.age} years old")

    # Python 没有析构函数，有__del__但很少用

# 使用
p = Person("Alice", 25)
p.introduce()

5.2 访问控制

Python 的"成人式"设计：

class BankAccount:
    def __init__(self, balance):
        self._balance = balance # _表示"请不要直接访问"
        self.__secret = "123" # __会被名称改写

    def deposit(self, amount):
        self._balance += amount

# Python 相信程序员
account = BankAccount(1000)
print(account._balance) # 可以访问，但不推荐

5.3 属性和装饰器

C++ Getter/Setter:

class Circle {
private:
    double radius;
public:
    double getRadius() const { return radius; }
    void setRadius(double r) { if (r > 0) radius = r; }
};

Python @property:

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property # 装饰器
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value > 0:
            self._radius = value

    @property
    def area(self): # 只读属性
        return 3.14159 * self._radius ** 2

# 使用起来像属性
c = Circle(5)
print(c.radius) # 像访问属性，实际调用方法
c.radius = 10 # 像赋值，实际调用 setter
print(c.area) # 只读，不能赋值

5.4 继承

C++: 多种继承方式：

class Animal {
public:
    virtual void speak() {
        std::cout << "Some sound" << std::endl;
    }
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void speak() override { // 重写
        std::cout << "Woof!" << std::endl;
    }
};

Python: 更简单的继承：

class Animal:
    def speak(self):
        print("Some sound")

class Dog(Animal):
    def speak(self): # 重写（无需关键字）
        print("Woof!")

    def bark(self):
        super().speak() # 调用父类方法
        print("Bark!")

# 多继承
class FlyingDog(Dog, Flying): # Python 支持多继承
    pass

5.5 特殊方法（魔术方法）

Python 的特殊方法让类更强大：

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self): # 相当于 C++ 的 operator<<
        return f"Vector({self.x}, {self.y})"

    def __repr__(self): # 官方字符串表示
        return f"Vector(x={self.x}, y={self.y})"

    def __add__(self, other): # 运算符重载 +
        return Vector(self.x + other.x, self.y + other.y)

    def __len__(self): # len(obj)
        return int((self.x**2 + self.y**2)**0.5)

    def __getitem__(self, key): # obj[key]
        if key == 0:
            return self.x
        if key == 1:
            return self.y
        raise IndexError()

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2 # 调用__add__
print(v1) # 调用__str__

常用魔术方法：

6. 内存管理：从手动到自动

6.1 核心差异

6.2 上下文管理器

C++ RAII:

{
    std::ifstream file("data.txt"); // 使用 file
} // file 自动关闭

Python with 语句：

with open('data.txt') as file:
    content = file.read() # 自动关闭，即使发生异常

# 自定义上下文管理器
class MyResource:
    def __enter__(self):
        print("获取资源")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("释放资源")
        return False # 不抑制异常

with MyResource() as r:
    pass # 使用资源

6.3 浅拷贝 vs 深拷贝

import copy
original = [[1, 2], [3, 4]]

# 浅拷贝
shallow = original.copy()
shallow[0][0] = 99
print(original) # [[99, 2], [3, 4]] 受影响！

# 深拷贝
deep = copy.deepcopy(original)
deep[0][0] = 999
print(original) # 不受影响

7. Python 开发环境：工具链全景

7.1 Python 安装

• 官方 Python: python.org
• Anaconda: 科学计算推荐
• Pyenv: 多版本管理

7.2 IDE 和编辑器

7.3 包管理

# pip: Python 标准包管理器
pip install requests
pip install -r requirements.txt
pip list
pip uninstall requests

# 虚拟环境
python -m venv myenv
source myenv/bin/activate # Windows: myenv\Scripts\activate
pip install numpy
decorate

8. 标准库与生态系统

Python 的"batteries included"（自带电池）哲学意味着标准库功能丰富。

8.1 常用标准库

文件和路径：

import os
import pathlib

# os 模块 (传统方式)
current_dir = os.getcwd()
os.listdir('.')
os.path.join('dir', 'file.txt')

# pathlib (现代方式，推荐)
from pathlib import Path
p = Path('.')
p.is_file()
p.glob('*.txt')
files = list(p.iterdir())

数据处理：

# collections: 高级数据结构
from collections import defaultdict, Counter, deque

# itertools: 迭代器工具
from itertools import chain, combinations, permutations

# functools: 函数工具
from functools import lru_cache, partial

@lru_cache(maxsize=128) # 缓存结果
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

日期时间：

from datetime import datetime, timedelta
now = datetime.now()
tomorrow = now + timedelta(days=1)
formatted = now.strftime('%Y-%m-%d %H:%M:%S')

8.2 必备第三方库

示例：requests：

import requests

# GET 请求
response = requests.get('https://api.github.com')
data = response.json()

# POST 请求
response = requests.post('https://api.example.com', json={'key': 'value'})

9. 学习路径：从入门到进阶

graph TD
    A[开始学习] --> B[第 1 周：基础语法]
    B --> C[第 2 周：数据结构]
    C --> D[第 3-4 周：OOP 和函数式]
    D --> E{选择方向}
    E --> F1[Web 开发]
    E --> F2[数据科学]
    E --> F3[自动化]
    F1 --> G1[Django/Flask]
    F2 --> G2[Pandas/NumPy]
    F3 --> G3[实用脚本]
    G1 --> H[持续实践]
    G2 --> H
    G3 --> H
    H --> I[阅读源码]
    I --> J[参与开源]
    style A fill:#e1f5ff
    style H fill:#fff4e1
    style J fill:#e1ffe1

学习阶段

基础阶段（1-2 周）：

• 语法、数据类型、控制流
• 列表、字典、集合
• 函数和模块

进阶阶段（3-4 周）：

• 面向对象
• 装饰器、生成器
• 异常处理

实战阶段（1-3 月）：

• 选择方向深入
• 完成实战项目
• 阅读优秀代码

10. 最佳实践：写出 Pythonic 代码

10.1 PEP 8 核心要点

# ✅ 好的命名
class UserAccount: # 类名：大驼峰
    pass

def get_user_name(): # 函数名：小写 + 下划线
    pass

MAX_SIZE = 100 # 常量：大写 + 下划线

# ✅ 空格使用
result = a + b # 运算符两侧有空格
func(1, 2, 3) # 逗号后有空格

# ✅ 每行不超过 79 字符

10.2 Pythonic 惯用法

# ❌ 非 Pythonic
i = 0
while i < len(items):
    item = items[i]
    process(item)
    i += 1

# ✅ Pythonic
for item in items:
    process(item)

# ❌ 手动构建列表
result = []
for x in range(10):
    if x % 2 == 0:
        result.append(x**2)

# ✅ 列表推导
result = [x**2 for x in range(10) if x % 2 == 0]

# ✅ 使用 enumerate
for i, item in enumerate(items):
    print(f"{i}: {item}")

# ✅ 使用 zip
for name, score in zip(names, scores):
    print(f"{name}: {score}")

11. 常见陷阱：C++ 开发者易犯的错误

陷阱 1: 可变默认参数

# ❌ 错误
def add_item(item, my_list=[]):
    my_list.append(item)
    return my_list

print(add_item(1)) # [1]
print(add_item(2)) # [1, 2] ⚠️ 意外！

# ✅ 正确
def add_item(item, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(item)
    return my_list

陷阱 2: 闭包变量绑定

# ❌ 错误
functions = []
for i in range(3):
    functions.append(lambda: i)

for f in functions:
    print(f()) # 2, 2, 2 ⚠️ 全是 2！

# ✅ 正确
functions = []
for i in range(3):
    functions.append(lambda x=i: x) # 立即绑定

for f in functions:
    print(f()) # 0, 1, 2 ✅

陷阱 3: 字符串拼接性能

# ❌ 低效
for s in strings:
    result += s # 每次创建新字符串

# ✅ 高效
''.join(strings) # 一次性拼接

12. 实战项目建议

项目 1: 文件批处理工具

难度: ⭐⭐
知识点: 文件 I/O、os 模块、pathlib

# 示例：批量重命名文件
from pathlib import Path

def batch_rename(directory, old_ext, new_ext):
    path = Path(directory)
    for file in path.glob(f"*.{old_ext}"):
        new_name = file.stem + f".{new_ext}"
        file.rename(file.parent / new_name)

项目 2: Web API 调用工具

难度: ⭐⭐⭐
知识点: requests 库、JSON、异常处理

import requests

def get_weather(city):
    url = f"https://api.weather.com/{city}"
    response = requests.get(url)
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"Error: {response.status_code}")

项目 3: 简单 Web 应用

难度: ⭐⭐⭐⭐
知识点: Flask 框架、HTML、数据库

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/')
def home():
    return render_template('index.html')

if __name__ == '__main__':
    app.run(debug=True)

13. FAQ

Q1: Python 比 C++ 慢多少？什么时候性能是问题？
A: Python 通常比 C++ 慢 10-100 倍。但对于大多数应用（Web、数据分析、脚本），开发效率更重要。真正的瓶颈往往是 I/O 或算法，不是语言。需要性能时可以用 Cython 或调用 C++ 模块。

Q2: 应该完全放弃 C++ 吗？
A: 不。两者互补：C++ 适合性能关键代码，Python 适合快速开发和胶水代码。很多项目用 Python 调用 C++ 核心模块。

Q3: Python 适合大型项目吗？
A: 可以。Instagram、Dropbox、YouTube 后端都大量使用 Python。关键是：使用类型提示、写好测试、遵循规范。

Q4: 学 Python 需要多久？
A: 基础：1-2 周；熟练：1-2 月；精通：需要大量实践。有 C++ 基础会快很多。

Q5: 如何在 Python 项目中使用 C++ 代码？
A: 使用 pybind11 或 Cython。示例：

// C++ (用 pybind11)
#include <pybind11/pybind11.h>

int add(int a, int b) {
    return a + b;
}

PYBIND11_MODULE(example, m) {
    m.def("add", &add);
}

# Python 中调用
import example
result = example.add(1, 2)

Q6: Python 2 还是 Python 3？
A: 必须 Python 3！Python 2 已于 2020 年停止支持。

Q7: 动态类型会导致更多 bug 吗？
A: 可能。但可以用类型提示+mypy 降低风险。测试比类型系统更重要。

Q8: 最重要的 Python 库是哪些？
A:

• 通用：requests, pytest, click
• Web：Django, Flask, FastAPI
• 数据：NumPy, Pandas, Matplotlib
• AI：TensorFlow, PyTorch, scikit-learn

Q9: 如何调试 Python 代码？
A:

• print() 调试（快速简单）
• pdb 调试器（交互式）
• IDE 断点调试（VSCode/PyCharm）

Q10: Python 能做 C++ 能做的所有事吗？
A: 大部分可以，但有限制：

• ❌ 不适合：实时系统、嵌入式、内核开发
• ✅ 适合：Web、数据分析、AI、自动化、原型开发

14. 延伸阅读

推荐书籍

入门：

• 《Python Crash Course》- 快速上手
• 《Automate the Boring Stuff with Python》- 实用导向

进阶：

• 《Fluent Python》- 深入理解 Python
• 《Effective Python》- 最佳实践
• 《Python Cookbook》- 实用技巧

特定领域：

• Web: 《Flask Web Development》
• 数据：《Python for Data Analysis》
• AI: 《Hands-On Machine Learning》

在线资源

官方：

• Python 官方文档：https://docs.python.org/
• PEP 8 风格指南：https://pep8.org/

学习平台：

• Real Python: realpython.com
• Python 官方教程
• Codecademy Python 课程

练习：

• LeetCode (Python 刷题)
• Project Euler (算法挑战)
• HackerRank

开源项目推荐

阅读优秀代码：

• Requests: HTTP 库，代码优雅
• Flask: Web 框架，架构清晰
• Django: 大型 Web 框架，学习最佳实践

社区

• Stack Overflow (提问)
• Reddit r/Python (讨论)
• Python Discord (实时交流)
• GitHub (阅读源码、参与贡献)

持续学习建议

1. 每天编码: 形成肌肉记忆
2. 阅读源码: 学习优秀实践
3. 写博客: 巩固理解
4. 参与开源: 实战提升
5. 关注 PEP: 了解语言发展

📚 附录

附录 A：Python 与 C++ 特性对照表

附录 B：常用库速查表

通用开发：

requests - HTTP 客户端
pytest - 测试框架
click - 命令行工具
python-dotenv - 环境变量管理

Web 开发：

django - 全功能 Web 框架
flask - 轻量 Web 框架
fastapi - 现代异步 API 框架
sqlalchemy - ORM 数据库工具

数据科学：

numpy - 数值计算
pandas - 数据分析
matplotlib - 数据可视化
scikit-learn - 机器学习
jupyter - 交互式笔记本

自动化和工具：

selenium - 浏览器自动化
pillow - 图像处理
openpyxl - Excel 操作
beautifulsoup4 - HTML 解析

附录 C：学习资源清单

官方资源：

• Python 官网：https://www.python.org/
• Python 文档：https://docs.python.org/zh-cn/3/
• PEP 索引：https://www.python.org/dev/peps/
• PyPI 包索引：https://pypi.org

在线教程：

• Real Python: https://realpython.com/
• Python 官方教程：https://docs.python.org/zh-cn/3/tutorial/
• W3Schools Python: https://www.w3schools.com/python/
• Programiz Python: https://www.programiz.com/python-programming

练习平台：

• LeetCode: https://leetcode.com/
• HackerRank: https://www.hackerrank.com/domains/python
• Codewars: https://www.codewars.com/
• Project Euler: https://projecteuler.net/

视频课程：

• Coursera: Python for Everybody
• edX: MIT Introduction to Computer Science
• YouTube: Corey Schafer's Python Tutorials
• B 站：Python 教程（搜索热门）

社区和论坛：

• Stack Overflow: 技术问答
• Reddit r/learnpython: 学习讨论
• Python Discord: 实时聊天
• 知乎 Python 话题：中文社区

🎓 学习建议总结

作为 C++ 开发者学习 Python，你具有得天独厚的优势。记住以下几点：

1. 放下控制欲 - 信任 Python 的自动化，专注业务逻辑
2. 拥抱简洁 - "能一行写完就不用两行"
3. 实践为王 - 每学一个概念立即写代码验证
4. 阅读优秀代码 - GitHub 上找优质 Python 项目学习
5. 参与社区 - 提问、回答、贡献开源
6. 两者并用 - C++ 和 Python 不是替代关系，而是互补

推荐学习路线：

Week 1: 基础语法 → 完成 10 个小练习
Week 2: 数据结构 → 用 Python 重写一个 C++ 项目
Week 3-4: OOP 和高级特性 → 阅读一个开源项目
Month 2: 选择方向深入 → 完成一个实战项目
Month 3+: 持续实践 → 参与开源、写技术博客

祝你学习顺利，早日成为 Python 高手！