Python 核心编程知识点与案例应用（Java 开发者专属版）
专为 Java 开发者设计：重点标注 Python 与 Java 的核心差异，所有案例均为日常开发高频场景，无任何 AI 数学相关内容。学完即可独立完成数据处理、脚本编写、工具开发等基础任务。
一、基础语法与核心概念
1. 变量与数据类型
核心差异：Python 是动态类型语言，变量无需声明类型，可随时赋值不同类型的数据；Java 是静态类型语言，变量必须先声明类型。
| 数据类型 | 说明 | 与 Java 对比 |
|---|---|---|
| 整数 (int) | 无大小限制 | Java 有 byte/short/int/long 之分 |
| 浮点数 (float) | 双精度浮点数 | 等同于 Java 的 double |
| 字符串 (str) | 单引号 / 双引号 / 三引号均可 | Java 只能用双引号，三引号用于多行字符串 |
| 布尔值 (bool) | True/False（首字母大写） | Java 是 true/false（小写） |
| 空值 (None) | 表示空对象 | 等同于 Java 的 null |
案例：变量与类型转换
# 变量定义（无需声明类型）
name = "张三"
age = 25
height = 1.75
is_student = True
# 类型转换
age_str = str(age) # 整数转字符串
height_int = int(height) # 浮点数转整数（截断小数部分）
print(f"姓名：{name}，年龄：{age}，身高：{height}，是否学生：{is_student}")
# 查看变量类型
print(type(name)) # <class 'str'>
print(type(age)) # <class 'int'>
2. 运算符
-
算术运算符：
+-*///（整除）%（取余）**（幂运算） -
比较运算符：
==!=><>=<= -
逻辑运算符：
andornot（Java 是&&||!） -
赋值运算符：
=+=-=*=/=//=%=**=
案例：简单计算器
a = 10
b = 3
print(f"加法：{a + b}") # 13
print(f"减法：{a - b}") # 7
print(f"乘法：{a * b}") # 30
print(f"除法：{a / b}") # 3.3333333333333335
print(f"整除：{a // b}") # 3
print(f"取余：{a % b}") # 1
print(f"幂运算：{a ** b}") # 1000
3. 控制流语句
核心差异：Python 使用缩进（通常 4 个空格）表示代码块，Java 使用大括号{}。
(1) 条件语句
score = 85
if score >= 90:
grade = "优秀"
elif score >= 80:
grade = "良好"
elif score >= 60:
grade = "及格"
else:
grade = "不及格"
print(f"成绩等级：{grade}") # 良好
(2) 循环语句
- for 循环：用于遍历可迭代对象（列表、字典、字符串等）
- while 循环：当条件为 True 时执行循环体
案例：遍历列表与九九乘法表
# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
print(f"我喜欢吃{fruit}")
# 九九乘法表
for i in range(1, 10):
for j in range(1, i+1):
print(f"{j}×{i}={i*j}", end="\t")
print() # 换行
二、Python 核心数据结构
核心差异：Python 内置了列表、字典、集合、元组四种核心数据结构，语法比 Java 更简洁，功能更强大。
1. 列表 (list)
特点：有序、可变、可重复，类似于 Java 的 ArrayList，但更灵活。
常用操作：
] # 创建列表
numbers = [1, 2, 3, 4, 5]
fruits = ["苹果", "香蕉", "橙子"]
# 访问元素（索引从0开始）
print(fruits[0]) # 苹果
print(fruits[-1]) # 橙子（负索引表示从末尾开始）
# 修改元素
fruits[1] = "葡萄"
print(fruits) # ['苹果', '葡萄', '橙子']
# 添加元素
fruits.append("西瓜") # 末尾添加
fruits.insert(1, "草莓") # 指定位置插入
print(fruits) # ['苹果', '草莓', '葡萄', '橙子', '西瓜']
# 删除元素
fruits.remove("葡萄") # 删除指定元素
del fruits[0] # 删除指定索引元素
last_fruit = fruits.pop() # 删除并返回末尾元素
print(fruits) # ['草莓', '橙子']
# 切片操作（[起始:结束:步长]）
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:5]) # [3, 4, 5]
print(numbers[:3]) # [1, 2, 3]
print(numbers[5:]) # [6, 7, 8, 9]
print(numbers[::2]) # [1, 3, 5, 7, 9]
print(numbers[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1]（反转列表）
案例：待办事项管理器
todo_list = []
def add_task(task):
todo_list.append(task)
print(f"已添加任务：{task}")
def remove_task(index):
if 0 <= index < len(todo_list):
removed_task = todo_list.pop(index)
print(f"已删除任务：{removed_task}")
else:
print("任务索引无效")
def show_tasks():
if not todo_list:
print("待办事项为空")
else:
print("待办事项列表：")
for i, task in enumerate(todo_list):
print(f"{i+1}. {task}")
# 测试
add_task("学习Python")
add_task("写代码")
show_tasks()
remove_task(0)
show_tasks()
2. 字典 (dict)
特点：键值对存储、无序（Python3.7 + 有序）、键唯一不可变，类似于 Java 的 HashMap。
常用操作：
] # 创建字典
student = {
"name": "张三",
"age": 20,
"gender": "男",
"scores": {"数学": 90, "语文": 85, "英语": 95}
}
# 访问值
print(student["name"]) # 张三
print(student.get("age")) # 20
print(student.get("address", "未知")) # 键不存在时返回默认值
# 修改/添加键值对
student["age"] = 21
student["address"] = "北京市"
print(student)
# 删除键值对
del student["gender"]
age = student.pop("age")
print(student)
# 遍历字典
for key in student:
print(f"{key}: {student[key]}")
for key, value in student.items():
print(f"{key}: {value}")
案例：学生成绩管理系统
students = {}
def add_student(id, name, scores):
students[id] = {"name": name, "scores": scores}
print(f"已添加学生：{name}")
def get_student(id):
if id in students:
student = students[id]
print(f"学号：{id}")
print(f"姓名：{student['name']}")
print("成绩：")
for subject, score in student['scores'].items():
print(f" {subject}：{score}")
else:
print("学生不存在")
def calculate_average(id):
if id in students:
scores = students[id]["scores"].values()
average = sum(scores) / len(scores)
print(f"平均成绩：{average:.2f}")
else:
print("学生不存在")
# 测试
add_student(1001, "张三", {"数学": 90, "语文": 85, "英语": 95})
add_student(1002, "李四", {"数学": 80, "语文": 75, "英语": 85})
get_student(1001)
calculate_average(1001)
3. 集合 (set)
特点：无序、不可重复，类似于 Java 的 HashSet，常用于去重和集合运算。
常用操作：
# 创建集合
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7, 8}
# 添加元素
s1.add(6)
print(s1) # {1, 2, 3, 4, 5, 6}
# 删除元素
s1.remove(6)
print(s1) # {1, 2, 3, 4, 5}
# 集合运算
print(s1 & s2) # 交集 {4, 5}
print(s1 | s2) # 并集 {1, 2, 3, 4, 5, 6, 7, 8}
print(s1 - s2) # 差集 {1, 2, 3}
print(s1 ^ s2) # 对称差集 {1, 2, 3, 6, 7, 8}
# 列表去重
numbers = [1, 2, 2, 3, 3, 3, 4, 5, 5]
unique_numbers = list(set(numbers))
print(unique_numbers) # [1, 2, 3, 4, 5]
4. 元组 (tuple)
特点：有序、不可变、可重复，类似于不可变的列表，常用于保护数据不被修改。
常用操作：
# 创建元组
t1 = (1, 2, 3, 4, 5)
t2 = ("张三", 20, "男")
# 访问元素
print(t1[0]) # 1
print(t2[1]) # 20
# 元组解包
name, age, gender = t2
print(f"姓名：{name}，年龄：{age}，性别：{gender}")
# 元组不可修改
# t1[0] = 10 # 会报错：TypeError: 'tuple' object does not support item assignment
5. 推导式（Python 特色语法）
核心优势：用一行代码生成列表、字典、集合，比 Java 的循环写法简洁得多。
# 列表推导式
# 生成1-10的平方数
squares = [x**2 for x in range(1, 11)]
print(squares) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
# 带条件的列表推导式
# 生成1-10中的偶数
even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers) # [2, 4, 6, 8, 10]
# 字典推导式
# 将列表转换为字典，键为元素，值为元素的平方
square_dict = {x: x**2 for x in range(1, 6)}
print(square_dict) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# 集合推导式
# 生成1-10中奇数的平方
odd_squares = {x**2 for x in range(1, 11) if x % 2 != 0}
print(odd_squares) # {1, 9, 25, 49, 81}
三、函数与模块
1. 函数定义与调用
核心差异：Python 函数是一等公民，可以作为参数传递、返回值、赋值给变量，这是 Java 没有的特性。
# 定义函数
def add(a, b):
"""计算两个数的和"""
return a + b
# 调用函数
result = add(3, 5)
print(result) # 8
# 函数作为参数传递
def calculate(func, a, b):
return func(a, b)
print(calculate(add, 3, 5)) # 8
2. 函数参数
位置参数：按顺序传递
关键字参数：按参数名传递
默认参数：定义时指定默认值
-
可变参数：
*args（接收任意多个位置参数）、**kwargs（接收任意多个关键字参数）# 默认参数 def greet(name, message="你好"): print(f"{message}，{name}！") greet("张三") # 你好，张三！ greet("李四", "早上好") # 早上好，李四！ greet(message="晚上好", name="王五") # 晚上好，王五！ # 可变参数 def sum_numbers(*args): total = 0 for num in args: total += num return total print(sum_numbers(1, 2, 3)) # 6 print(sum_numbers(1, 2, 3, 4, 5)) # 15 def print_info(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}") print_info(name="张三", age=20, gender="男")
3. 匿名函数 (lambda)
用于定义简单的单行函数，类似于 Java 的 Lambda 表达式。
# 定义匿名函数
add = lambda a, b: a + b
print(add(3, 5)) # 8
# 结合内置函数使用
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares) # [1, 4, 9, 16, 25]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # [2, 4]
4. 装饰器（Python 高级特性）
作用：在不修改原函数代码的情况下，为函数添加额外功能，是 Python 面向切面编程 (AOP) 的实现方式。
案例：函数执行时间计时器
import time
def timer(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
print(f"函数{func.__name__}执行时间：{end_time - start_time:.4f}秒")
return result
return wrapper
# 使用装饰器
@timer
def slow_function():
time.sleep(2)
print("函数执行完成")
slow_function()
5. 模块与包
核心差异：Python 的模块就是一个.py文件，包是包含__init__.py文件的目录，用于组织代码。
python
# 导入整个模块
import math
print(math.pi) # 3.141592653589793
print(math.sqrt(16)) # 4.0
# 导入模块中的特定函数
from math import pi, sqrt
print(pi) # 3.141592653589793
print(sqrt(16)) # 4.0
# 导入模块并起别名
import math as m
print(m.pi) # 3.141592653589793
四、面向对象编程
核心差异：Python 的面向对象比 Java 更灵活，支持多继承，没有接口概念，所有属性和方法默认都是公有的。
1. 类与对象
# 定义类
class Person:
# 构造方法
def __init__(self, name, age):
self.name = name # 实例属性
self.age = age
# 实例方法
def say_hello(self):
print(f"大家好，我是{self.name}，今年{self.age}岁")
# 创建对象
person1 = Person("张三", 20)
# 访问属性 使用点号 . 来访问对象的属性
person1.say_hello() # 大家好，我是张三，今年20岁
# 访问，新增和修改属性
print(person1.name) # 张三
person1.phone = 10086 # 新增属性
person1.phone = 1008611 # 修改属性
print(person1.phone) # 1008611
# 删除属性
del person1.phone
--- 用函数的方式来访问属性
hasattr(person1, 'age') # 如果存在 'age' 属性返回 True。
getattr(person1, 'age') # 返回 'age' 属性的值
setattr(person1, 'age', 8) # 添加属性 'age' 值为 8
delattr(person1, 'age') # 删除属性 'age'
2. 继承
# 子类继承父类
class Student(Person):
def __init__(self, name, age, student_id):
super().__init__(name, age) # 调用父类构造方法
self.student_id = student_id
# 重写父类方法
def say_hello(self):
print(f"大家好，我是{self.name}，今年{self.age}岁，学号是{self.student_id}")
# 子类特有方法
def study(self, subject):
print(f"{self.name}正在学习{subject}")
# 创建子类对象
student1 = Student("李四", 18, 1001)
student1.say_hello() # 大家好，我是李四，今年18岁，学号是1001
student1.study("Python") # 李四正在学习Python
3. 魔法方法
Python 中以双下划线开头和结尾的方法，用于实现类的特殊行为。
class Book:
def __init__(self, title, author, price):
self.title = title
self.author = author
self.price = price
# 自定义对象的字符串表示
def __str__(self):
return f"《{self.title}》- {self.author}，价格：{self.price}元"
# 自定义对象的相等比较
def __eq__(self, other):
if isinstance(other, Book):
return self.title == other.title and self.author == other.author
return False
book1 = Book("Python编程", "张三", 59.9)
book2 = Book("Python编程", "张三", 69.9)
print(book1) # 《Python编程》- 张三，价格：59.9元
print(book1 == book2) # True（因为标题和作者相同）
常见的魔法方法
- 对象的“出生”与销毁
| 魔法方法 | 作用 |
|---|---|
__init__ |
初始化对象时自动调用（构造函数） |
__del__ |
对象销毁时自动调用（析构函数） |
__new__ |
创建对象本体，比 init 更早执行 |
注意：平时只用重写 __init__ 就够了，__new__ 和 __del__ 是进阶场景
class Dog:
def __init__(self, name):
print("一只狗出生了")
self.name = name
def __del__(self):
print(f"{self.name} 被销毁了")
d = Dog("大黄")
- 对象怎么“被打印”
| 魔法方法 | 作用 |
|---|---|
__str__ |
控制 print(obj) 的输出 |
__repr__ |
控制调试时的显示，推荐写得更精准 |
class Book:
def __init__(self, title):
self.title = title
def __str__(self):
return f" {self.title}"
def __repr__(self):
return f"Book('{self.title}')"
b = Book("Python入门")
print(b) # 调用 __str__
print([b]) # 调用 __repr__
- 运算符重载，让对象也能 + - * ==
| 魔法方法 | 作用 |
|---|---|
__add__ |
+ 运算 |
__sub__ |
- 运算 |
__eq__ |
== 比较是否相等 |
__lt__ |
< 比较大小 |
class Price:
def __init__(self, yuan):
self.yuan = yuan
def __add__(self, other):
return Price(self.yuan + other.yuan)
def __eq__(self, other):
return self.yuan == other.yuan
def __str__(self):
return f"{self.yuan}元"
p1 = Price(30)
p2 = Price(20)
print(p1 + p2) # 输出 50元
print(p1 == p2) # False
- 让对象支持索引、遍历、len()
| 魔法方法 | 作用 |
|---|---|
__getitem__
|
支持 obj[index] |
__setitem__ |
支持赋值 obj[key] = val |
__delitem__ |
删除元素 |
__len__ |
支持 len(obj) |
contains |
支持 in 判断是否包含 |
__iter__, __next__ |
支持 for ... in 遍历 |
class MyList:
def __init__(self):
self.data = [1, 2, 3]
def __getitem__(self, index):
return self.data[index]
def __len__(self):
return len(self.data)
ml = MyList()
print(ml[0]) # 输出 1
print(len(ml)) # 输出 3
- 让对象能像函数一样调用
| 魔法方法 | 作用 |
|---|---|
__call__ |
支持 obj() 形式调用 |
class Hello:
def __call__(self, name):
print(f"你好，{name}！")
h = Hello()
h("张三") # 相当于调用函数
- 上下文管理器（配合with）
| 魔法方法 | 作用 |
|---|---|
__enter__ |
进入上下文时调用 |
__exit__ |
离开上下文时调用 |
class MyContext:
def __enter__(self):
print("进入上下文")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("退出上下文")
with MyContext():
print("处理中...")
- 对象的真假值和哈希值
| 魔法方法 | 作用 |
|---|---|
__bool__ |
控制对象的布尔值（用于 if） |
__hash__ |
是否可作为字典的 key |
class Empty:
def __bool__(self):
return False
e = Empty()
if not e:
print("对象被认为是 False")
五、文件操作与异常处理
1. 读取键盘输入
raw_input 从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
input 接收一个Python表达式作为输入，并将运算结果返回
2. 文件读写
核心差异：Python 推荐使用with语句（上下文管理器）自动管理文件资源，无需手动关闭文件，避免资源泄漏。
# 写入文件
with open("test.txt", "w", encoding="utf-8") as f:
f.write("Hello, Python!\n")
f.write("这是一个测试文件\n")
# 读取文件
with open("test.txt", "r", encoding="utf-8") as f:
# 读取全部内容
content = f.read()
print(content)
# 逐行读取
with open("test.txt", "r", encoding="utf-8") as f:
for line in f:
print(line.strip()) # strip()去除换行符和空格
| 模式 | 描述 |
|---|---|
| t | 文本模式 (默认)。 |
| x | 写模式，新建一个文件，如果该文件已存在则会报错。 |
| b | 二进制模式。 |
| + | 打开一个文件进行更新(可读可写)。 |
| U | 通用换行模式（不推荐）。 |
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
| w | 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
2. 异常处理
核心差异：Python 的异常处理语法比 Java 更简洁，支持else和finally子句。
python
try:
# 可能会抛出异常的代码
num1 = int(input("请输入第一个数："))
num2 = int(input("请输入第二个数："))
result = num1 / num2
except ValueError:
print("输入的不是有效的整数")
except ZeroDivisionError:
print("除数不能为零")
else:
# 没有异常时执行
print(f"结果是：{result}")
finally:
# 无论是否有异常都会执行
print("程序执行结束")
六、常用标准库
1. os 模块：操作系统接口
import os
# 获取当前工作目录
print(os.getcwd())
# 列出目录下的文件
print(os.listdir("."))
# 创建目录
os.mkdir("test_dir")
# 删除目录
os.rmdir("test_dir")
# 检查文件是否存在
print(os.path.exists("test.txt"))
# 获取文件大小
print(os.path.getsize("test.txt"))
2. datetime 模块：日期时间处理
from datetime import datetime, timedelta
# 获取当前时间
now = datetime.now()
print(now) # 2026-05-08 15:30:00.123456
# 格式化时间
print(now.strftime("%Y-%m-%d %H:%M:%S")) # 2026-05-08 15:30:00
# 时间计算
tomorrow = now + timedelta(days=1)
print(tomorrow)
# 字符串转时间
date_str = "2026-05-08"
date = datetime.strptime(date_str, "%Y-%m-%d")
print(date)
3. json 模块：JSON 数据处理
import json
# Python对象转JSON字符串
student = {
"name": "张三",
"age": 20,
"gender": "男"
}
json_str = json.dumps(student, ensure_ascii=False, indent=4)
print(json_str)
# JSON字符串转Python对象
json_str = '{"name": "李四", "age": 18, "gender": "女"}'
student = json.loads(json_str)
print(student["name"]) # 李四
# 写入JSON文件
with open("student.json", "w", encoding="utf-8") as f:
json.dump(student, f, ensure_ascii=False, indent=4)
# 读取JSON文件
with open("student.json", "r", encoding="utf-8") as f:
student = json.load(f)
print(student)
4. re 模块：正则表达式
import re
# 匹配手机号码
phone_pattern = r"^1[3-9]\d{9}$"
phone = "13812345678"
if re.match(phone_pattern, phone):
print("手机号码格式正确")
else:
print("手机号码格式错误")
# 提取邮箱地址
text = "我的邮箱是zhangsan@example.com，李四的邮箱是lisi@test.com"
email_pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
emails = re.findall(email_pattern, text)
print(emails) # ['zhangsan@example.com', 'lisi@test.com']