从 Java 开发者视角出发，全面对比了 Java 与 Python 在环境搭建、语法基础、数据类型、控制流、数据结构、函数、面向对象、异常处理、模块、文件操作、数据库及并发编程等方面的核心差异。文章通过大量代码示例展示了两种语言在实现相同功能时的写法区别，帮助 Java 开发者快速掌握 Python 核心语法与实战技巧，并提供了简易 RESTful API 服务的完整案例。适合希望拓展技术栈、利用 Python 进行数据分析或快速开发的 Java 工程师阅读。
作为一名 Java 开发者，你可能已经习惯了强类型、编译型、面向对象的编程范式。Java 以其严谨性、健壮性和广泛的企业级应用而闻名，但在某些场景下，它的 "重量级" 特性反而成为了束缚。
Python，作为一门解释型、动态类型的语言，正在人工智能、数据分析、自动化脚本、快速原型开发等领域大放异彩。对于 Java 开发者来说，掌握 Python 不仅能拓宽技术视野，更能在合适的场景下选择更高效的工具。
本教程将从 Java 开发者的视角，通过对比两种语言的异同，带你快速掌握 Python 的核心语法和实战技巧。我们不会面面俱到，但会直击要点，让你用最短的时间具备 Python 开发能力。
在 Java 世界，我们需要安装 JDK（Java Development Kit），配置环境变量，通常还会使用 Maven 或 Gradle 进行项目管理。
Python 的环境搭建则简单得多：
python --version # 或 python3 --version
pip --version # 或 pip3 --version
Java 开发者常用的 IDE 如 IntelliJ IDEA、Eclipse 都有优秀的 Python 插件支持。此外，PyCharm（与 IDEA 同属 JetBrains）是 Python 专用 IDE，VS Code 也有出色的 Python 支持。
Java 版本：
import lombok.extern.slf4j.Slf4j;
/**
* 第一个 Java 程序
* 输出 "Hello, World!"
*/
@Slf4j
public class HelloWorld {
public static void main(String[] args) {
log.info("Hello, World!");
}
}
Python 版本：
# 第一个 Python 程序
# 输出 "Hello, World!"
print("Hello, World!")
Java 是静态类型语言：
Python 是动态类型语言：
| Java 类型 | Python 类型 | 说明 |
|---|---|---|
| int | int | 整数，Python3 中 int 可表示任意大小整数 |
| long | int | Python 中没有 long，int 可自动扩展 |
| float | float | 单精度浮点数 |
| double | float | Python 中 float 实际是双精度 |
| boolean | bool | 布尔值，Python 中是 True/False |
| char | str | Python 中没有 char，用长度为 1 的字符串表示 |
| String | str | 字符串，Python 中用单引号或双引号 |
Java：
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
/**
* 变量定义与使用示例
*/
@Slf4j
public class VariableDemo {
public static void main(String[] args) {
// 声明并初始化各种类型变量
int age = 30;
double height = 1.85;
boolean isStudent = false;
String name = "Alice";
// 变量使用
log.info("姓名：{}", name);
log.info("年龄：{}", age);
// 类型转换
String ageStr = String.valueOf(age);
if (StringUtils.hasText(ageStr)) {
log.info("年龄字符串：{}", ageStr);
}
}
}
Python：
# 变量定义与使用示例
# 直接赋值，无需声明类型
age = 30
height = 1.85
is_student = False
name = "Alice"
# 变量使用
print(f"姓名：{name}")
print(f"年龄：{age}")
# 类型转换
age_str = str(age)
if age_str: # Python 中非空字符串即为 True
print(f"年龄字符串：{age_str}")
Java：
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
/**
* 字符串操作示例
*/
@Slf4j
public class StringDemo {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "World";
// 字符串拼接
String greeting = str1 + ", " + str2 + "!";
log.info(greeting);
// 字符串长度
log.info("长度：{}", greeting.length());
// 字符串截取
String substr = greeting.substring(0, 5);
log.info("子串：{}", substr);
// 字符串分割
String[] parts = "a,b,c,d".split(",");
log.info("分割后第一个元素：{}", parts[0]);
// 字符串格式化
String formatted = String.format("Name: %s, Age: %d", "Bob", 25);
log.info(formatted);
}
}
Python：
# 字符串操作示例
str1 = "Hello"
str2 = "World"
# 字符串拼接
greeting = f"{str1}, {str2}!"
print(greeting)
# 字符串长度
print(f"长度：{len(greeting)}")
# 字符串截取（切片）
substr = greeting[0:5]
print(f"子串：{substr}")
# 字符串分割
parts = "a,b,c,d".split(",")
print(f"分割后第一个元素：{parts[0]}")
# 字符串格式化
formatted = f"Name: {'Bob'}, Age: {25}"
print(formatted)
Java：
import lombok.extern.slf4j.Slf4j;
/**
* 条件语句示例
*/
@Slf4j
public class ConditionDemo {
public static void main(String[] args) {
int score = 85;
if (score >= 90) {
log.info("优秀");
} else if (score >= 80) {
log.info("良好");
} else if (score >= 60) {
log.info("及格");
} else {
log.info("不及格");
}
// 三元运算符
String result = score >= 60 ? "通过" : "未通过";
log.info(result);
}
}
Python：
# 条件语句示例
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 60:
print("及格")
else:
print("不及格")
# 三元运算符
result = "通过" if score >= 60 else "未通过"
print(result)
Java：
import lombok.extern.slf4j.Slf4j;
import com.google.common.collect.Lists;
import java.util.List;
/**
* 循环语句示例
*/
@Slf4j
public class LoopDemo {
public static void main(String[] args) {
List<String> fruits = Lists.newArrayList("苹果", "香蕉", "橙子");
// for 循环遍历集合
for (String fruit : fruits) {
log.info(fruit);
}
// 传统 for 循环
for (int i = 0; i < 5; i++) {
log.info("计数：{}", i);
}
// while 循环
int count = 0;
while (count < 3) {
log.info("While 计数：{}", count);
count++;
}
}
}
Python：
# 循环语句示例
fruits = ["苹果", "香蕉", "橙子"]
# for 循环遍历集合
for fruit in fruits:
print(fruit)
# for 循环遍历范围
for i in range(5):
print(f"计数：{i}")
# while 循环
count = 0
while count < 3:
print(f"While 计数：{count}")
count += 1
Java：
import lombok.extern.slf4j.Slf4j;
/**
* 循环控制示例
*/
@Slf4j
public class LoopControlDemo {
public static void main(String[] args) {
// break 示例
for (int i = 0; i < 10; i++) {
if (i == 5) {
break; // 跳出循环
}
log.info("Break 示例：{}", i);
}
// continue 示例
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
continue; // 跳过本次循环
}
log.info("Continue 示例：{}", i);
}
}
}
Python：
# 循环控制示例
# break 示例
for i in range(10):
if i == 5:
break # 跳出循环
print(f"Break 示例：{i}")
# continue 示例
for i in range(10):
if i % 2 == 0:
continue # 跳过本次循环
print(f"Continue 示例：{i}")
Java 集合框架
Java 的 ArrayList 对应 Python 的 list：
Java：
import lombok.extern.slf4j.Slf4j;
import com.google.common.collect.Lists;
import org.springframework.util.CollectionUtils;
import java.util.List;
/**
* List 操作示例
*/
@Slf4j
public class ListDemo {
public static void main(String[] args) {
// 创建列表
List<String> fruits = Lists.newArrayList("苹果", "香蕉", "橙子");
// 添加元素
fruits.add("葡萄");
// 获取元素
String firstFruit = fruits.get(0);
log.info("第一个水果：{}", firstFruit);
// 修改元素
fruits.set(1, "草莓");
// 删除元素
fruits.remove(2);
// 检查元素是否存在
boolean hasApple = fruits.contains("苹果");
log.info("是否包含苹果：{}", hasApple);
// 列表大小
log.info("列表大小：{}", fruits.size());
// 遍历列表
if (!CollectionUtils.isEmpty(fruits)) {
for (String fruit : fruits) {
log.info(fruit);
}
}
}
}
Python：
# 列表操作示例
# 创建列表
fruits = ["苹果", "香蕉", "橙子"]
# 添加元素
fruits.append("葡萄")
# 获取元素
first_fruit = fruits[0]
print(f"第一个水果：{first_fruit}")
# 修改元素
fruits[1] = "草莓"
# 删除元素
del fruits[2]
# 检查元素是否存在
has_apple = "苹果" in fruits
print(f"是否包含苹果：{has_apple}")
# 列表大小
print(f"列表大小：{len(fruits)}")
# 遍历列表
if fruits: # 非空列表即为 True
for fruit in fruits:
print(fruit)
Java 的 HashSet 对应 Python 的 set：
Java：
import lombok.extern.slf4j.Slf4j;
import com.google.common.collect.Sets;
import org.springframework.util.CollectionUtils;
import java.util.Set;
/**
* Set 操作示例
*/
@Slf4j
public class SetDemo {
public static void main(String[] args) {
// 创建集合
Set<String> fruits = Sets.newHashSet("苹果", "香蕉", "橙子", "苹果");
// 添加元素
fruits.add("葡萄");
// 检查元素是否存在
boolean hasApple = fruits.contains("苹果");
log.info("是否包含苹果：{}", hasApple);
// 集合大小
log.info("集合大小：{}", fruits.size());
// 删除元素
fruits.remove("香蕉");
// 遍历集合
if (!CollectionUtils.isEmpty(fruits)) {
for (String fruit : fruits) {
log.info(fruit);
}
}
// 集合运算
Set<String> set1 = Sets.newHashSet("a", "b", "c");
Set<String> set2 = Sets.newHashSet("b", "c", "d");
// 交集
Set<String> intersection = Sets.intersection(set1, set2);
log.info("交集：{}", intersection);
// 并集
Set<String> union = Sets.union(set1, set2);
log.info(, union);
}
}
Python：
# 集合操作示例
# 创建集合
fruits = {"苹果", "香蕉", "橙子", "苹果"}
# 自动去重
# 添加元素
fruits.add("葡萄")
# 检查元素是否存在
has_apple = "苹果" in fruits
print(f"是否包含苹果：{has_apple}")
# 集合大小
print(f"集合大小：{len(fruits)}")
# 删除元素
fruits.remove("香蕉")
# 遍历集合
if fruits: # 非空集合即为 True
for fruit in fruits:
print(fruit)
# 集合运算
set1 = {"a", "b", "c"}
set2 = {"b", "c", "d"}
# 交集
intersection = set1 & set2
print(f"交集：{intersection}")
# 并集
union = set1 | set2
print(f"并集：{union}")
Java 的 HashMap 对应 Python 的 dict：
Java：
import lombok.extern.slf4j.Slf4j;
import com.google.common.collect.Maps;
import org.springframework.util.CollectionUtils;
import java.util.Map;
/**
* Map 操作示例
*/
@Slf4j
public class MapDemo {
public static void main(String[] args) {
// 创建映射
Map<String, Integer> fruitPrices = Maps.newHashMap();
// 添加键值对
fruitPrices.put("苹果", 10);
fruitPrices.put("香蕉", 5);
fruitPrices.put("橙子", 8);
// 获取值
int applePrice = fruitPrices.get("苹果");
log.info("苹果价格：{}", applePrice);
// 检查键是否存在
boolean hasBanana = fruitPrices.containsKey("香蕉");
log.info("是否有香蕉：{}", hasBanana);
// 映射大小
log.info("映射大小：{}", fruitPrices.size());
// 删除键值对
fruitPrices.remove("香蕉");
// 遍历映射
if (!CollectionUtils.isEmpty(fruitPrices)) {
for (Map.Entry<String, Integer> entry : fruitPrices.entrySet()) {
log.info("{}: {}", entry.getKey(), entry.getValue());
}
}
}
}
Python：
# 字典操作示例
# 创建字典
fruit_prices = {}
# 添加键值对
fruit_prices["苹果"] = 10
fruit_prices["香蕉"] = 5
fruit_prices["橙子"] = 8
# 获取值
apple_price = fruit_prices["苹果"]
print(f"苹果价格：{apple_price}")
# 检查键是否存在
has_banana = "香蕉" in fruit_prices
print(f"是否有香蕉：{has_banana}")
# 字典大小
print(f"字典大小：{len(fruit_prices)}")
# 删除键值对
del fruit_prices["香蕉"]
# 遍历字典
if fruit_prices: # 非空字典即为 True
for fruit, price in fruit_prices.items():
print(f"{fruit}: {price}")
Python 特有的元组类型，类似不可变的列表：
# 元组操作示例
# 创建元组
point = (10, 20)
colors = ("红", "绿", "蓝")
# 获取元素
x = point[0]
print(f"X 坐标：{x}")
# 元组大小
print(f"颜色数量：{len(colors)}")
# 遍历元组
for color in colors:
print(color)
# 元组不可修改，以下代码会报错
# point[0] = 15
# 元组解包
a, b, c = colors
print(f"解包后：a={a}, b={b}, c={c}")
# 单元素元组需要加逗号
single_element = (5,)
print(f"单元素元组：{single_element}")
Java：
import lombok.extern.slf4j.Slf4j;
/**
* 方法定义与调用示例
*/
@Slf4j
public class MethodDemo {
/**
* 计算两个整数的和
* @param a 第一个整数
* @param b 第二个整数
* @return 两个整数的和
*/
public static int add(int a, int b) {
return a + b;
}
/**
* 打印问候语
* @param name 姓名
*/
public static void greet(String name) {
log.info("Hello, {}!", name);
}
public static void main(String[] args) {
// 调用有返回值的方法
int sum = add(3, 5);
log.info("3 + 5 = {}", sum);
// 调用无返回值的方法
greet("Alice");
}
}
Python：
# 函数定义与调用示例
def add(a, b):
""" 计算两个数的和
@param a: 第一个数
@param b: 第二个数
@return: 两个数的和
"""
return a + b
def greet(name):
""" 打印问候语
@param name: 姓名
"""
print(f"Hello, {name}!")
# 调用有返回值的函数
sum_result = add(3, 5)
print(f"3 + 5 = {sum_result}")
# 调用无返回值的函数
greet("Alice")
Python 支持多种灵活的参数形式，这是与 Java 方法参数的主要区别：
# 函数参数示例
# 位置参数
def power(base, exponent):
"""计算 base 的 exponent 次方"""
result = 1
for _ in range(exponent):
result *= base
return result
print(power(2, 3)) # 8
# 默认参数
def greet(name, greeting="Hello"):
"""带默认值的问候函数"""
print(f"{greeting}, {name}!")
greet("Alice") # Hello, Alice!
greet("Bob", "Hi") # Hi, Bob!
# 关键字参数
def describe_person(name, age, city):
"""描述一个人的信息"""
print(f"{name} is {age} years old and lives in {city}")
# 可以不按顺序传递参数
describe_person(age=30, name="Charlie", city="New York")
# 可变参数
def sum_numbers(*numbers):
"""计算任意数量数字的和"""
total = 0
for num in numbers:
total += num
return total
(sum_numbers(, , , ))
():
key, value info.items():
()
print_info(name=, age=, occupation=)
Python 函数可以返回多个值，这在 Java 中需要通过自定义对象或数组实现：
Java：
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
/**
* 方法返回多个值示例
*/
@Slf4j
public class MultipleReturnDemo {
/**
* 存储两个整数的结果
*/
@Data
public static class IntResult {
private int sum;
private int product;
public IntResult(int sum, int product) {
this.sum = sum;
this.product = product;
}
}
/**
* 计算两个整数的和与积
* @param a 第一个整数
* @param b 第二个整数
* @return 包含和与积的 IntResult 对象
*/
public static IntResult calculate(int a, int b) {
int sum = a + b;
int product = a * b;
return new IntResult(sum, product);
}
public static void main(String[] args) {
IntResult result = calculate(3, );
log.info(, result.getSum());
log.info(, result.getProduct());
}
}
Python：
# 函数返回多个值示例
def calculate(a, b):
""" 计算两个数的和与积
@param a: 第一个数
@param b: 第二个数
@return: 包含和与积的元组
"""
sum_result = a + b
product_result = a * b
return sum_result, product_result # 实际返回一个元组
# 接收多个返回值
sum_val, product_val = calculate(3, 4)
print(f"和：{sum_val}")
print(f"积：{product_val}")
# 也可以作为单个元组接收
result = calculate(3, 4)
print(f"结果元组：{result}")
Java：
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
/**
* 类与对象基础示例
*/
@Slf4j
public class OOPBasics {
/**
* 学生类
*/
@Data
public static class Student {
private String name;
private int age;
private String major;
/**
* 构造方法
* @param name 姓名
* @param age 年龄
* @param major 专业
*/
public Student(String name, int age, String major) {
this.name = name;
this.age = age;
this.major = major;
}
/**
* 学生自我介绍
*/
public void introduce() {
log.info("大家好，我叫{},今年{}岁，专业是{}", name, age, major);
}
/**
* 学生学习
* @param course 课程名称
*/
public void study(String course) {
log.info("{}正在学习{}", name, course);
}
}
public static void main(String[] args) {
// 创建对象
Student (, , );
student.introduce();
student.study();
log.info(, student.getName());
student.setAge();
log.info(, student.getAge());
}
}
Python：
# 类与对象基础示例
class Student:
"""学生类"""
def __init__(self, name, age, major):
""" 构造方法
@param name: 姓名
@param age: 年龄
@param major: 专业
"""
self.name = name
self.age = age
self.major = major
def introduce(self):
"""学生自我介绍"""
print(f"大家好，我叫{self.name}，今年{self.age}岁，专业是{self.major}")
def study(self, course):
""" 学生学习
@param course: 课程名称
"""
print(f"{self.name}正在学习{course}")
# 创建对象
student = Student("张三", 20, "计算机科学")
# 调用对象方法
student.introduce()
student.study("Python 编程")
# 访问对象属性
print(f"学生姓名：{student.name}")
# 修改对象属性
student.age = 21
print(f"修改后的年龄：{student.age}")
Java：
import lombok.extern.slf4j.Slf4j;
/**
* 继承示例
*/
@Slf4j
public class InheritanceDemo {
/**
* 动物类（父类）
*/
public static class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
log.info("{}在吃东西", name);
}
public void sleep() {
log.info("{}在睡觉", name);
}
}
/**
* 狗类（子类）
*/
public static class Dog extends Animal {
public Dog(String name) {
super(name);
}
// 重写父类方法
@Override
public void eat() {
log.info("{}在吃骨头", name);
}
// 子类特有方法
public void bark() {
log.info("{}在汪汪叫", name);
}
}
/**
* 猫类（子类）
*/
{
{
(name);
}
{
log.info(, name);
}
{
log.info(, name);
}
}
{
();
();
dog.eat();
dog.sleep();
((Dog) dog).bark();
cat.eat();
cat.sleep();
((Cat) cat).meow();
}
}
Python：
# 继承示例
class Animal:
"""动物类（父类）"""
def __init__(self, name):
self.name = name
def eat(self):
print(f"{self.name}在吃东西")
def sleep(self):
print(f"{self.name}在睡觉")
class Dog(Animal):
"""狗类（子类）"""
def eat(self):
"""重写父类方法"""
print(f"{self.name}在吃骨头")
def bark(self):
"""子类特有方法"""
print(f"{self.name}在汪汪叫")
class Cat(Animal):
"""猫类（子类）"""
def eat(self):
"""重写父类方法"""
print(f"{self.name}在吃鱼")
def meow(self):
"""子类特有方法"""
print(f"{self.name}在喵喵叫")
dog = Dog()
cat = Cat()
dog.eat()
dog.sleep()
dog.bark()
cat.eat()
cat.sleep()
cat.meow()
Java：
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
/**
* 封装示例
*/
@Slf4j
public class EncapsulationDemo {
/**
* 银行账户类
*/
@Getter
public static class BankAccount {
private String accountNumber;
@Setter
private String ownerName;
private double balance;
/**
* 构造方法
* @param accountNumber 账号
* @param ownerName 所有者姓名
* @param initialBalance 初始余额
*/
public BankAccount(String accountNumber, String ownerName, double initialBalance) {
this.accountNumber = accountNumber;
this.ownerName = ownerName;
this.balance = initialBalance > 0 ? initialBalance : 0;
}
/**
* 存款
* @param amount 存款金额
*/
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
log.info("存款成功，金额：{}", amount);
} else {
log.error("存款金额必须为正数");
}
}
/**
* 取款
* amount 取款金额
* 是否取款成功
*/
{
(amount > && amount <= balance) {
balance -= amount;
log.info(, amount);
;
}
log.error();
;
}
{
log.info();
balance;
}
}
{
(, , );
log.info(, account.getAccountNumber());
log.info(, account.getOwnerName());
log.info(, account.getBalance());
account.deposit();
log.info(, account.getBalance());
account.withdraw();
(withdrawSuccess) {
log.info(, account.getBalance());
}
account.setOwnerName();
log.info(, account.getOwnerName());
}
}
Python：
# 封装示例
class BankAccount:
"""银行账户类"""
def __init__(self, account_number, owner_name, initial_balance):
self._account_number = account_number # 单下划线表示受保护
self._owner_name = owner_name
self.__balance = initial_balance if initial_balance > 0 else 0 # 双下划线表示私有
@property
def account_number(self):
"""账号的 getter 方法"""
return self._account_number
@property
def owner_name(self):
"""户主姓名的 getter 方法"""
return self._owner_name
@owner_name.setter
def owner_name(self, new_name):
"""户主姓名的 setter 方法"""
self._owner_name = new_name
def deposit(self, amount):
""" 存款
@param amount: 存款金额
"""
if amount > 0:
self.__balance += amount
print(f"存款成功，金额：{amount}")
else:
print("存款金额必须为正数")
():
amount > amount <= .__balance:
.__balance -= amount
()
()
():
()
.__balance
account = BankAccount(, , )
()
()
()
account.deposit()
()
withdraw_success = account.withdraw()
withdraw_success:
()
account.__balance =
()
account.owner_name =
()
Java：
import lombok.extern.slf4j.Slf4j;
/**
* 异常处理示例
*/
@Slf4j
public class ExceptionHandlingDemo {
/**
* 除法运算
* @param a 被除数
* @param b 除数
* @return 商
* @throws ArithmeticException 当除数为 0 时抛出
*/
public static double divide(double a, double b) {
if (b == 0) {
throw new ArithmeticException("除数不能为 0");
}
return a / b;
}
public static void main(String[] args) {
try {
double result = divide(10, 2);
log.info("10 / 2 = {}", result);
result = divide(10, 0);
log.info("10 / 0 = {}", result);
} catch (ArithmeticException e) {
log.error("发生算术异常：{}", e.getMessage());
} finally {
log.info("运算结束");
}
// 处理多种异常
String[] fruits = {"苹果", "香蕉", "橙子"};
try {
Integer.parseInt();
log.info(fruits[index]);
} (NumberFormatException e) {
log.error();
} (ArrayIndexOutOfBoundsException e) {
log.error();
} (Exception e) {
log.error(, e.getMessage());
}
}
}
Python：
# 异常处理示例
def divide(a, b):
""" 除法运算
@param a: 被除数
@param b: 除数
@return: 商
@raise ArithmeticError: 当除数为 0 时抛出
"""
if b == 0:
raise ArithmeticError("除数不能为 0")
return a / b
try:
result = divide(10, 2)
print(f"10 / 2 = {result}")
result = divide(10, 0)
print(f"10 / 0 = {result}")
except ArithmeticError as e:
print(f"发生算术异常：{str(e)}")
finally:
print("运算结束")
# 处理多种异常
fruits = ["苹果", "香蕉", "橙子"]
try:
index = int("abc")
print(fruits[index])
except ValueError:
print("值错误：无法将字符串转换为整数")
except IndexError:
print("索引错误：索引超出数组范围")
except Exception as e:
print(f"发生未知异常：{str(e)}")
Java：
import lombok.extern.slf4j.Slf4j;
/**
* 自定义异常示例
*/
@Slf4j
public class CustomExceptionDemo {
/**
* 自定义异常：用户不存在异常
*/
public static class UserNotFoundException extends Exception {
public UserNotFoundException(String message) {
super(message);
}
}
/**
* 自定义异常：权限不足异常
*/
public static class PermissionDeniedException extends Exception {
public PermissionDeniedException(String message) {
super(message);
}
}
/**
* 检查用户是否存在
* @param userId 用户 ID
* @throws UserNotFoundException 当用户不存在时抛出
*/
public static void checkUserExists(String userId) throws UserNotFoundException {
// 模拟检查用户是否存在
if ("000".equals(userId)) {
throw new UserNotFoundException("用户不存在：" + userId);
}
}
/**
* 检查用户权限
* @param userId 用户 ID
* @throws PermissionDeniedException 当权限不足时抛出
*/
PermissionDeniedException {
(.equals(userId)) {
( + userId);
}
}
{
;
{
checkUserExists(userId);
checkPermission(userId);
log.info(, userId);
} (UserNotFoundException | PermissionDeniedException e) {
log.error(, e.getMessage());
} (Exception e) {
log.error(, e.getMessage());
}
}
}
Python：
# 自定义异常示例
class UserNotFoundException(Exception):
"""自定义异常：用户不存在异常"""
pass
class PermissionDeniedException(Exception):
"""自定义异常：权限不足异常"""
pass
def check_user_exists(user_id):
""" 检查用户是否存在
@param user_id: 用户 ID
@raise UserNotFoundException: 当用户不存在时抛出
"""
# 模拟检查用户是否存在
if user_id == "000":
raise UserNotFoundException(f"用户不存在：{user_id}")
def check_permission(user_id):
""" 检查用户权限
@param user_id: 用户 ID
@raise PermissionDeniedException: 当权限不足时抛出
"""
# 模拟检查权限
if user_id == "123":
raise PermissionDeniedException(f"用户权限不足：{user_id}")
user_id = "123"
try:
check_user_exists(user_id)
check_permission(user_id)
print(f"用户 {user_id} 验证通过")
except (UserNotFoundException, PermissionDeniedException) as e:
print(f"验证失败：{str(e)}")
except Exception as e:
print(f"发生未知错误：{str(e)}")
Java 中我们通过 import 语句导入类，Python 中则通过 import 语句导入模块：
Python 模块示例（创建一个名为 math_utils.py 的文件）：
# 数学工具模块
PI = 3.1415926535
def add(a, b):
"""加法运算"""
return a + b
def subtract(a, b):
"""减法运算"""
return a - b
def multiply(a, b):
"""乘法运算"""
return a * b
def divide(a, b):
"""除法运算"""
if b == 0:
raise ValueError("除数不能为 0")
return a / b
def circle_area(radius):
"""计算圆的面积"""
return PI * radius * radius
使用模块：
# 模块使用示例
# 导入整个模块
import math_utils
print(f"PI 的值：{math_utils.PI}")
print(f"3 + 5 = {math_utils.add(3, 5)}")
print(f"半径为 2 的圆面积：{math_utils.circle_area(2)}")
# 导入模块并指定别名
import math_utils as mu
print(f"10 - 4 = {mu.subtract(10, 4)}")
# 导入模块中的特定函数或变量
from math_utils import multiply, PI
print(f"6 * 7 = {multiply(6, 7)}")
print(f"再次打印 PI: {PI}")
# 导入模块中的所有内容（不推荐）
from math_utils import *
print(f"10 / 2 = {divide(10, 2)}")
Python 的包类似于 Java 的包，是模块的集合。一个包含 __init__.py 文件的目录就是一个 Python 包。
包结构示例：
my_package/
├── __init__.py
├── math_utils.py
└── string_utils.py
__init__.py 文件可以为空，也可以包含包的初始化代码：
# 包初始化文件
# 声明包中可以导出的模块或函数
__all__ = ['math_utils', 'string_utils']
print("my_package 包被导入了")
string_utils.py 文件：
# 字符串工具模块
def to_upper(s):
"""转换为大写"""
return s.upper()
def to_lower(s):
"""转换为小写"""
return s.lower()
def reverse(s):
"""反转字符串"""
return s[::-1]
使用包：
# 包使用示例
# 从包中导入模块
from my_package import math_utils, string_utils
print(f"5 * 8 = {math_utils.multiply(5, 8)}")
print(f"反转字符串：{string_utils.reverse('hello')}")
# 导入模块并指定别名
from my_package import math_utils as mu
print(f"圆面积：{mu.circle_area(3)}")
# 从包的模块中导入特定函数
from my_package.string_utils import to_upper
print(f"转换为大写：{to_upper('hello world')}")
# 使用通配符导入（受__init__.py 中__all__的限制）
from my_package import *
print(f"3.14 / 2 = {math_utils.divide(3.14, 2)}")
print(f"转换为小写：{string_utils.to_lower('HELLO')}")
Python 拥有丰富的标准库，相当于 Java 的 JDK 类库：
# 常用标准库示例
# 时间日期处理
import time
import datetime
print(f"当前时间戳：{time.time()}")
print(f"本地时间：{time.localtime()}")
print(f"格式化时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")
today = datetime.date.today()
print(f"今天日期：{today}")
tomorrow = today + datetime.timedelta(days=1)
print(f"明天日期：{tomorrow}")
# 数学运算
import math
import random
print(f"圆周率：{math.pi}")
print(f"正弦值：{math.sin(math.pi / 2)}")
print(f"平方根：{math.sqrt(16)}")
print(f"随机整数：{random.randint(1, 100)}")
print(f"随机选择：{random.choice(['红', '绿', '蓝'])}")
# 文件处理
import os
import shutil
print(f"当前目录：{os.getcwd()}")
print(f"目录内容：{os.listdir('.')}")
gzip
json
data = {: , : , : [, ]}
json_str = json.dumps(data, ensure_ascii=)
()
parsed_data = json.loads(json_str)
()
Java：
import lombok.extern.slf4j.Slf4j;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
/**
* 文件操作示例
*/
@Slf4j
public class FileOperationDemo {
public static void main(String[] args) {
String filename = "example.txt";
// 写入文件
try (BufferedWriter writer = new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream(filename), StandardCharsets.UTF_8))) {
writer.write("Hello, World!");
writer.newLine();
writer.write("这是一个文件写入示例。");
log.info("文件写入成功");
} catch (IOException e) {
log.error("文件写入失败：{}", e.getMessage());
}
// 读取文件（按行读取）
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(
new FileInputStream(filename), StandardCharsets.UTF_8))) {
String line;
log.info();
((line = reader.readLine()) != ) {
log.info(line);
}
} (IOException e) {
log.error(, e.getMessage());
}
{
List<String> lines = Files.readAllLines(Paths.get(filename), StandardCharsets.UTF_8);
log.info();
(String line : lines) {
log.info(line);
}
} (IOException e) {
log.error(, e.getMessage());
}
}
}
Python：
# 文件操作示例
filename = "example.txt"
# 写入文件
try:
with open(filename, "w", encoding="utf-8") as writer:
writer.write("Hello, World!\n")
writer.write("这是一个文件写入示例。")
print("文件写入成功")
except IOError as e:
print(f"文件写入失败：{str(e)}")
# 读取文件（按行读取）
try:
with open(filename, "r", encoding="utf-8") as reader:
print("文件内容:")
for line in reader:
print(line.strip()) # strip() 用于去除换行符
except IOError as e:
print(f"文件读取失败：{str(e)}")
# 读取所有内容
try:
with open(filename, "r", encoding="utf-8") as reader:
content = reader.read()
print("所有文件内容:")
print(content)
except IOError as e:
print(f"文件读取失败：{(e)}")
:
(filename, , encoding=) reader:
lines = reader.readlines()
()
line lines:
(line.strip())
IOError e:
()
Java：
import lombok.extern.slf4j.Slf4j;
import java.io.*;
/**
* 二进制文件操作示例
*/
@Slf4j
public class BinaryFileDemo {
public static void main(String[] args) {
String sourceFile = "source.bin";
String destFile = "dest.bin";
// 写入二进制文件
try (DataOutputStream dos = new DataOutputStream(
new FileOutputStream(sourceFile))) {
dos.writeInt(42);
dos.writeDouble(3.14159);
dos.writeUTF("Hello, Binary World!");
log.info("二进制文件写入成功");
} catch (IOException e) {
log.error("二进制文件写入失败：{}", e.getMessage());
}
// 读取二进制文件
try (DataInputStream dis = new DataInputStream(
new FileInputStream(sourceFile))) {
int intValue = dis.readInt();
double doubleValue = dis.readDouble();
dis.readUTF();
log.info();
log.info(, intValue);
log.info(, doubleValue);
log.info(, stringValue);
} (IOException e) {
log.error(, e.getMessage());
}
( (sourceFile); (destFile)) {
[] buffer = [];
bytesRead;
((bytesRead = in.read(buffer)) != -) {
out.write(buffer, , bytesRead);
}
log.info();
} (IOException e) {
log.error(, e.getMessage());
}
}
}
Python：
# 二进制文件操作示例
source_file = "source.bin"
dest_file = "dest.bin"
# 写入二进制文件
try:
with open(source_file, "wb") as f:
# 写入整数（4 字节，大端模式）
f.write((42).to_bytes(4, byteorder='big'))
# 写入双精度浮点数（8 字节）
import struct
f.write(struct.pack('d', 3.14159))
# 写入字符串（UTF-8 编码）
f.write("Hello, Binary World!".encode('utf-8'))
print("二进制文件写入成功")
except IOError as e:
print(f"二进制文件写入失败：{str(e)}")
# 读取二进制文件
try:
with open(source_file, "rb") as f:
# 读取整数
int_bytes = f.read(4)
int_value = int.from_bytes(int_bytes, byteorder='big')
# 读取双精度浮点数
double_bytes = f.read(8)
double_value = struct.unpack('d', double_bytes)[0]
# 读取字符串
str_bytes = f.read()
str_value = str_bytes.decode('utf-8')
print("读取二进制数据:")
print(f"整数：{int_value}")
()
()
IOError e:
()
:
(source_file, ) in_file, (dest_file, ) out_file:
:
buffer = in_file.read()
buffer:
out_file.write(buffer)
()
IOError e:
()
Java（使用 MyBatis-Plus）：
首先，添加 Maven 依赖（pom.xml）：
<dependencies>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.30</version>
<scope>provided</scope>
</dependency>
<!-- SLF4J API -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>2.0.9</version>
</dependency>
<!-- SLF4J Simple binding for demonstration -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<version>2.0.9</version>
</dependency>
<!-- MySQL Connector -->
com.mysql
mysql-connector-j
8.1.0
com.baomidou
mybatis-plus-boot-starter
3.5.3.1
org.springframework.boot
spring-boot-starter
3.1.3
实体类：
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import io.swagger.v3.oas.annotations.media.Schema;
import java.time.LocalDateTime;
/**
* 用户实体类
*/
@Data
@TableName("user")
@Schema(description = "用户实体")
public class User {
@TableId(type = IdType.AUTO)
@Schema(description = "用户 ID")
private Long id;
@Schema(description = "用户名")
private String username;
@Schema(description = "年龄")
private Integer age;
@Schema(description = "邮箱")
private String email;
@Schema(description = "创建时间")
private LocalDateTime createTime;
}
Mapper 接口：
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
/**
* 用户 Mapper 接口
*/
@Mapper
public interface UserMapper extends BaseMapper<User> {
/**
* 根据年龄查询用户
* @param page 分页对象
* @param age 年龄
* @return 分页用户列表
*/
IPage<User> selectByAge(Page<User> page, @Param("age") Integer age);
}
服务类：
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.List;
/**
* 用户服务类
*/
@Service
@Slf4j
public class UserService extends ServiceImpl<UserMapper, User> {
/**
* 创建用户
* @param user 用户对象
* @return 是否创建成功
*/
public boolean createUser(User user) {
user.setCreateTime(LocalDateTime.now());
return save(user);
}
/**
* 根据 ID 查询用户
* @param id 用户 ID
* @return 用户对象
*/
public User getUserById(Long id) {
return getById(id);
}
/**
* 查询所有用户
* @return 用户列表
*/
public List<User> getAllUsers() {
return list();
}
/**
* 更新用户信息
* @param user 用户对象
* @return 是否更新成功
*/
public boolean updateUser(User user) {
return updateById(user);
}
/**
* 根据 ID 删除用户
* id 用户 ID
* 是否删除成功
*/
{
removeById(id);
}
IPage<User> {
Page<User> page = <>(pageNum, pageSize);
page(page);
}
IPage<User> {
Page<User> page = <>(pageNum, pageSize);
baseMapper.selectByAge(page, age);
}
}
使用示例：
import com.baomidou.mybatisplus.core.metadata.IPage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
/**
* 数据库操作示例
*/
@SpringBootApplication
@Slf4j
public class DatabaseDemoApplication {
@Autowired
private UserService userService;
public static void main(String[] args) {
SpringApplication.run(DatabaseDemoApplication.class, args);
}
/**
* 配置 MyBatis-Plus 分页插件
* @return MyBatis-Plus 拦截器
*/
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
return interceptor;
}
/**
* 演示数据库操作
* @return CommandLineRunner
*/
@Bean
public CommandLineRunner demo {
args -> {
();
user.setUsername();
user.setAge();
user.setEmail();
userService.createUser(user);
log.info(, created ? : );
user.getId();
log.info(, userId);
userService.getUserById(userId);
log.info(, foundUser);
(foundUser != ) {
foundUser.setAge();
userService.updateUser(foundUser);
log.info(, updated ? : );
}
IPage<User> page = userService.getUsersByPage(, );
log.info(, page.getTotal(), page.getPages());
log.info(, page.getRecords());
IPage<User> agePage = userService.getUsersByAge(, , );
log.info(, agePage.getRecords());
(userId != ) {
userService.deleteUser(userId);
log.info(, deleted ? : );
}
};
}
}
Python（使用 PyMySQL 和 SQLAlchemy）：
首先安装依赖：
pip install pymysql sqlalchemy
Python 代码：
# MySQL 数据库操作示例
from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from datetime import datetime
import pymysql
# 数据库连接配置
DB_CONFIG = {
'host': 'localhost',
'port': 3306,
'user': 'root',
'password': 'password', # 替换为你的密码
'database': 'test_db',
'charset': 'utf8mb4'
}
# 创建数据库引擎
engine = create_engine(
f"mysql+pymysql://{DB_CONFIG['user']}:{DB_CONFIG['password']}@{DB_CONFIG['host']}:{DB_CONFIG['port']}/{DB_CONFIG['database']}?charset={DB_CONFIG['charset']}"
)
# 创建会话工厂
Session = sessionmaker(bind=engine)
# 声明基类
Base = declarative_base()
class User(Base):
"""用户模型类"""
__tablename__ = 'user'
id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(50), nullable=False)
age = Column(Integer)
email = Column(String())
create_time = Column(DateTime, default=datetime.now)
():
Base.metadata.create_all(engine)
():
session = Session()
:
user = User(username=username, age=age, email=email)
session.add(user)
session.commit()
()
user
Exception e:
session.rollback()
()
:
session.close()
():
session = Session()
:
user = session.query(User).filter_by(=user_id).first()
user:
()
:
()
user
Exception e:
()
:
session.close()
():
session = Session()
:
users = session.query(User).()
()
users
Exception e:
()
[]
:
session.close()
():
session = Session()
:
user = session.query(User).filter_by(=user_id).first()
user:
()
key, value kwargs.items():
(user, key):
(user, key, value)
session.commit()
()
Exception e:
session.rollback()
()
:
session.close()
():
session = Session()
:
user = session.query(User).filter_by(=user_id).first()
user:
()
session.delete(user)
session.commit()
()
Exception e:
session.rollback()
()
:
session.close()
():
session = Session()
:
offset = (page_num - ) * page_size
total = session.query(User).count()
users = session.query(User).offset(offset).limit(page_size).()
()
users, total
Exception e:
()
[],
:
session.close()
():
session = Session()
:
offset = (page_num - ) * page_size
total = session.query(User).filter_by(age=age).count()
users = session.query(User).filter_by(age=age).offset(offset).limit(page_size).()
()
users, total
Exception e:
()
[],
:
session.close()
__name__ == :
user = create_user(, , )
user:
user_id = user.
get_user_by_id(user_id)
update_user(user_id, age=)
users, total = get_users_by_page(, )
()
age_users, age_total = get_users_by_age()
()
delete_user(user_id)
Java：
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 多线程示例
*/
@Slf4j
public class MultithreadingDemo {
/**
* 计数器类
*/
public static class Counter {
private int count = 0;
/**
* 增加计数（线程安全）
*/
public synchronized void increment() {
count++;
}
/**
* 获取当前计数
* @return 当前计数值
*/
public int getCount() {
return count;
}
}
/**
* 线程任务：计数
*/
public static class CountingTask implements Runnable {
private final Counter counter;
private final int iterations;
public CountingTask(Counter counter, int iterations) {
this.counter = counter;
.iterations = iterations;
}
{
Thread.currentThread().getName();
log.info(, threadName);
( ; i < iterations; i++) {
counter.increment();
{
Thread.sleep();
} (InterruptedException e) {
log.error(, threadName);
Thread.currentThread().interrupt();
;
}
}
log.info(, threadName);
}
}
InterruptedException {
();
;
;
Executors.newFixedThreadPool(threadCount);
( ; i < threadCount; i++) {
executor.submit( (counter, iterationsPerThread));
}
executor.shutdown();
(executor.awaitTermination(, TimeUnit.MINUTES)) {
log.info();
log.info(, counter.getCount(), threadCount * iterationsPerThread);
} {
log.error();
}
}
}
Python：
# 多线程示例
import threading
import time
from concurrent.futures import ThreadPoolExecutor
class Counter:
"""计数器类"""
def __init__(self):
self.count = 0
self.lock = threading.Lock() # 锁对象，用于保证线程安全
def increment(self):
"""增加计数（线程安全）"""
with self.lock: # 使用上下文管理器自动获取和释放锁
self.count += 1
def get_count(self):
"""获取当前计数"""
return self.count
def counting_task(counter, iterations, thread_name):
"""计数任务函数"""
print(f"线程 {thread_name} 开始执行")
for _ in range(iterations):
counter.increment()
# 模拟耗时操作
time.sleep(0.001)
print(f"线程 {thread_name} 执行完毕")
def main():
# 创建计数器
counter = Counter()
iterations_per_thread = 1000
thread_count = 5
# 创建线程池
ThreadPoolExecutor(max_workers=thread_count) executor:
i (thread_count):
executor.submit(
counting_task, counter, iterations_per_thread,
)
()
()
__name__ == :
main()
由于 Python 的全局解释器锁（GIL），多线程在 CPU 密集型任务中并不能真正并行。对于这类任务，应该使用多进程：
# 多进程示例（适用于 CPU 密集型任务）
import multiprocessing
import time
def cpu_intensive_task(start, end):
"""CPU 密集型任务：计算从 start 到 end 的和"""
process_name = multiprocessing.current_process().name
print(f"进程 {process_name} 开始执行：计算 {start} 到 {end} 的和")
total = 0
for i in range(start, end):
total += i
print(f"进程 {process_name} 执行完毕，结果：{total}")
return total
def main():
# 定义任务范围
ranges = [
(1, 25000000),
(25000000, 50000000),
(50000000, 75000000),
(75000000, 100000000)
]
# 记录开始时间
start_time = time.time()
# 使用多进程
with multiprocessing.Pool(processes=4) as pool:
# 映射任务到进程池
results = pool.starmap(cpu_intensive_task, ranges)
# 计算总结果
total = sum(results)
# 记录结束时间
end_time = time.time()
print(f"所有进程执行完毕，总和：{total}")
print(f"总耗时：{end_time - start_time:.2f} 秒")
__name__ == :
main()
首先，添加 Maven 依赖（pom.xml）：
<dependencies>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.30</version>
<scope>provided</scope>
</dependency>
<!-- SLF4J API -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>2.0.9</version>
</dependency>
<!-- Spring Boot Starter Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>3.1.3</version>
</dependency>
<!-- Spring Boot Starter Validation -->
org.springframework.boot
spring-boot-starter-validation
3.1.3
org.springdoc
springdoc-openapi-starter-webmvc-ui
2.1.0
实体类：
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.PositiveOrZero;
import lombok.Data;
/**
* 用户实体类
*/
@Data
@Schema(description = "用户实体")
public class User {
@Schema(description = "用户 ID", example = "1")
private Long id;
@NotBlank(message = "用户名不能为空")
@Schema(description = "用户名", example = "张三")
private String username;
@PositiveOrZero(message = "年龄不能为负数")
@Schema(description = "年龄", example = "25")
private Integer age;
@Email(message = "邮箱格式不正确")
@Schema(description = "邮箱", example = "[email protected]")
private String email;
}
服务类：
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
/**
* 用户服务类
*/
@Service
@Slf4j
public class UserService {
// 内存存储用户数据
private final Map<Long, User> userMap = new ConcurrentHashMap<>();
// 自增 ID 生成器
private final AtomicLong idGenerator = new AtomicLong(1);
/**
* 创建用户
* @param user 用户对象
* @return 创建的用户对象（包含 ID）
*/
public User createUser(User user) {
log.info("创建用户：{}", user);
Long userId = idGenerator.getAndIncrement();
user.setId(userId);
userMap.put(userId, user);
return user;
}
/**
* 根据 ID 查询用户
* @param id 用户 ID
* @return 用户对象，不存在则返回 null
*/
public User getUserById(Long id) {
log.info("查询用户：ID={}", id);
return userMap.get(id);
}
/**
* 查询所有用户
* 用户列表
*/
List<User> {
log.info();
Collection<User> users = userMap.values();
CollectionUtils.isEmpty(users) ? Collections.emptyList() : <>(users);
}
User {
log.info(, id, user);
(!userMap.containsKey(id)) {
;
}
userMap.get(id);
(user.getUsername() != ) {
existingUser.setUsername(user.getUsername());
}
(user.getAge() != ) {
existingUser.setAge(user.getAge());
}
(user.getEmail() != ) {
existingUser.setEmail(user.getEmail());
}
userMap.put(id, existingUser);
existingUser;
}
{
log.info(, id);
userMap.remove(id) != ;
}
}
控制器：
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Content;
import io.swagger.v3.oas.annotations.media.Schema;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.validation.Valid;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 用户控制器
* 提供 RESTful API 接口
*/
@RestController
@RequestMapping("/api/users")
@Slf4j
@Tag(name = "用户管理", description = "用户 CRUD 操作的 API 接口")
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
/**
* 创建用户
* @param user 用户对象
* @return 创建的用户对象
*/
@PostMapping
@Operation(summary = "创建用户", description = "添加新用户到系统")
@ApiResponses({
@ApiResponse(responseCode = "201", description = "用户创建成功", content = @Content(schema = @Schema(implementation = User.class))),
@ApiResponse(responseCode = "400", description = "请求参数错误")
})
public ResponseEntity<User> createUser(
@Valid @RequestBody @Parameter(description = "用户信息") User user) {
userService.createUser(user);
<>(createdUser, HttpStatus.CREATED);
}
ResponseEntity<User> {
userService.getUserById(id);
(user == ) {
<>(HttpStatus.NOT_FOUND);
}
ResponseEntity.ok(user);
}
ResponseEntity<List<User>> {
List<User> users = userService.getAllUsers();
ResponseEntity.ok(users);
}
ResponseEntity<User> {
userService.updateUser(id, user);
(updatedUser == ) {
<>(HttpStatus.NOT_FOUND);
}
ResponseEntity.ok(updatedUser);
}
ResponseEntity<Void> {
userService.deleteUser(id);
(!deleted) {
<>(HttpStatus.NOT_FOUND);
}
<>(HttpStatus.NO_CONTENT);
}
}
启动类：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import io.swagger.v3.oas.annotations.OpenAPIDefinition;
import io.swagger.v3.oas.annotations.info.Info;
/**
* RESTful API 服务启动类
*/
@SpringBootApplication
@OpenAPIDefinition(
info = @Info(
title = "用户管理 API",
version = "1.0",
description = "简易用户管理系统的 RESTful API 接口文档"
)
)
public class RestApiApplication {
public static void main(String[] args) {
SpringApplication.run(RestApiApplication.class, args);
}
}
首先安装依赖：
pip install fastapi uvicorn pydantic
Python 代码：
# 简易 RESTful API 服务（FastAPI）
from fastapi import FastAPI, HTTPException, status
from pydantic import BaseModel, EmailStr, field_validator
from typing import List, Optional, Dict
import uvicorn
from fastapi.middleware.cors import CORSMiddleware
import logging
# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# 创建 FastAPI 应用
app = FastAPI(
title="用户管理 API",
description="简易用户管理系统的 RESTful API 接口",
version="1.0.0"
)
# 配置 CORS
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
# 数据模型
class User(BaseModel):
"""用户模型"""
id: Optional[int] = None
username: str
age: Optional[int] = None
email: Optional[EmailStr] = None
@field_validator('age')
def age_must_be_non_negative(cls, v):
"""验证年龄必须为非负数"""
if v is v < :
ValueError()
v
users: [, User] = {}
next_id =
():
next_id
logger.info()
user. = next_id
users[next_id] = user
next_id +=
user
():
logger.info()
user_id users:
HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=
)
users[user_id]
():
logger.info()
(users.values())
():
logger.info()
user_id users:
HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=
)
existing_user = users[user_id]
user_update.username :
existing_user.username = user_update.username
user_update.age :
existing_user.age = user_update.age
user_update.email :
existing_user.email = user_update.email
users[user_id] = existing_user
existing_user
():
logger.info()
user_id users:
HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=
)
users[user_id]
__name__ == :
uvicorn.run(app, host=, port=)
| 特性 | Java | Python |
|---|---|---|
| 类型系统 | 静态类型，编译时检查 | 动态类型，运行时检查 |
| 语法风格 | 强调显式声明，使用大括号和分号 | 简洁，使用缩进来划分代码块 |
| 性能 | 编译为字节码，性能较好 | 解释执行，通常性能较低 |
| 并发模型 | 多线程，真正并行 | 受 GIL 限制，多线程不适合 CPU 密集型任务，常用多进程 |
| 生态系统 | 强大的企业级库，Spring 生态 | 丰富的数据科学、AI 库，简洁的 Web 框架 |
| 代码量 | 相对冗长 | 简洁，代码量通常较少 |
| 学习曲线 | 较陡峭 | 较平缓，易于上手 |
| 应用场景 | 企业级应用，Android 开发 | 数据分析，AI，脚本，快速原型开发 |
通过本教程，我们从 Java 开发者的视角快速了解了 Python 的核心语法和特性。我们对比了两种语言在数据类型、控制流、函数、面向对象、异常处理、文件操作、数据库访问和并发编程等方面的异同。
作为 Java 开发者，学习 Python 有以下优势：
下一步学习建议：
Python 以其简洁、灵活和强大的生态系统，为开发者提供了另一种高效的编程选择。作为 Java 开发者，掌握 Python 不仅能拓宽技术视野，更能在合适的场景下选择最适合的工具，提高开发效率。
祝你在 Python 的学习之旅中取得更多收获！
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online