给 Java 工程师的
Python 语法对照手册

这是所有差异的根源。Java 是「编译成字节码 → JVM 执行」，Python 也是「编译成字节码 → 虚拟机执行」，看起来很像，但两者在类型检查时机和代码组织方式上完全不同。

最简单的程序

package com.demo;

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, World");
    }
}

# 不需要包声明、不需要类、不需要 main

print("Hello, World")


# 想区分"被导入"和"直接运行"时：
if __name__ == "__main__":
    print("只有在直接执行本文件时才会打印")

Python 变量是「贴在对象上的名字」，不是「装值的盒子」。所以既不需要写类型，也不能给变量单独声明类型——你标注的类型是给对象和阅读者看的。

int age = 25;
long money = 10_0000_0000L;
double price = 19.9;
boolean flag = true;
char grade = 'A';
String name = "Alice";
final int MAX = 100;       // 常量

// 必须显式声明类型，且类型不可变
// 泛型集合
List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();

// 局部变量可推断（Java 10+）
var count = 10;

age = 25
money = 10000000000      # 整数无上限，不需要 long
price = 19.9
flag = True              # 注意首字母大写
grade = "A"              # 没有 char，用长度 1 的字符串
name = "Alice"
MAX = 100                # 全大写只是"约定"，语法上仍可修改

# 类型是"动"的，随时可换
x = 1
x = "现在是字符串了"      # 合法

# 容器不需要泛型声明，天然可异构
lst = []
mp = {}

# 类型注解是可选的，运行时不强制
age: int = 25
name: str = "Alice"

def greet(n: str) -> str:   # 返回类型注解
    return "Hi " + n

类型对照表

变量命名习惯

Python 的字符串是日常用得最多的类型，也是从 Java 过来最爽的地方：格式化、切片、多行文本都比 Java 顺手得多。

String name = "Alice";
int age = 25;

// 格式化
String msg = String.format("我是 %s，今年 %d 岁", name, age);

// 多行文本（Java 15+）
String multi = """
    第一行
    第二行
    """;

String s = "hello";
s.length();            // 5  —— 方法
s.toUpperCase();       // "HELLO"
s.substring(1, 3);     // "el"  左闭右开
s.charAt(0);           // 'h'
s.contains("ell");
s.split(",");
s.trim();
s.isEmpty();
"a" + "b";             // 拼接
String.join("-", list);

name = "Alice"
age = 25

# f-string（3.6+）：推荐，最直观
msg = f"我是 {name}，今年 {age} 岁"
msg2 = f"明年 {age + 1} 岁"        # 可以直接写表达式

# 多行文本：三个引号
multi = """第一行
第二行"""

s = "hello"
len(s)                 # 5   —— 函数，不是方法！
s.upper()              # "HELLO"
s[1:3]                 # "el"  切片，左闭右开
s[0]                   # "h"
"ell" in s             # 用 in 做包含判断
s.split(",")
s.strip()              # 等价 trim
not s                  # 空字符串为假
"a" + "b"
"-".join(["a", "b"])   # "a-b"

# 单双引号完全等价，省去转义
a = 'He said "hi"'

切片：Python 独有、用了就回不去的语法

s = "Python"
s[0]        # "P"
s[-1]       # "n"      负数从右边数
s[0:3]      # "Pyt"    左闭右开，等价 s[:3]
s[3:]       # "hon"    省略终点表示到末尾
s[:]        # "Python" 整个字符串（浅拷贝）
s[::2]      # "Pto"    步长为 2
s[::-1]     # "nohtyP" 反转！Java 要 StringBuilder.reverse()

nums = [1, 2, 3, 4, 5]
nums[1:4]   # [2, 3, 4]  —— 切片对 list 一样适用
nums[-2:]   # [4, 5]

字符串格式化三种写法

name, score = "Alice", 95.678

# 1. f-string  —— 首选
f"{name} 得分 {score:.2f}"          # Alice 得分 95.68
f"{score:>10.2f}"                    # 右对齐宽度10
f"{1234567:,}"                       # 1,234,567
f"{0.856:.1%}"                       # 85.6%
f"{name=}"                           # name='Alice'  调试神器

# 2. str.format()  —— 老写法
"{} 得分 {:.2f}".format(name, score)
"{n} 得分 {s}".format(n=name, s=score)

# 3. % 格式化  —— 类 C 风格，新代码不建议
"%s 得分 %.2f" % (name, score)

运算符差异不大，但有三个地方会直接咬人：除法语义、逻辑运算符的写法、以及 == 与 is 的区别。

int a = 5 / 2;              // 2     整数除法截断
double b = 5 / 2.0;        // 2.5   要写一个浮点字面量
double c = 5 % 2;          // 1.0
double p = Math.pow(2, 10); // 1024.0
int q = Math.floorDiv(-7, 2); // -4
int r = Math.floorMod(-7, 2); // 1

if (x > 0 && x < 10) { }
if (a == 0 || b == 0) { }
if (!done) { }

// 三元
String s = age >= 18 ? "成年" : "未成年";

int i = 0;
i++;  i--;  ++i;          // 自增自减

// 字符串比较必须用 equals
if (name.equals(other)) { }
if (null == obj) { }

a = 5 // 2       # 2    整除（向下取整）
b = 5 / 2        # 2.5  真除法，永远是 float
c = 5 % 2        # 1
p = 2 ** 10      # 1024 幂运算，不用 Math.pow
q = -7 // 2      # -4   向下取整（Java 的 / 是向零取整）
r = -7 % 2       # 1    余数符号跟随除数

if 0 < x < 10:      # 链式比较，比 Java 优雅
    ...

if a == 0 or b == 0:
    ...

if not done:
    ...

# 三元（条件表达式）
s = "成年" if age >= 18 else "未成年"

i = 0
i += 1  # 没有 ++ / --，一行只能写一个语句

# 字符串比较就用 ==（比较值）
if name == other:
    ...

# is 是"身份"比较，等价于 Java 的 == 引用比较
if obj is None:
    ...

逻辑与比较的坑

逻辑完全一样，但 Python 用缩进代替花括号，for 是「遍历可迭代对象」而不是「三段式循环」，这是最需要重新训练肌肉记忆的地方。

if (score >= 90) {
    grade = "A";
} else if (score >= 60) {
    grade = "B";
} else {
    grade = "C";
}

// 三段式 for
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

// 增强 for
for (String s : list) {
    System.out.println(s);
}

while (cond) { }

do { } while (cond);

// switch
switch (day) {
    case 1 -> "周一";
    case 2, 3 -> "工作日";
    default -> "未知";
}

break;  continue;

if score >= 90:      # 冒号 + 缩进，没有 ()
    grade = "A"
elif score >= 60:    # 是 elif，不是 else if
    grade = "B"
else:
    grade = "C"

for i in range(5):   # 0,1,2,3,4   左闭右开
    print(i)

for s in lst:        # 直接遍历元素
    print(s)

for i, s in enumerate(lst):     # 需要下标时
    print(i, s)

for a, b in zip(xs, ys):        # 并行遍历
    print(a, b)

while cond:
    ...

# 没有 do-while，用 while True + break 模拟

# 3.10+ 的 match（类似 switch，但语义更强）
match day:
    case 1:
        r = "周一"
    case 2 | 3:              # 或
        r = "工作日"
    case _:                  # 默认分支
        r = "未知"

break
continue
pass            # 空语句占位，相当于 Java 的 {}

range 与常用循环套路

range(5)            # 0 1 2 3 4
range(2, 5)         # 2 3 4
range(0, 10, 2)     # 0 2 4 6 8
range(5, 0, -1)     # 5 4 3 2 1  倒序

# 倒序遍历
for i in reversed(lst): ...

# 带下标倒序
for i in range(len(lst) - 1, -1, -1): ...

# 同时取索引和值（比 Java 的 for i 干净）
for idx, val in enumerate(lst, start=1):
    print(idx, val)

# 字典遍历
for k in d: ...                 # 键
for k, v in d.items(): ...      # 键值对
for v in d.values(): ...        # 值

# for-else / while-else：循环"正常结束"（没被 break）时执行
for n in nums:
    if n < 0:
        break
else:
    print("全都是非负数")   # 没 break 才打印

Python 函数是「一等公民」：可以赋给变量、当参数传、被返回。同时它用默认参数 + 关键字参数 + *args/**kwargs 取代了 Java 的方法重载。

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

// 方法重载：同名不同参
public static int add(int a, int b, int c) {
    return a + b + c;
}

// 可变参数
public static int total(int... nums) { }

// 默认值只能靠重载实现
public static String greet(String name) {
    return greet(name, "你好");
}
public static String greet(String name, String g) {
    return g + ", " + name;
}

// 多返回值要包对象
record DivResult(int q, int r) { }
public static DivResult divmod(int a, int b) {
    return new DivResult(a / b, a % b);
}

def add(a, b):
    return a + b

# 默认参数：取代了大量重载
def greet(name, greeting="你好"):
    return f"{greeting}, {name}"

# 关键字参数：调用时任意顺序，可读性极强
greet("Tom")
greet("Tom", "Hi")
greet(greeting="Hi", name="Tom")

# 可变参数：*args 收位置参数为元组
def total(*nums):
    return sum(nums)
total(1, 2, 3)

# **kwargs 收关键字参数为字典
def config(**kwargs):
    print(kwargs)
config(debug=True, port=8080)

# 顺序：普通参数 → 默认参数 → *args → **kwargs
def f(a, b=1, *args, **kwargs):
    pass

# 多返回值：本质是元组，自动解包
def divmod_(a, b):
    return a // b, a % b

q, r = divmod_(7, 2)   # q=3, r=1

# 类型注解（可选，运行时不检查）
def add(a: int, b: int) -> int:
    return a + b

函数即对象

def double(x):
    return x * 2

f = double              # 函数可以赋值给变量
f(3)                    # 6

def apply(func, value):  # 可以当参数传
    return func(value)
apply(double, 5)        # 10

# 匿名函数：只能写单个表达式
square = lambda x: x * x
sorted(words, key=lambda w: len(w))     # 最常见的用法

# 排序多关键字
users.sort(key=lambda u: (-u.score, u.name))

# 偏函数
from functools import partial
inc = partial(add, 1)
inc(5)                  # 6

def append_to(item, target=[]):     # 危险！
    target.append(item)
    return target

append_to(1)    # [1]
append_to(2)    # [1, 2]   —— 你以为会是 [2]

# 正确写法：用 None 做哨兵
def append_to(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

Java 的集合框架要选类型（ArrayList 还是 LinkedList？HashMap 还是 TreeMap？），Python 只有四种内置容器，覆盖了 95% 的场景。

// 数组：定长
int[] arr = {1, 2, 3};
arr.length;

// List
List<String> list = new ArrayList<>();
list.add("a");
list.add(0, "b");           // 指定位置插入
list.get(0);
list.set(0, "c");
list.remove(0);
list.size();
list.contains("a");
list.isEmpty();
Collections.sort(list);
list.subList(0, 2);

// Map
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
map.get("a");               // 没有返回 null
map.getOrDefault("b", 0);
map.containsKey("a");
map.remove("a");
map.keySet();

// Set
Set<String> set = new HashSet<>();
set.add("x");
set.contains("x");

// 元组：Java 14+ record
record Point(int x, int y) {}
Point p = new Point(1, 2);
p.x();

# list：什么都能装
lst = [1, 2, 3]
lst[0]                      # 索引
lst.append("a")             # 尾部追加
lst.insert(0, "b")
lst[0] = "c"
lst.pop()                   # 弹出末尾
lst.remove("b")             # 按值删除
len(lst)
"a" in lst
lst.sort()                  # 原地排序
lst[::-1]                   # 反转（返回新列表）
lst[0:2]                    # 切片

# 栈：直接用 list
stack = []
stack.append(1)
stack.pop()

# 队列：用 deque，别用 list（头部操作是 O(n)）
from collections import deque
q = deque()
q.append(1)                 # 右进
q.popleft()                 # 左出

# dict
d = {"a": 1}
d["a"]                      # 取不到抛 KeyError（不是返回 null）
d.get("b")                  # 安全取值，返回 None
d.get("b", 0)               # 带默认值
d["c"] = 3                  # 新增/覆盖
"a" in d
d.keys(); d.values(); d.items()
del d["a"]

# set
s = {"x"}
s.add("y")
"x" in s
{1, 2} | {2, 3}             # 并集
{1, 2} & {2, 3}             # 交集
{1, 2} - {2, 3}             # 差集

# tuple：不可变，可解包
t = (1, 2)
x, y = t                    # 解包
# t[0] = 9                  # TypeError

容器对照表

a = [1, 2, 3]
b = a               # b 和 a 指向同一个 list！
b.append(4)
print(a)            # [1, 2, 3, 4]  —— a 也被改了

c = a[:]            # 浅拷贝（一层）
d = a.copy()        # 同上
import copy
e = copy.deepcopy(a)  # 深拷贝，嵌套结构也能断开

Java 用 Stream 链式处理集合，Python 用推导式——一行搞定过滤 + 映射，可读性反而更高。如果你习惯 stream().filter().map().collect()，把它替换成推导式即可。

List<Integer> nums = List.of(1, 2, 3, 4, 5);

// 过滤 + 映射
List<Integer> squares = nums.stream()
        .filter(n -> n % 2 == 0)
        .map(n -> n * n)
        .collect(Collectors.toList());

int sum = nums.stream()
        .mapToInt(Integer::intValue)
        .sum();

// 转 Map
Map<Integer, String> m = nums.stream()
        .collect(Collectors.toMap(
            n -> n, n -> "v" + n));

// 分组
Map<Integer, List<Integer>> g = nums.stream()
        .collect(Collectors.groupingBy(n -> n % 2));

// 任意匹配
boolean anyEven = nums.stream()
        .anyMatch(n -> n % 2 == 0);

// 排序取前 3
nums.stream().sorted().limit(3).toList();

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

# 列表推导式：过滤 + 映射一步到位
squares = [n * n for n in nums if n % 2 == 0]

# 还能嵌套、能写条件表达式
matrix = [[i * j for j in range(3)] for i in range(3)]

# 字典推导式
m = {n: f"v{n}" for n in nums}

# 集合推导式（自动去重）
s = {n % 3 for n in nums}

# 生成器表达式：用 ()，惰性求值、不占内存
total = sum(n * n for n in nums)

# 分组用 defaultdict
from collections import defaultdict
g = defaultdict(list)
for n in nums:
    g[n % 2].append(n)

# 任意匹配
any_even = any(n % 2 == 0 for n in nums)   # ≈ anyMatch
all_pos = all(n > 0 for n in nums)         # ≈ allMatch

# 排序取前 3
sorted(nums)[:3]

# 求和 / 最大 / 最小
sum(nums); max(nums); min(nums)

# map / filter（能写推导式就别用它们）
list(map(lambda n: n * n, filter(lambda n: n % 2 == 0, nums)))

常用内置函数对照

Python 的 OOP 比 Java「轻」：没有访问修饰符关键字，没有方法重载，没有接口，但支持多继承和鸭子类型。self 必须显式写出来，这是最需要适应的点。

public class Animal {
    private final String name;      // 字段必须声明
    static int count = 0;           // 类变量

    public Animal(String name) {
        this.name = name;
        count++;
    }

    public void speak() {
        System.out.println(name + " 发出声音");
    }

    public String getName() { return name; }

    @Override
    public String toString() {
        return "Animal(" + name + ")";
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void speak() {
        System.out.println("汪");
    }
}

// 接口 + 抽象类
interface Flyable {
    void fly();
}

class Animal:
    count = 0                       # 类属性

    def __init__(self, name):       # 构造方法，self ≈ this
        self.name = name            # 实例属性随用随建
        Animal.count += 1

    def speak(self):                # 第一个参数必须是 self
        print(f"{self.name} 发出声音")

    @property                       # ≈ getter，但调用时不加 ()
    def display_name(self):
        return self.name.upper()

    def __str__(self):              # ≈ toString()
        return f"Animal({self.name})"

    def __repr__(self):             # 调试用表示
        return f"Animal({self.name!r})"


class Dog(Animal):                  # 继承用 ()
    def __init__(self, name):
        super().__init__(name)      # 必须显式调用

    def speak(self):                # 直接覆盖，无 @Override
        print("汪")


d = Dog("旺财")
d.speak()
print(d.name)
print(d.display_name)   # 属性式访问
isinstance(d, Animal)   # True，≈ instanceof
issubclass(Dog, Animal)

Java → Python 的 OOP 概念映射

dataclass：Java record / Lombok 的替代

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    age: int
    tags: list = field(default_factory=list)   # 可变默认值要用 factory

u = User("Alice", 30)
print(u)            # User(name='Alice', age=30, tags=[])
u2 = User("Alice", 30)
print(u == u2)      # True  —— 自动生成 __eq__

# 不可变版本（可哈希，能当字典键）
@dataclass(frozen=True)
class Point:
    x: int
    y: int

{Point(1, 2): "原点附近"}

语法骨架和 Java 很像，但有三个关键区别：没有受检异常、可以一次捕获多种、多了 else 分支。另外 Python 社区倡导 EAFP（先做再捕获）而不是 LBYL（先检查再做）。

try {
    int r = 10 / x;
    process(r);
} catch (ArithmeticException e) {
    logger.error(e.getMessage());
} catch (IOException | SQLException e) {
    // 一次捕获多种
    e.printStackTrace();
} catch (Exception e) {
    // 兜底
} finally {
    // 一定执行，用于释放资源
    cleanup();
}

// 抛出
throw new IllegalArgumentException("x 不能为 0");

// 自定义异常
class BizException extends RuntimeException {
    public BizException(String msg) { super(msg); }
}

// 受检异常必须声明
public void read() throws IOException { }

try:
    r = 10 / x
    process(r)
except ZeroDivisionError as e:
    print(f"除零: {e}")
except (ValueError, TypeError) as e:
    # 一次捕获多种，用元组
    print(e)
except Exception as e:
    # 兜底；永远别写裸 except:
    print(f"未知错误: {e}")
else:
    # 没有异常时执行（Java 没有）
    print("成功")
finally:
    cleanup()      # 一定执行


# 抛出：和 Java 的 throw 一样
raise ValueError("x 不能为 0")

# 重新抛出当前异常
except Exception:
    raise

# 自定义异常
class BizError(Exception):
    def __init__(self, msg, code=500):
        super().__init__(msg)
        self.code = code

# 没有"受检异常"，不需要 throws 声明
# 异常链
raise RuntimeError("包装后的错误") from original_error

EAFP vs LBYL：习惯要反过来

// 先检查，再操作
if (map.containsKey(key)) {
    value = map.get(key);
} else {
    value = "default";
}

if (file.exists()) {
    content = read(file);
}

# 先做，出错再处理（Easier to Ask Forgiveness）
try:
    value = d[key]
except KeyError:
    value = "default"

# 或者直接用 dict 提供的 API
value = d.get(key, "default")

try:
    with open(path) as f:
        content = f.read()
except FileNotFoundError:
    content = ""

常见异常类型对照

Java 的 package/import 和你熟悉的概念一一对应，但 Python 里「一个文件就是一个模块」，「一个目录就是一个包」，粒度更细。

package com.demo.service;

import java.util.List;
import java.util.ArrayList;
import java.util.*;                    // 通配
import static java.lang.Math.max;    // 静态导入

// 项目结构
// src/main/java/com/demo/
//   ├── App.java
//   └── service/UserService.java
//
// 目录结构必须和包名一致

// 依赖管理：pom.xml
// <dependency>
//   <groupId>com.google.guava</groupId>
//   <artifactId>guava</artifactId>
//   <version>33.0.0-jre</version>
// </dependency>

# 导入整个模块，用 模块.名字 访问
import math
math.sqrt(16)

# 别名（社区惯例：numpy 一律 as np）
import numpy as np
import pandas as pd

# 只导入需要的名字
from math import sqrt, pi
from collections import defaultdict

# 通配导入（不推荐，会污染命名空间）
from math import *

# 相对导入（同一个包内部）
from .utils import helper
from ..models import User

# 项目结构
# myproject/
#   ├── main.py
#   └── pkg/                 ← 目录名就是包名
#       ├── __init__.py      ← 标记为包，可为空
#       ├── utils.py         ← 模块
#       └── service.py

__name__ == "__main__" 到底在干什么

# utils.py
def helper():
    return "帮助函数"

print(f"模块 {__name__} 被加载了")

if __name__ == "__main__":
    # 只有"用 python utils.py 直接运行"时才会执行
    # 被别的文件 import 时，__name__ 是 "utils"，这里不执行
    print("作为脚本运行")
    helper()

这相当于 Java 的 public static void main 加上「可被 import」的双重身份。Python 的一个文件既是库又是可执行脚本，全靠这一行区分。

依赖管理与工程工具对照

python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate
pip install requests pandas pytest
pip freeze > requirements.txt    # 导出依赖

Python 的 with 语句等价于 Java 的 try-with-resources，而且更通用——任何实现了上下文管理器协议的对象都能用。

// try-with-resources：自动关闭
try (BufferedReader br = new BufferedReader(
         new FileReader("data.txt", StandardCharsets.UTF_8))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 写文件
try (BufferedWriter bw = new BufferedWriter(
         new FileWriter("out.txt", StandardCharsets.UTF_8))) {
    bw.write("hello");
    bw.newLine();
}

// 读取全部内容（Java 11+）
String content = Files.readString(Path.of("data.txt"));
List<String> lines = Files.readAllLines(Path.of("data.txt"));

# with ≈ try-with-resources，自动关闭
with open("data.txt", encoding="utf-8") as f:
    for line in f:                    # 直接迭代，逐行读
        print(line.rstrip())          # 行尾自带 \n

# 一次性读取
with open("data.txt", encoding="utf-8") as f:
    content = f.read()                # 整个字符串
with open("data.txt", encoding="utf-8") as f:
    lines = f.readlines()             # 每行一个元素
with open("data.txt", encoding="utf-8") as f:
    lines = [l.strip() for l in f]

# 写文件：w 覆盖，a 追加
with open("out.txt", "w", encoding="utf-8") as f:
    f.write("hello\n")
    print("world", file=f)            # 也能用 print

# 同时开多个文件
with open("in.txt") as src, open("out.txt", "w") as dst:
    dst.write(src.read())

更现代的路径操作：pathlib

from pathlib import Path

p = Path("data") / "logs" / "app.log"   # 用 / 拼路径，跨平台
p.exists()
p.is_file()
p.suffix              # ".log"
p.stem                # "app"
p.parent              # data/logs

# 读 / 写一行搞定
text = Path("a.txt").read_text(encoding="utf-8")
Path("b.txt").write_text("hi", encoding="utf-8")

# 遍历目录
for f in Path(".").glob("**/*.py"):
    print(f)

# 创建 / 删除目录
Path("out/nested").mkdir(parents=True, exist_ok=True)

JSON 读写（≈ Jackson 的极简版）

import json

data = {"name": "Alice", "tags": ["a", "b"], "age": 30}

# 对象 → 字符串
s = json.dumps(data, ensure_ascii=False, indent=2)

# 字符串 → 对象
obj = json.loads(s)

# 直接读写文件
with open("d.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

with open("d.json", encoding="utf-8") as f:
    obj = json.load(f)

Java 里需要引第三方库甚至自己写的东西，Python 大量已经内置。下面这张表是日常开发最高频的对照，建议收藏。

这几个特性是 Python 的「特色菜」，Java 里没有直接对应物。掌握它们，你写的就不再是「用 Python 语法的 Java 代码」。

装饰器：比 Java 注解更强大

Java 的注解（@Transactional、@Cacheable）靠 Spring 之类的框架在运行时/编译期用反射处理。Python 的装饰器本身就是一个包装函数的函数，不需要框架介入。

import functools, time, logging

def timer(func):
    @functools.wraps(func)              # 保留原函数的名字和文档
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        logging.info(f"{func.__name__} 耗时 {time.time() - start:.3f}s")
        return result
    return wrapper

@timer                                  # 等价于 work = timer(work)
def work():
    time.sleep(0.1)

# 带参数的装饰器：多一层嵌套
def retry(times=3):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception:
                    if i == times - 1:
                        raise
        return wrapper
    return decorator

@retry(times=5)
def fetch():
    ...

# 标准库自带的常用装饰器
@functools.lru_cache(maxsize=128)       # 结果缓存，≈ @Cacheable
@staticmethod / @classmethod / @property

生成器：惰性求值，内存友好

Java 里要处理百万行日志，你可能得写 Iterator + 状态机。Python 用 yield 几行搞定，而且天然懒执行——不占内存。

def read_large_file(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()          # 每次只产出一行，不占内存

for line in read_large_file("huge.log"):
    process(line)

# 生成器表达式：列表推导式换成 () 就是惰性的
squares = (n * n for n in range(10_000_000))   # 瞬间返回，不构建列表
next(squares)      # 0
next(squares)      # 1

def fib():
    a, b = 0, 1
    while True:                        # 无限序列也没问题
        yield a
        a, b = b, a + b

from itertools import islice
list(islice(fib(), 10))                # 取前 10 个

上下文管理器：with 背后的协议

# 自己实现一个 with 可用的对象（≈ AutoCloseable）
class DBConnection:
    def __enter__(self):
        self.conn = connect()
        return self.conn
    def __exit__(self, exc_type, exc_val, tb):
        self.conn.close()
        return False        # False 表示不吞异常

with DBConnection() as conn:
    conn.execute("select 1")

# 或者用装饰器写法，更简洁
from contextlib import contextmanager

@contextmanager
def timer(name):
    start = time.time()
    try:
        yield                                  # 分界线：yield 之前是进入，之后是退出
    finally:
        print(f"{name} 用了 {time.time()-start:.3f}s")

with timer("查询"):
    do_something()

解包与魔法方法

# 解包：极其常用
a, b = 1, 2
a, *rest = [1, 2, 3, 4]        # a=1, rest=[2,3,4]
*init, last = [1, 2, 3, 4]     # init=[1,2,3], last=4
first, *mid, last = range(5)
d = {"x": 1, "y": 2}
f(**d)                          # 字典解包成关键字参数

# 交换变量（Java 要临时变量）
a, b = b, a

# 魔法方法（dunder）：让自定义类像内置类型一样工作
class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, o):        # 支持 v1 + v2
        return Vector(self.x + o.x, self.y + o.y)
    def __len__(self):
        return 2
    def __eq__(self, o):         # 支持 ==
        return (self.x, self.y) == (o.x, o.y)
    def __hash__(self):
        return hash((self.x, self.y))
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

asyncio：Python 的异步

import asyncio

async def fetch(url):
    await asyncio.sleep(1)          # 模拟 IO
    return f"data from {url}"

async def main():
    # 并发执行，总耗时约 1 秒而不是 3 秒
    results = await asyncio.gather(
        fetch("a"), fetch("b"), fetch("c")
    )
    print(results)

asyncio.run(main())

如果你用过 Java 的 CompletableFuture 或 Kotlin 协程，这套模型是同一类思想：单线程事件循环 + await 让出控制权，适合 IO 密集型任务。

这 12 条是 Java 背景开发者最常踩的坑，按「踩坑频率 × 排查难度」排序。建议写代码前先扫一遍。

几个容易忽略的细节

• 排序方法返回值不同：list.sort() 原地排序返回 None，要新列表用 sorted(xs)。写 xs = xs.sort() 会得到 None。
• dict 缺键抛异常：d["k"] 取不到是 KeyError，不是返回 null。习惯用 d.get("k", default) 或 collections.defaultdict。
• 模块导入即执行：import foo 会把 foo.py 的顶层代码全跑一遍。把副作用代码放进 if __name__ == "__main__": 或函数里。
• 可变对象不能当 dict 键：list 不行，tuple 可以。自定义类要同时实现 __eq__ 和 __hash__。
• Python 没有 ++：i++ 是语法错误，写 i += 1。而且 a = b = 0; a += 1 这种"连等"含义和 Java 也不同。
• 字符串是常量池式共享：小整数（-5~256）和部分字符串会被 intern，所以 is 的结果不可预测，别依赖。

把最常用的操作压成一张表，用的时候直接查。后面是给 Java 工程师的四周上手路线。

一行速查

四周上手路线

工具链与配置建议