python入门第一天学习指南（Java资深/Python小白适用）-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_37607945/article/details/145610178

阶段一：基础语法对比与强化

循环与迭代

# Python for 循环（自动迭代数字序列）
for i in range(5):  # 0~4
    print(i)

# Java 实现对比
# for (int i=0; i<5; i++) { System.out.println(i); }

# 带 else 的循环（仅当循环正常结束时触发）
for x in range(3):
    print(x)
else:
    print("循环完成")  # 输出：0 1 2 循环完成

陷阱案例：

# 当 range 参数未明确时，Java 开发者容易混淆
for i in range(2, 5):  # 包含2，不包含5 → 输出2,3,4（类似 Java 的 [2,5)）
    print(i)

数据结构对比
列表 List（动态类型支持混合模式）：

# 定义与操作
fruits = ["apple", "banana", 123, True]
fruits.append("orange")      # 类似 Java add()
fruits.insert(1, "pear")     # Java 需手动移动元素
print(fruits[0])             # 索引访问（Java get(0)）
print(fruits[-1])            # 反向索引（Java 无此语法）

# Java 对比：ArrayList<Object> list = new ArrayList<>(Arrays.asList("apple", "banana", 123, true));

字典 Dict（类似 Java HashMap）：

user = {
    "name": "Alice",
    "age": 30,
    "skills": ["Python", "Java"]
}
print(user["name"])                   # 直接访问（Java: get("name")）
print(user.get("height", 170))        # 类似 getOrDefault("height", 170)
user["height"] = 175                  # 新增键值对

函数与参数
默认参数陷阱：

# 错误示例（默认参数为可变对象）
def add_element(val, my_list=[]):
    my_list.append(val)
    return my_list

print(add_element(1))  # [1]
print(add_element(2))  # [1, 2] （因为默认参数是同一个列表）

# 正确做法：
def add_element_safe(val, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(val)
    return my_list

可变参数案例：

def calculate_sum(*args):
    return sum(args)

print(calculate_sum(1, 2, 3))  # 6

def build_profile(**kwargs):
    return {key: value for key, value in kwargs.items()}

print(build_profile(name="Bob", age=25))  # {'name': 'Bob', 'age': 25}

阶段二：Python 特有机制

列表推导式（代替 Java Stream）

# 生成平方数
squares = [x**2 for x in range(10) if x % 2 == 0]
# Java 等效：IntStream.range(0, 10).filter(x -> x%2==0).map(x->x*x).boxed().collect(Collectors.toList())

# 推导式嵌套循环
matrix = [[1, 2], [3, 4]]
flatten = [num for row in matrix for num in row]  # [1, 2, 3, 4]

字符串操作

# f-string 动态计算表达式
price = 99.9
print(f"价格：{price * 1.1:.2f}")  # 价格：109.89

# 多行字符串与分割
text = """
    Hello,
    Python!
"""
print(text.strip())  # 移除首尾空白（类似 Java trim()）

异常处理（上下文更灵活）

try:
    value = int("abc")  # 触发 ValueError
except ValueError as e:
    print(f"转换错误: {e}")
except Exception as e:  # 类似 Java 的 catch (Exception e)
    print("未知错误")
else:
    print("转换成功")
finally:
    print("清理完成")

对比 Java：

// Java 需要更明确的异常类型捕获
try {
    int value = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("转换错误: " + e.getMessage());
} finally {
    System.out.println("清理完成");
}

阶段三：陷阱与最佳实践

可变对象引用陷阱

# 修改可变对象影响所有引用
a = [1, 2]
b = a
a.append(3)
print(b)  # [1, 2, 3] （Java 中 ArrayList 的行为与此一致）

# 正确做法（复制对象）：
c = [4, 5]
d = c.copy()     # 或 d = c[:]
c.append(6)
print(d)         # [4, 5]

is 与 == 的区别

a = [1, 2]
b = [1, 2]
print(a == b)   # True （值相等）
print(a is b)   # False （不是同一个对象）

x = 256
y = 256
print(x is y)   # True （小整数缓存）

练习与参考答案

练习 1：多态实现（通过鸭子类型）

class Bird:
    def fly(self):
        print("Flying high")

class Airplane:
    def fly(self):
        print("Engine powered flight")

# 无需继承同一父类
def let_it_fly(obj):
    obj.fly()

let_it_fly(Bird())      # Flying high
let_it_fly(Airplane())  # Engine powered flight

练习 2：动态特性实战

# 动态添加方法给实例
import types
class Dog:
    def __init__(self, name):
        self.name = name

def bark(self):
    print(f"{self.name} says: Woof!")

dog = Dog("Buddy")
dog.bark = types.MethodType(bark, dog)  # 动态绑定方法
dog.bark()  # Buddy says: Woof!

# 动态删除属性
del dog.name
print(hasattr(dog, "name"))  # False

查漏补缺练习

题目：编写一个函数，接受任意数量的关键字参数，并过滤出值为整数的参数，返回它们的平方的列表。
参考答案：

def filter_and_square(**kwargs):
    return [v**2 for v in kwargs.values() if isinstance(v, int)]

print(filter_and_square(a=2, b=3.5, c="test", d=4))  # [4, 16]

进阶陷阱实测
题目：以下代码会输出什么？

def add(value, my_list=[]):
    my_list.append(value)
    return my_list

print(add(1))    # [1]
print(add(2))    # [1, 2]

答案解析：Python 的默认参数在函数定义时初始化一次，多次调用共享同一个列表对象。应对方式见前文 add_element_safe 函数。

通过细化后的代码与陷阱分析，可以帮助你更透彻地迁移 Java 经验到 Python，同时警惕动态语言的特殊设计模式。

完整代码

# 打印一个九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print('%d * %d = %d' % (i, j, i * j), end='\t')
    print()

# 带else的循环(仅当循环正常结束时触发)
for x in range(3):
    print(x)
else:
    print('循环正常结束')

# 输出的结果是不包含5 左闭右开
for i in range(2, 5):
    print(i)

fruits = ['apple', 'banana', 'orange', 123, True]
print(fruits)  # ['apple', 'banana', 'orange', 123, True]
fruits.append("orange")
print(fruits)  # ['apple', 'banana', 'orange', 123, True, 'orange']
fruits.insert(1, "pear")
print(fruits)  # ['apple', 'pear', 'banana', 'orange', 123, True, 'orange']
print(fruits[0])
print(fruits[-1])  # 反向索引（Java 无此语法）
# apple
# orange

user = {
    'name': 'zhangsan',
    'age': 18,
    'gender': 'male',
    'skills': ['java', 'python', 'c++']
}
print(user)
print(user['name'])  # 直接访问（Java: get("name")）
print(user.get('height', '170cm'))  # 类似 getOrDefault("height", 170)
# {'name': 'zhangsan', 'age': 18, 'gender': 'male', 'skills': ['java', 'python', 'c++']}
# zhangsan
# 170cm
user['height'] = '173cm'  # 新增键值对


# 错误示例（默认参数为可变对象）
def add_element(val, my_list=[]):
    my_list.append(val)
    return my_list


print(add_element(1))  # [1]
print(add_element(2))  # [1, 2] （因为默认参数是同一个列表）


def add_element_safe(val, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(val)
    return my_list


print(add_element_safe(1))  # [1]
print(add_element_safe(2))  # [2]


def calculate_sum(*args):
    total = 0
    for num in args:
        total += num
    return total


print(calculate_sum(1, 2, 3, 4, 5))  # 15


def calculate_sum_kwargs(**kwargs):
    total = 0
    for key, value in kwargs.items():
        total += value
    return total


print(calculate_sum_kwargs(a=1, b=2, c=3, d=4, e=5))  # 15


# 这是 Python 中的字典推导式（Dictionary Comprehension）语法。它用于根据现有可迭代对象快速创建一个新的字典。
# 具体来说，{key: value for key, value in kwargs.items()} 遍历 kwargs 字典的键值对，并将每个键值对添加到新字典中。
# kwargs.items() 返回一个包含字典所有键值对的视图对象。
# for key, value in kwargs.items() 遍历每个键值对。
# {key: value ...} 构建新的字典
def build_profile(**kwargs):
    return {key: value for key, value in kwargs.items()}


print(build_profile(name='zhangsan', age=18, gender='male'))  # {'name': 'zhangsan', 'age': 18, 'gender': 'male'}

numbers = [1, 2, 3, 4, 5]
squares_dict = {num: num ** 2 for num in numbers}
print(squares_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

text = "hello"
char_count = {char: text.count(char) for char in text}
print(char_count)  # 输出: {'h': 1, 'e': 1, 'l': 2, 'o': 1}

# 列表推导式 python特有机制
squares = [x ** 2 for x in range(10) if x % 2 == 0]
# Java 等效：IntStream.range(0, 10).filter(x -> x%2==0).map(x->x*x).boxed().collect(Collectors.toList())
print(squares)  # [0, 4, 16, 36, 64]

# 推导式嵌套循环
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 动态计算表达式
price = 99.9
print(f"The price is ${price:.2f}")  # The price is $99.90
print(f"价格为： {price * 1.1:,.2f}")  # 价格为： 109.89

text = """
    Hello,
    Python!
"""
print(text)
print(text.strip())  # 移除首尾空白

try:
    value = int(input("请输入一个整数："))
    print(f"输入的整数是：{value}")
except ValueError as e:
    print(f"输入的不是整数！{e}")
except Exception as e:
    print(f"发生错误！{e}")
else:
    print("没有异常发生！")
finally:
    print("无论是否发生异常，都会执行的代码块。")


# 函数式编程
def square(x1):
    return x1 ** 2


numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(square, numbers))
print(squared_numbers)  # [1, 4, 9,16, 25]

c = [4, 5]
d = c.copy()
c.append(6)
print(d)  # [4, 5]
print(c)  # [4, 5, 6]

a = [1, 2]
b = [1, 2]
print(a == b)  # True （值相等）
print(a is b)  # False （不是同一个对象）

x = 256
y = 256
print(x is y)  # True （小整数缓存）


class Bird:
    def fly(self):
        print("Bird is flying")


class Airplane:
    def fly(self):
        print("Airplane is flying")


def let_it_fly(obj):
    obj.fly()


let_it_fly(Bird())  # Bird is flying
let_it_fly(Airplane())  # Airplane is flying

# 动态添加方法给实例
import types


class Dog:
    def __init__(self, name):
        self.name = name

    def jump(self):
        print(f"{self.name} is jumping")


def bark(self):
    print(f"{self.name} is barking")


dog = Dog("Max")

dog.jump()  # Max is jumping

dog.bark = types.MethodType(bark, dog)
dog.bark()  # Max is barking

dog.run = types.MethodType(lambda self: print(f"{self.name} is running"), dog)
dog.run()  # Max is running

# 删除方法
del dog.run

# 删除属性
del dog.name

print(hasattr(dog, "name"))  # False

# 删除实例
del dog

# 过滤并平方
def filter_and_square(**kwargs):
    return [v ** 2 for v in kwargs.values() if isinstance(v, int)]


print(filter_and_square(a=2, b=3.5, c="test", d=4))  # [4, 16]