Java开发者7天速成Python：从语法到实战的完整指南

引言

你是一位有Java基础的程序员，想要快速学习Python。但你不想从头开始——你希望用已有的编程思维快速切换到Python的优雅世界。

这篇文章就是为你准备的。

7天，每天1小时，从Java的严谨到Python的优雅，通过对比学习让你快速掌握Python的核心技能。

本文包含：

✅ 丰富的代码示例（Java vs Python对比）
✅ 每天练习题（带答案）
✅ Day 7实战项目（股票分析工具）
✅ 完整的学习路径

💡 提示：Cheat Sheet（Java-Python对照表）已单独整理成另一篇文章，本教程专注于实战学习。

📋 学习路径

天数	主题	核心目标
Day 1	语法基础	理解动态类型、掌握字符串切片
Day 2	控制流与函数	适应缩进语法、理解参数机制
Day 3	数据结构	掌握四大核心容器、列表推导式
Day 4	面向对象	理解类定义、继承、多态
Day 5	异常与文件	掌握异常处理、with语句、JSON
Day 6	高级特性	理解装饰器、生成器、上下文管理器
Day 7	实战项目	完成股票分析工具

Day 1: 语法基础

🎯 今日目标

理解Python的动态类型 vs Java的静态类型
掌握字符串切片（Python独有）
学会f-string格式化

变量与类型

Java: 静态类型

// 必须声明类型
String name = "小熊";
int age = 28;
double salary = 11000.0;
boolean isActive = true;

// 类型不匹配会编译错误
// int x = "错误"; // ❌ 编译错误

Python: 动态类型

# 不需要声明类型，自动推断
name = "小熊"
age = 28
salary = 11000.0
is_active = True

# 同一变量可以改变类型（不推荐但允许）
x = 10        # int
x = "hello"    # str
x = [1, 2, 3] # list

关键差异

Java	Python	差异
编译时类型检查	运行时类型推断	Python更灵活但易出错
`int x = 3.14` 会报错	`x = 3.14` 正常，类型是float	Python不自动转换
`null`	`None`	空值表示
`final`	无，用大写常量	`MAX_SIZE = 100`

字符串切片（Python独有）

Java

String s = "Hello World";
s.substring(0, 5);       // "Hello"
s.substring(6);          // "World"

Python

s = "Hello World"
s[0:5]                    # "Hello" - 索引0到4
s[6:]                      # "World" - 从6到末尾
s[:5]                       # "Hello" - 从开始到4
s[::2]                       # "HloWrd" - 每隔一个
s[::-1]                      # "dlroW olleH" - 反转
s[-1]                        # "d" - 最后一个

Java需要用substring()或循环，Python一行搞定。

切片语法总结

s[start:end:step]

start：起始位置（包含）
end：结束位置（不包含）
step：步长

实用示例

# 提取文件名
filename = "data_20260203.csv"
name = filename[:-4]  # "data"

# 提取扩展名
ext = filename[-4:]  # ".csv"

# 反转字符串
reversed = s[::-1]

# 每隔一个字符取
every_other = s[::2]

f-string格式化

Java

String name = "小熊";
int age = 28;

System.out.println("Hello, " + name);
System.out.printf("Age: %d\n", age);

Python

name = "小熊"
age = 28
salary = 11000.5

# f-string - 最直观
print(f"Hello, {name}")
print(f"Age: {age}")
print(f"Salary: {salary:.2f}")       # 保留2位小数
print(f"Age: {age:03d}")           # 补零到3位

# 对齐输出
print(f"{'姓名':<10}{'年龄':>5}")      # 左右对齐

Day 1 练习

任务1：个人信息收集器

# 从控制台读取
name = input("姓名: ")
age = int(input("年龄: "))
salary = float(input("月薪: "))
is_developer = input("是程序员吗(y/n): ") == 'y'

# 用f-string输出
print(f"""
=== 个人信息 ===
姓名: {name}
年龄: {age}
月薪: {salary:.2f}
职业: {'开发者' if is_developer else '其他'}
""")

任务2：字符串切片练习

s = "Python Programming Language"

# TODO: 提取"Python"
print(s[0:6])

# TODO: 提取"Language"
print(s[-8:])

# TODO: 反转字符串
print(s[::-1])

# TODO: 每隔一个字符取一个字符
print(s[::2])

答案

# 任务2答案
print(s[0:6])        # "Python"
print(s[-8:])           # "Language"
print(s[::-1])          # "egauLgnimmartoP nohtyP"
print(s[::2])           # "Pto rgamn iguaLn"

Day 2: 控制流与函数

🎯 今日目标

适应Python的缩进语法（无花括号）
理解参数机制（位置、默认、可变、关键字）
掌握lambda表达式

缩进与代码块

Java

public void process(int x) {
    if (x > 0) {
        System.out.println("正数");
    } else {
        System.out.println("非正数");
    }

    for (int i = 0; i < 10; i++) {
        System.out.println(i);
    }
}

Python

def process(x):
    # 缩进表示代码块（通常是4个空格）
    if x > 0:
        print("正数")
    else:
        print("非正数")

    for i in range(10):
        print(i)

⚠️ 易错点

Java习惯	Python现实	结果
忘记写分号`;`	不需要分号	✅ 正确
用花括号`{}`	用缩进	❌ 语法错误
`if (x > 0)`	`if x > 0:`	❌ 需要冒号
`else if`	`elif`	❌ 语法错误

enumerate() - 同时获取索引和值

Java

String[] names = {"小熊", "Jiavis", "Python"};
for (int i = 0; i < names.length; i++) {
    System.out.println(i + ": " + names[i]);
}

Python

names = ["小熊", "Jiavis", "Python"]
for index, name in enumerate(names):
    print(f"{index}: {name}")

参数机制

默认参数（注意坑）

# ⚠️ 注意：默认参数只计算一次！
def add_item(item, items=[]):    # ❌ 错误！
    items.append(item)
    return items

# 正确做法
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

关键字参数

def create_user(name, age, city="上海"):
    print(f"{name}, {age}, {city}")

# 位置参数
create_user("小熊", 28)

# 关键字参数
create_user(name="小熊", age=28)

# 混合（Python独有：可以打乱顺序）
create_user(city="北京", age=28, name="小熊")

Lambda表达式

Java

import java.util.function.*;

Consumer<String> printer = s -> System.out.println(s);
Function<Integer, Integer> doubler = x -> x * 2;
Predicate<Integer> isEven = x -> x % 2 == 0;

Python

# Lambda语法：lambda args: expression
printer = lambda s: print(s)
doubler = lambda x: x * 2
is_even = lambda x: x % 2 == 0

# 使用
printer("Hello")
print(doubler(5))
print(is_even(4))

# 与内置函数配合
numbers = [1, 2, 3, 4, 5]
even = list(filter(lambda x: x % 2 == 0, numbers))
squared = list(map(lambda x: x ** 2, numbers))
total = sum(map(lambda x: x, numbers))

Day 2 练习

任务1：计算器函数

def calculator(a, b, operation):
    """
    实现加减乘除
    - operation: "+", "-", "*", "/"
    - 除法检查除0
    """
    if operation == "+":
        return a + b
    elif operation == "-":
        return a - b
    elif operation == "*":
        return a * b
    elif operation == "/":
        if b == 0:
            return "不能除0"
        return a / b
    else:
        return "未知操作"

# 测试
print(calculator(10, 5, "+"))   # 15
print(calculator(10, 5, "/"))   # 2.0
print(calculator(10, 0, "/"))   # "不能除0"

任务2：Lambda练习

numbers = list(range(1, 21)))

# TODO: 用lambda筛选出偶数
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)

# TODO: 用lambda计算平方
squared = list(map(lambda x: x ** 2, numbers))
print(squared)

# TODO: 用lambda求和
total = sum(map(lambda x: x, numbers))
print(total)

Day 3: 数据结构

🎯 今日目标

掌握列表推导式（核心特性）
学会字典高级操作
理解元组和解包

列表推导式

传统方式

# Java风格（啰嗦）
squares = []
for i in range(10):
    squares.append(i ** 2)
print(squares)

列表推导式

# Python风格（一行搞定）
squares = [i ** 2 for i in range(10)]
print(squares)

# 带条件
even_squares = [i ** 2 for i in range(10) if i % 2 == 0]
print(even_squares)

# 嵌套循环（扁平化矩阵）
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)

字典推导式

# 传统方式
squared = {}
for i in range(5):
    squared[i] = i ** 2

# 字典推导式（一行搞定）
squared = {i: i ** 2 for i in range(5)}
print(squared)

# 带条件
even_squared = {i: i ** 2 for i in range(10) if i % 2 == 0}
print(even_squared)

zip() - 同时遍历多个列表

names = ["小熊", "Jiavis", "Python"]
ages = [28, 999, 33]
scores = [85, 95, 90]

# 同时遍历
for name, age, score in zip(names, ages, scores):
    print(f"{name}: {age}岁, {score}分")

Day 3 练习

任务1：列表推导式

# 1. 生成1-100中能被3整除的数列表
div_by_3 = [x for x in range(1, 101) if x % 3 == 0]
print(div_by_3[:10])

# 2. 将单词首字母大写
words = ["hello", "world", "python"]
capitalized = [w.capitalize() for w in words]
print(capitalized)

# 3. 筛选素数
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

primes = [n for n in range(1, 101) if is_prime(n)]
print(primes[:10])
print(f"前100个素数: {len(primes)}个")

任务2：字典统计

text = "python python java java python"
word_count = {}

for word in text.split():
    word_count[word] = word_count.get(word, 0) + 1

print(word_count)
# {'python': 3, 'java': 3}

Day 4: 面向对象

🎯 今日目标

理解Python的类定义
掌握self的使用
学会继承和方法重写

类定义对比

Java

public class User {
    // 私有字段
    private String name;
    private int age;

    // 构造器
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter/Setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // 方法
    public void greet() {
        System.out.println("Hello, " + name);
    }
}

Python

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, {self.name}")

user = User("小熊", 28)
user.greet()

多继承（Python独有）

// Java不支持多继承（用接口）
public class Duck implements Flyable, Swimable {
    // ...
}

# Python支持多继承！
class Flyable:
    def fly(self):
        print("Flying...")

class Swimable:
    def swim(self):
        print("Swimming...")

class Duck(Flyable, Swimable):  # 多继承
    pass

duck = Duck()
duck.fly()
duck.swim()

Day 4 练习

class BankAccount:
    """
    实现以下功能：
    - 存款(deposit)
    - 取款(withdraw)
    - 查询余额(get_balance)
    - 显示账户信息(__str__)
    """
    def __init__(self, owner, initial_balance=0):
        self.owner = owner
        self.balance = initial_balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("存款金额必须大于0")
        self.balance += amount
        return self.balance

    def withdraw(self, amount):
        if amount > self.balance:
            return False
        self.balance -= amount
        return True

    def get_balance(self):
        return self.balance

    def __str__(self):
        return f"账户: {self.owner}, 余额: {self.balance:.2f}元"

# 测试
account = BankAccount("小熊", 1000)
account.deposit(500)
print(account)
account.withdraw(200)
print(account.get_balance())

Day 5: 异常处理与文件操作

🎯 今日目标

掌握异常处理（try-except-else-finally）
理解with语句（上下文管理器）
学会JSON操作

with语句（上下文管理器）

这是Python最优雅的特性之一。

Java

FileInputStream fis = null;
try {
    fis = new FileInputStream("file.txt");
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fis != null) {
        try {
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Python

# 自动管理资源（自动关闭）
with open("file.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# 文件已经自动关闭了，不需要finally

Day 5 练习

import json
from datetime import datetime

class Logger:
    def __init__(self, filename="app.log"):
        self.filename = filename

    def info(self, message):
        self._write_log("INFO", message)

    def error(self, message):
        self._write_log("ERROR", message)

    def _write_log(self, level, message):
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "level": level,
            "message": message
        }
        with open(self.filename, "a", encoding="utf-8") as f:
            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")

# 测试
logger = Logger()
logger.info("程序启动")
logger.error("发生错误")

Day 6: 高级特性

🎯 今日目标

理解装饰器
掌握生成器和yield
学会上下文管理器

装饰器

传统方式

def add(a, b):
    result = a + b
    print(f"{a} + {b} = {result}")
    return result

装饰器方式

def log_function(func):
    def wrapper(*args, **kwargs):
        print(f"调用函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"返回结果: {result}")
        return result
    return wrapper

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

生成器

列表方式

def get_squares(n):
    result = []
    for i in range(n):
        result.append(i ** 2)
    return result

生成器方式

def get_squares_generator(n):
    for i in range(n):
        yield i ** 2

for square in get_squares_generator(10):
    print(square)

Day 6 练习

# 任务1：缓存装饰器
def memoize(func):
    cache = {}
    def wrapper(*args):
        key = args
        if key in cache:
            print("从缓存读取")
            return cache[key]
        result = func(*args)
        cache[key] = result
        return result
    return wrapper

@memoize
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(35))

Day 7: 实战项目

🎯 今日目标

应用前6天学到的知识
完成一个实际项目
巩固Python技能

项目：股票分析工具

import json
from datetime import datetime

class StockAnalyzer:
    def __init__(self, stock_data_file):
        self.stocks = self._load_data(stock_data_file)

    def _load_data(self, filename):
        try:
            with open(filename, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            print(f"文件 {filename} 不存在")
            return {}

    def analyze(self, code):
        if code not in self.stocks:
            return f"股票 {code} 不存在"

        stock = self.stocks[code]
        name = stock.get('name', '未知')
        price = stock.get('price', 0)
        ma5 = stock.get('ma5', 0)

        if price > ma5 * 1.05:
            advice = "观望（价格超过MA5 5%）"
        elif price > ma5:
            advice = "持有（价格高于MA5）"
        else:
            advice = "关注（价格低于MA5）"

        return f"""
=== {name}({code}) 分析 ===
当前价格: {price}
MA5: {ma5}
建议: {advice}
分析时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
"""

    def batch_analyze(self, codes):
        print(f"=== 批量分析 {len(codes)} 只股票 ===")
        for code in codes:
            result = self.analyze(code)
            print(result)

    def export_report(self, codes, filename):
        report = []
        for code in codes:
            if code in self.stocks:
                stock = self.stocks[code]
                report.append({
                    "code": code,
                    "name": stock.get('name', '未知'),
                    "price": stock.get('price', 0),
                    "ma5": stock.get('ma5', 0),
                })

        with open(filename, 'w', encoding='utf-8') as f:
            json.dump(report, f, ensure_ascii=False, indent=2)
        print(f"报告已导出到 {filename}")


# 示例数据
sample_data = {
    "600519": {
        "name": "贵州茅台",
        "price": 1800.0,
        "ma5": 1750.0,
        "ma10": 1720.0,
        "ma20": 1700.0,
    },
    "000001": {
        "name": "平安银行",
        "price": 15.5,
        "ma5": 15.8,
        "ma10": 15.6,
        "ma20": 15.4,
    },
}

# 保存示例数据
with open('stocks.json', 'w', encoding='utf-8') as f:
    json.dump(sample_data, f, ensure_ascii=False, indent=2)

# 使用示例
if __name__ == "__main__":
    analyzer = StockAnalyzer('stocks.json')
    print(analyzer.analyze("600519"))
    analyzer.batch_analyze(["600519", "000001"])
    analyzer.export_report(["600519", "000001"], "report.json")

项目扩展任务

# 任务1：添加技术指标计算
def calculate_ma(prices, period=5):
    return [sum(prices[i-period+1:i+1])/period
            for i in range(period-1, len(prices))]

# 任务2：添加可视化（需要matplotlib）
# pip install matplotlib
# def draw_chart(data):
#     import matplotlib.pyplot as plt
#     ...

# 任务3：添加回测功能
def backtest_strategy(stock_data, buy_condition, sell_condition):
    pass

🎯 学习完成总结

核心差异

维度	Java	Python
类型系统	静态类型	动态类型
语法	花括号、分号	缩进、无分号
变量声明	`int x = 10;`	`x = 10`
空值	`null`	`None`
布尔值	`true/false`	`True/False`
字符串	不可变，`equals()`	不可变，`==`
数组	`int[]`（固定）	`list`（动态）
字典	`Map<K,V>`	`dict`
继承	单继承 + 接口	多继承
异常	`try-catch-finally`	`try-except-else-finally`
资源管理	`try-finally`	`with`语句
装饰器	AOP框架	`@decorator`
生成器	Iterator接口	`yield`

Java开发者7天速成Python：从语法到实战的完整指南

引言

📋 学习路径

Day 1: 语法基础

🎯 今日目标

变量与类型

Java: 静态类型

Python: 动态类型

关键差异

字符串切片（Python独有）

Java

Python

切片语法总结

实用示例

f-string格式化

Java

Python

Day 1 练习

任务1：个人信息收集器

任务2：字符串切片练习

答案

Day 2: 控制流与函数

🎯 今日目标

缩进与代码块

Java

Python

⚠️ 易错点

enumerate() - 同时获取索引和值

Java

Python

参数机制

默认参数（注意坑）

关键字参数

Lambda表达式

Java

Python

Day 2 练习

任务1：计算器函数

任务2：Lambda练习

Day 3: 数据结构

🎯 今日目标

列表推导式

传统方式

列表推导式

字典推导式

zip() - 同时遍历多个列表

Day 3 练习

任务1：列表推导式

任务2：字典统计

Day 4: 面向对象

🎯 今日目标

类定义对比

Java

Python

多继承（Python独有）

Day 4 练习

Day 5: 异常处理与文件操作

🎯 今日目标

with语句（上下文管理器）

Java

Python

Day 5 练习

Day 6: 高级特性

🎯 今日目标

装饰器

传统方式

装饰器方式

生成器

列表方式

生成器方式

Day 6 练习

Day 7: 实战项目

🎯 今日目标

项目：股票分析工具

项目扩展任务

🎯 学习完成总结

核心差异

下一步学习

基础巩固

进阶方向