Python 基础语法 × Java 对比

说明：这份文档按你给的目录把 每一条内容都展开并给出 Python 语法 + 对应的 Java 比较 。每个小节都包含可复制运行的代码示例和关键点说明，便于你一边看一边在本地实现练习。

风格原则：以"工程师记忆友好"为目标，重点对比差异、常见坑、以及 Java 程序员该如何快速迁移到 Python 思维。

1 Python 基础入门

1.1 数据类型（常见）

Python（动态）常见类型：

int（整数）, float（浮点）, bool（布尔）, str（字符串）, bytes
容器类型：list, tuple, set, dict
NoneType（None）表示空
任意对象都是引用（对象模型）

Java（静态）常见类型：

原始类型：int, long, double, float, boolean, char, byte, short
引用类型：String, Integer（包装类），集合 List, Map, Set 等（需要泛型）

Python 示例

python 复制代码

# python
a = 10         # int
b = 3.14       # float
c = True       # bool
s = "hello"    # str
lst = [1,2,3]  # list
d = {"k": 1}   # dict

print(type(a), type(b), type(s), type(lst), type(d))

Java 示例（对比）

java 复制代码

// java
int a = 10;
double b = 3.14;
boolean c = true;
String s = "hello";
List<Integer> lst = new ArrayList<>(Arrays.asList(1,2,3));
Map<String,Integer> d = new HashMap<>();
d.put("k", 1);

关键对比：

Python 不需要声明类型，变量可随时指向不同类型；Java 需要声明类型（静态类型）。
Python 的数值类型在需要时自动升级（例如大整数），Java 有固定宽度（int 32 位等）。

1.2 变量与关键字

Python 不需 var/let，直接赋值；关键字示例：def, class, if, else, elif, for, while, try, except, finally, with, import, from, as, return, lambda, global, nonlocal, pass, break, continue, raise, yield.

Java 关键字示例：public, private, protected, class, interface, extends, implements, import, package, static, final, void, int, if, else, switch, try, catch, finally, throw, throws, new, this, super。

注意点 ：不要在 Python 中使用 Java 思维的"声明"，直接赋值即可。尽量避免用与关键字同名的变量（例如 list、str 等内置名也不推荐覆盖）。

1.3 语句 / 表达式 / 运算符

Python 中 and, or, not 用作逻辑运算；比较运算符 ==, !=, <, >；成员判断 in；同一行可以有表达式 x = 1 if cond else 2（三元表达式）。
Java 中逻辑运算 &&, ||, !；三元 cond ? a : b。

Python 示例 - 三元 & chain comparators

python 复制代码

x = 5
y = 10
res = "big" if x > 3 else "small"
# 链式比较：
if 0 < x < 10:
    print("x between 0 and 10")

Java 示例

java 复制代码

int x = 5;
String res = x > 3 ? "big" : "small";
if (0 < x && x < 10) {
    System.out.println("x between 0 and 10");
}

2 列表与元组

2.1 通用序列操作（索引、切片、长度）

Python（列表）

python 复制代码

lst = [10,20,30,40,50]
print(lst[0], lst[-1])     # 取第一个和最后一个
print(lst[1:4])            # 切片 -> [20,30,40]
print(len(lst))            # 长度

Java（ArrayList / 数组）

java 复制代码

int[] arr = {10,20,30,40,50};
System.out.println(arr[0]);      // 第一个
// ArrayList
List<Integer> lst = new ArrayList<>(Arrays.asList(10,20,30,40,50));
System.out.println(lst.get(2));  // index-based access
System.out.println(lst.size());

差异：

Python 支持切片（slice）语法 lst[a:b:c]，Java 原生数组/集合没有切片语法（需调用 subList 或自己实现）。
Python lst[-1] 语法很方便；Java 需 lst.get(lst.size()-1)。

2.2 列表常用操作（修改/增删/排序）

python 复制代码

lst = [1,2,3]
lst.append(4)
lst.insert(1, 9)
lst.pop()       # 删除并返回最后一个
lst.remove(2)   # 删除值 2
lst.sort()      # 就地排序

Java 对应（ArrayList）:

java 复制代码

List<Integer> lst = new ArrayList<>();
lst.add(1);
lst.add(1, 9); // insert at index 1
lst.remove(Integer.valueOf(2)); // remove by value
Collections.sort(lst);
int last = lst.remove(lst.size()-1); // pop

2.3 元组（tuple）

Python 中 tuple 是不可变序列：t = (1,2,3)。不能修改元素（适合不可变数据）。
Java 中没有直接等价的内置 tuple（可以用 List.of() 或自定义不可变类，或使用 record（Java 16+）或第三方 Pair/Triple）。

Python 元组示例

python 复制代码

t = (1, 2, 3)
# t[0] = 10  # 会报错：TypeError

Java 等价（使用 record 或 List.of）

java 复制代码

record Pair<A,B>(A a, B b) {}
Pair<Integer, Integer> p = new Pair<>(1, 2);
// 或
List<Integer> immutableList = List.of(1,2,3); // 不可变列表

2.4 列表与元组的区别 & 相互转换

Python: list() 将 tuple 转为 list；tuple() 将 list 转为 tuple。

python 复制代码

t = (1,2,3)
lst = list(t)
t2 = tuple(lst)

3 字符串（String）

3.1 字符串基本操作

python 复制代码

s = "Hello, world"
print(len(s))
print(s[0:5])           # 切片 "Hello"
print(s.lower(), s.upper())
print(s.replace("world", "Python"))
print(" ".join(["a","b","c"]))  # join

Java 对应：

java 复制代码

String s = "Hello, world";
System.out.println(s.length());
System.out.println(s.substring(0,5)); // "Hello"
System.out.println(s.toLowerCase());
System.out.println(s.replace("world", "Java"));
String joined = String.join(" ", "a","b","c");

3.2 字符串格式化

Python（f-strings, format）：

python 复制代码

name = "Tom"
age = 30
print(f"{name} is {age} years old")
print("{} is {}".format(name, age))

Java（String.format 或 printf）：

java 复制代码

String name = "Tom";
int age = 30;
System.out.println(String.format("%s is %d years old", name, age));
System.out.printf("%s is %d years old%n", name, age);

差异：

Python f-string 很简洁，并且允许内联表达式 f"{value:.2f}"。
Java 需要 String.format 或 MessageFormat，拼接多字段推荐使用 StringBuilder（性能）或 String.format（可读）。

3.3 常用字符串方法（Python）

s.split(sep), s.strip(), s.startswith(), s.endswith(), s.find(), s.count()

Java 同类方法普遍存在于 String，名称基本相同：split, trim, startsWith, endsWith, indexOf, contains (Java contains 与 Python in)。

4 字典（映射 Map）

4.1 Python 字典：创建与访问

python 复制代码

d = {"a":1, "b":2}
print(d["a"])           # 1
print(d.get("c", 0))    # 如果不存在，返回默认 0
d["c"] = 3
for k, v in d.items():
    print(k, v)

4.2 Java Map（HashMap）

java 复制代码

Map<String,Integer> d = new HashMap<>();
d.put("a", 1);
System.out.println(d.get("a")); // 1
System.out.println(d.getOrDefault("c", 0));
for (Map.Entry<String,Integer> e : d.entrySet()) {
    System.out.println(e.getKey() + " " + e.getValue());
}

4.3 常用操作对比

Python: keys(), values(), items(), pop, setdefault, in 操作符用于检测键是否存在。
Java: keySet(), values(), entrySet(), remove(key), containsKey(key); Java 8+ 有 computeIfAbsent、merge 等高级方法。

5 条件、循环和其他语句

5.1 import 的使用

Python：

python 复制代码

# 导入模块
import math
from datetime import datetime
from os.path import join as path_join

Java：

java 复制代码

import java.util.List;
import java.time.LocalDateTime;

差异：Python 模块是运行时导入，可以在函数内部导入（延迟导入）；Java 的 import 是编译时的，主要是命名空间引用。

5.2 别样的赋值（多重赋值、解构）

python 复制代码

a, b = 1, 2          # 多重赋值
x, *rest = [1,2,3,4] # 解包

Java 可用多行或创建数组/对象；从 Java 10 可用 var 推断局部变量类型，但没有解包语法（需要手动拆分）。

5.3 语句块（缩进 vs 大括号）

Python 使用缩进 表示作用域（强制）;
Java 使用 {} 大括号表示块。

别踩坑：Python 缩进错误是常见错误，确保编辑器配置一致（建议使用 4 空格）。

5.4 条件语句

Python：

python 复制代码

if x > 0:
    print("positive")
elif x == 0:
    print("zero")
else:
    print("negative")

Java：

java 复制代码

if (x > 0) {
    System.out.println("positive");
} else if (x == 0) {
    System.out.println("zero");
} else {
    System.out.println("negative");
}

5.5 循环（for / while / for-each）

Python：

python 复制代码

# 遍历 list
for item in [1,2,3]:
    print(item)

# 使用 range
for i in range(5):  # 0..4
    print(i)

# while
i = 0
while i < 5:
    print(i)
    i += 1

# for-else (当循环正常结束才执行 else)
for x in [1,2,3]:
    if x==0:
        break
else:
    print("completed")

Java：

java 复制代码

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}
for (Integer item : Arrays.asList(1,2,3)) {
    System.out.println(item);
}
int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

注意：Python 的 for 是迭代器式的（可迭代对象），for-else 在 Java 中没有直接等价。

5.6 `pass` / `continue` / `break`

Python：pass 表示空操作，占位使用；continue 跳过当前循环，break 退出循环。
Java：无 pass（可以用空语句 ; 或注释），continue、break 同理。

6 函数（Function）

6.1 定义 & 调用

Python：

python 复制代码

def add(x, y):
    """返回 x + y"""
    return x + y

print(add(1,2))

Java（方法通常在类内）：

java 复制代码

public class Util {
    public static int add(int x, int y) {
        return x + y;
    }
}
// 调用： Util.add(1,2)

对比：

Python 顶层就能定义函数（模块级）；Java 必须在类中定义方法（静态方法或实例方法）。
Python 支持函数是第一类对象（可作为参数、返回值），Java 在 Java 8 之后通过 lambda + functional interface 也能实现类似，但语法不同。

6.2 参数（默认参数 / 可变参数 / 命名参数）

Python：

python 复制代码

def f(a, b=2, *args, **kwargs):
    print(a, b, args, kwargs)

f(1, 3, 4, 5, x=10)

*args 捕获位置可变参数（元组）
**kwargs 捕获关键字参数（字典）

Java（varargs）：

java 复制代码

public static void f(int a, int... args) {
    // args 是数组
}
f(1, 2, 3);

Java 没有 **kwargs 式的直接语法（可用 Map 传参或构建对象参数）。

6.3 变量作用域（local / global / nonlocal）

Python：

默认函数内部变量是局部（local）。
global var 用于在函数中修改模块变量。
nonlocal 用于闭包中修改外层非全局变量。

python 复制代码

x = 1
def f():
    global x
    x = 10

Java：

方法内变量是局部，类字段为成员变量（可以被方法直接访问），没有 global 关键字；如果要修改外部变量，通常需要使用字段或对象属性。

6.4 返回值、递归、匿名函数

Python：

python 复制代码

def factorial(n):
    return 1 if n <= 1 else n * factorial(n-1)

# 匿名 lambda
square = lambda x: x*x

Java：

递归写法类似（注意栈深度）
匿名函数（Java 8+ lambda）：

java 复制代码

Function<Integer,Integer> square = x -> x*x;

6.5 闭包与高阶函数

Python：

python 复制代码

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

add3 = make_adder(3)
print(add3(10))  # 13

Java（通过对象或 lambda 模拟）：

java 复制代码

Function<Integer, Integer> makeAdder(int n) {
    return x -> x + n;
}

注意点：

Python 闭包的自由变量若需修改需要 nonlocal。
Java lambda 捕获的是 effectively final 的局部变量（不能在 lambda 内改变外部变量，除非使用数组/容器封装）。

7 面向对象编程（OOP）

7.1 Python 的类与实例

python 复制代码

class Person:
    species = "Homo sapiens"   # 类变量
    def __init__(self, name, age):
        self.name = name       # 实例变量
        self.age = age

    def greet(self):
        return f"Hi, I'm {self.name}"

p = Person("Alice", 30)
print(p.greet())
print(Person.species)

7.2 Java 的类与对象（对比）

java 复制代码

public class Person {
    public static String species = "Homo sapiens";
    private String name;
    private int age;

    public Person(String name, int age) { // constructor
        this.name = name;
        this.age = age;
    }

    public String greet() {
        return "Hi, I'm " + name;
    }
}

// 使用：
Person p = new Person("Alice", 30);
System.out.println(p.greet());

关键差异：

Python 没有私有强制机制（有命名约定 _protected 和 __mangled），Java 有 private/protected/public 强制访问控制。
Python 方法第一个参数显式是 self（指向实例）；Java 使用隐式 this。

7.3 继承、多态、封装

Python 继承：

python 复制代码

class Student(Person):
    def __init__(self, name, age, stu_id):
        super().__init__(name, age)
        self.stu_id = stu_id

Java 继承：

java 复制代码

public class Student extends Person {
    private String stuId;
    public Student(String name, int age, String stuId) {
        super(name, age);
        this.stuId = stuId;
    }
}

多重继承：

Python 支持多重继承（MRO 决定方法解析顺序）。
Java 不支持类的多重继承，但支持实现多个接口；自 Java 8 起接口可含默认方法（default methods），可部分弥补。

7.4 抽象类、接口

Python 有 abc 模块支持抽象基类（ABC）。
Java 有 abstract class 和 interface，接口是常用的多态方式。

7.5 类的专有方法（Python magic methods）

Python 常见魔法方法：

__init__, __str__, __repr__, __len__, __iter__, __enter__, __exit__, __eq__, __lt__ 等。这些用于定制对象行为（像 JS 的 Symbol）。

Java 使用接口（Comparable）或覆盖 toString(), equals(), hashCode() 等。

8 异常与文件处理

8.1 异常处理

Python：

python 复制代码

try:
    x = 1 / 0
except ZeroDivisionError as e:
    print("division by zero:", e)
except Exception as e:
    print("other error", e)
finally:
    print("cleanup")

Java：

java 复制代码

try {
    int x = 1 / 0;
} catch (ArithmeticException e) {
    System.out.println("division by zero: " + e);
} catch (Exception e) {
    System.out.println("other error: " + e);
} finally {
    System.out.println("cleanup");
}

Checked vs Unchecked（Java 特性）：

Java 有受检异常（checked exceptions）和非受检异常（RuntimeException）。方法声明时可 throws IOException 强制调用方处理。
Python 没有编译时强制捕捉异常的机制。

8.2 自定义异常

Python：

python 复制代码

class MyError(Exception):
    pass

raise MyError("something wrong")

Java：

java 复制代码

public class MyError extends Exception {
    public MyError(String msg) { super(msg); }
}
throw new MyError("something wrong");

8.3 文件操作

Python（建议使用 with，自动管理资源）:

python 复制代码

# 写文件
with open("data.txt", "w", encoding="utf-8") as f:
    f.write("hello\n")

# 读文件
with open("data.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

Java（推荐 try-with-resources，Java 7+）:

java 复制代码

try (BufferedWriter writer = Files.newBufferedWriter(Paths.get("data.txt"), StandardCharsets.UTF_8)) {
    writer.write("hello");
} catch (IOException e) {
    e.printStackTrace();
}

try (BufferedReader reader = Files.newBufferedReader(Paths.get("data.txt"), StandardCharsets.UTF_8)) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

对比重点：

Python with open(...) 相当于 Java 的 try (resource)，都能确保资源关闭。
Python 简洁，读写文本文件的代码行数通常更少。

9 常用进阶对比 & 工程实践建议

9.1 包管理 / 虚拟环境

Python：venv / virtualenv / conda，包管理 pip（requirements.txt 或 pyproject.toml + Poetry）。
Java：Maven / Gradle 管理依赖与构建。

建议：为每个 Python 项目启用虚拟环境（隔离依赖），类似 Java 的每个项目使用单独的 Maven/Gradle 配置。

9.2 单元测试

Python：unittest、pytest（推荐 pytest 简洁强大）。
Java：JUnit（常用 JUnit5） + Mockito。

9.3 风格与 linter

Python：PEP8（工具 flake8、black 格式化）。
Java：Google Java Style、Checkstyle、SpotBugs。

9.4 性能 / 类型提示

Python 默认动态类型，运行时开销较大；若需类型检查推荐使用 mypy（静态类型检查）和类型注解（Python 3.6+）。
Java 编译时类型检查，运行时更快（JIT 优化）。

示例：Python 类型注解

python 复制代码

def add(a: int, b: int) -> int:
    return a + b

10 常见问题 & 对 Java 程序员的迁移建议

从 Java 到 Python 的最大差异是什么？
- 最大差异是动态类型与缩进式语法，以及"函数即对象"的思想。Python 更灵活、脚本化更强，但需要注意类型和性能。
是否要学全部 Python 特性？
- 不需要。优先学数据结构、函数、面向对象、文件与异常 。后续针对 AI 需要学 numpy, pandas, torch, transformers。
如何把 Python 与 Java 结合？
- 常见模式：把 Python 做为模型/原型服务（REST/gRPC）部署，Java 调用 API；或把核心逻辑使用 Python 实现并暴露 HTTP 接口由 Java 调用。长期也可将模型导出为 ONNX 并用 Java 的 ONNXRuntime 调用以减少跨语言复杂度。
调试技巧
- Python: 使用 pdb、ipdb、或更现代的 debugpy（与 VSCode 集成）。
- Java 程序员可使用熟悉的 IDE（IntelliJ）同时调试 Java 与 Python 服务（分别启动断点）。

Python 基础语法 × Java 对比