Python 零基础学习指南

Python 零基础学习指南 | 极客日志

# 打开命令行，输入： python --version
# 应该显示：Python 3.x.x

# 这是你的第一个 Python 程序
print("Hello, World!")
print("欢迎来到 Python 的世界！")

Hello, World! 欢迎来到 Python 的世界！

领域	应用	热门库
🌐 网站开发	制作网站和 API	Django, Flask
🤖 人工智能	机器学习、深度学习	TensorFlow, PyTorch
📊 数据分析	数据处理和可视化	Pandas, Matplotlib
🎮 游戏开发	2D 游戏制作	Pygame
🔧 自动化	重复任务自动化	Selenium, requests

# 修改下面的代码，介绍你自己
name = "你的名字"
age = 你的年龄
hobby = "你的爱好"
print(f"大家好，我是{name}")
print(f"我今年{age}岁")
print(f"我喜欢{hobby}")

# 创建变量就像贴标签
name = "小明"      # 字符串变量
age = 18           # 整数变量
height = 1.75      # 小数变量
is_student = True  # 布尔变量
print(f"姓名：{name}")
print(f"年龄：{age}")
print(f"身高：{height}米")
print(f"是学生：{is_student}")

user_name = "张三"   # 使用下划线
userAge = 25         # 驼峰命名法
score1 = 95          # 可以包含数字
_private = "私有变量" # 可以以下划线开头

# 1name = "错误"    # 不能以数字开头
# user-name = "错误" # 不能包含连字符
# for = "错误"       # 不能使用关键字

# 这是单行注释，用来解释代码
""" 这是多行注释
可以写很多行
通常用来写详细说明
"""
name = "Python"  # 这里也可以写注释

# 数学运算
a = 10
b = 3
print(f"{a} + {b} = {a + b}")     # 加法：13
print(f"{a} - {b} = {a - b}")     # 减法：7
print(f"{a} * {b} = {a * b}")     # 乘法：30
print(f"{a} / {b} = {a / b}")     # 除法：3.33...
print(f"{a} // {b} = {a // b}")   # 整除：3
print(f"{a} % {b} = {a % b}")     # 取余：1
print(f"{a} ** {b} = {a ** b}")   # 幂运算：1000

# 比较运算（返回 True 或 False）
x = 5
y = 3
print(f"{x} > {y} = {x > y}")     # True
print(f"{x} == {y} = {x == y}")   # False
print(f"{x} != {y} = {x != y}")   # True

# 逻辑运算
is_sunny = True
is_warm = False
print(f"晴天且温暖：{is_sunny and is_warm}") # False
print(f"晴天或温暖：{is_sunny or is_warm}")  # True
print(f"不是晴天：{not is_sunny}")            # False

# 获取用户输入
name = input("请输入你的名字：")
age_str = input("请输入你的年龄：")

# 类型转换
age = int(age_str)  # 将字符串转换为整数

# 格式化输出
print(f"你好，{name}！")
print(f"你今年{age}岁了。")

# 计算明年年龄
next_year_age = age + 1
print(f"明年你就{next_year_age}岁了！")

name = "小红"
score = 95.5
subject = "数学"

# 方法 1：f-string（推荐）
print(f"{name}的{subject}成绩是{score}分")

# 方法 2：format 方法
print("{}的{}成绩是{}分".format(name, subject, score))

# 方法 3：%格式化（旧式）
print("%s的%s成绩是%.1f分" % (name, subject, score))

# ❌ 错误
if True:
print("这会报错")  # 没有缩进

# ✅ 正确
if True:
    print("这是正确的")  # 有缩进

# ❌ 错误
print(Name)  # Name 未定义

# ✅ 正确
name = "Python"
print(name)  # 先定义再使用

# 制作一个简单的计算器
num1 = float(input("请输入第一个数字："))
num2 = float(input("请输入第二个数字："))
print(f"加法：{num1} + {num2} = {num1 + num2}")
print(f"减法：{num1} - {num2} = {num1 - num2}")
print(f"乘法：{num1} * {num2} = {num1 * num2}")
if num2 != 0:
    print(f"除法：{num1} / {num2} = {num1 / num2}")
else:
    print("除数不能为 0！")

# 根据年龄判断人生阶段
age = int(input("请输入你的年龄："))
if age < 0:
    print("年龄不能为负数！")
elif age <= 12:
    print("你还是个孩子")
elif age <= 18:
    print("你是青少年")
elif age <= 60:
    print("你是成年人")
else:
    print("你是老年人")

# 整数 - 没有小数点的数字
age = 25
temperature = -10
big_number = 1000000
print(f"年龄：{age}")
print(f"温度：{temperature}°C")
print(f"大数字：{big_number:,}")  # 添加千位分隔符

# 浮点数 - 有小数点的数字
height = 1.75
pi = 3.14159
price = 99.99
print(f"身高：{height}米")
print(f"圆周率：{pi}")
print(f"价格：￥{price}")

# 有用的数字操作
import math
number = 16
print(f"平方根：{math.sqrt(number)}")
print(f"向上取整：{math.ceil(3.2)}")  # 4
print(f"向下取整：{math.floor(3.8)}") # 3
print(f"四舍五入：{round(3.14159, 2)}") # 3.14

# 创建字符串
message = "Hello, Python!"
name = '小明'
long_text = """
这是一个 多行字符串
可以写很多行
"""
print(message)
print(name)
print(long_text)

text = "Python 编程"
# 字符串长度
print(f"字符串长度：{len(text)}")
# 字符串索引（从 0 开始）
print(f"第一个字符：{text[0]}")  # P
print(f"最后一个字符：{text[-1]}")  # 程
# 字符串切片
print(f"前 3 个字符：{text[:3]}")  # Pyt
print(f"后 2 个字符：{text[-2:]}")  # 编程
print(f"中间部分：{text[2:5]}")  # tho

sentence = " Hello, World! "
print(f"原始：'{sentence}'")
print(f"大写：{sentence.upper()}")
print(f"小写：{sentence.lower()}")
print(f"去空格：'{sentence.strip()}'")
print(f"替换：{sentence.replace('World', 'Python')}")
print(f"分割：{sentence.split(',')}")

# 创建列表
fruits = ["苹果", "香蕉", "橙子"]
numbers = [1, 2, 3, 4, 5]
mixed = ["Python", 3.14, True, [1, 2, 3]]
print(f"水果：{fruits}")
print(f"数字：{numbers}")
print(f"混合：{mixed}")

shopping_list = ["牛奶", "面包"]
# 添加物品
shopping_list.append("鸡蛋")  # 在末尾添加
shopping_list.insert(0, "水果")  # 在开头添加
print(f"购物清单：{shopping_list}")

# 删除物品
shopping_list.remove("面包")  # 删除指定物品
last_item = shopping_list.pop()  # 删除并返回最后一个
print(f"删除后：{shopping_list}")
print(f"删除的物品：{last_item}")  # 面包

# 列表信息
print(f"清单长度：{len(shopping_list)}")
print(f"第一个物品：{shopping_list[0]}")

# 传统方法
squares = []
for i in range(1, 6):
    squares.append(i ** 2)

# 列表推导式（更简洁）
squares = [i ** 2 for i in range(1, 6)]
print(f"平方数：{squares}")  # [1, 4, 9, 16, 25]

# 带条件的列表推导式
even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(f"偶数的平方：{even_squares}")  # [4, 16, 36, 64, 100]

# 创建元组
coordinates = (10, 20)
colors = ("红", "绿", "蓝")
single_item = (42,)  # 单元素元组需要逗号
print(f"坐标：{coordinates}")
print(f"颜色：{colors}")

# 元组解包
x, y = coordinates
print(f"x 坐标：{x}, y 坐标：{y}")

# 元组的用途
def get_name_age():
    return "小明", 18  # 返回元组

name, age = get_name_age()
print(f"姓名：{name}, 年龄：{age}")

# 创建字典
student = {"姓名": "小红", "年龄": 20, "专业": "计算机科学", "成绩": [85, 92, 78]}
print(f"学生信息：{student}")

# 访问字典
print(f"姓名：{student['姓名']}")
print(f"年龄：{student.get('年龄', '未知')}")  # 安全访问

# 修改字典
student["年龄"] = 21  # 修改
student["学号"] = "2023001"  # 添加
print(f"更新后：{student}")

# 遍历字典
for key, value in student.items():
    print(f"{key}: {value}")

# 创建集合
fruits = {"苹果", "香蕉", "橙子", "苹果"}  # 重复的"苹果"会被去除
print(f"水果集合：{fruits}")

# 集合操作
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
print(f"交集：{set1 & set2}")  # {3, 4}
print(f"并集：{set1 | set2}")  # {1, 2, 3, 4, 5, 6}
print(f"差集：{set1 - set2}")  # {1, 2}

# 集合的实际应用
all_students = ["小明", "小红", "小刚", "小明", "小红"]
unique_students = set(all_students)
print(f"去重后的学生：{unique_students}")

# 类型转换示例
number_str = "123"
float_str = "3.14"
bool_str = "True"

# 转换为不同类型
print(f"字符串转整数：{int(number_str)}")
print(f"字符串转浮点数：{float(float_str)}")
print(f"数字转字符串：{str(456)}")
print(f"列表转集合：{set([1, 2, 2, 3])}")

# 检查类型
age = 25
print(f"age 的类型：{type(age)}")
print(f"是否为整数：{isinstance(age, int)}")

# 创建学生成绩字典
students = {"小明": [85, 92, 78], "小红": [90, 88, 95], "小刚": [76, 84, 89]}

# 计算每个学生的平均分
for name, scores in students.items():
    average = sum(scores) / len(scores)
    print(f"{name}的平均分：{average:.1f}")

# 找出最高分
all_scores = []
for scores in students.values():
    all_scores.extend(scores)
print(f"最高分：{max(all_scores)}")
print(f"最低分：{min(all_scores)}")

# 商品价格字典
prices = {"苹果": 5.0, "香蕉": 3.0, "橙子": 4.5, "牛奶": 12.0}

# 购物车列表
cart = []

# 模拟购物
cart.append("苹果")
cart.append("牛奶")
cart.append("苹果")  # 买了 2 个苹果

# 计算总价
total = 0
for item in cart:
    total += prices[item]
    print(f"添加 {item}，价格：￥{prices[item]}")
print(f"总价：￥{total}")

# 统计每种商品的数量
from collections import Counter
item_count = Counter(cart)
print(f"购买清单：{dict(item_count)}")

# 基本 if 语句
weather = "晴天"
if weather == "晴天":
    print("今天天气不错，出去走走吧！")
elif weather == "雨天":
    print("下雨了，记得带伞！")
else:
    print("不管什么天气，保持好心情！")

score = int(input("请输入你的成绩："))
if score >= 90:
    grade = "A"
    comment = "优秀！"
elif score >= 80:
    grade = "B"
    comment = "良好！"
elif score >= 70:
    grade = "C"
    comment = "中等"
elif score >= 60:
    grade = "D"
    comment = "及格"
else:
    grade = "F"
    comment = "需要努力"
print(f"成绩：{score}分")
print(f"等级：{grade}")
print(f"评价：{comment}")

age = 20
has_license = True
has_car = False

# 多条件判断
if age >= 18 and has_license:
    if has_car:
        print("你可以开车出行！")
    else:
        print("你可以租车或借车！")
elif age >= 18:
    print("你需要先考驾照！")
else:
    print("你还太年轻，不能开车！")

# 三元运算符（简化的 if-else）
status = "成年人" if age >= 18 else "未成年人"
print(f"你是：{status}")

# 基本 for 循环
print("倒计时：")
for i in range(5, 0, -1):
    print(f"{i}...")
print("发射！🚀")

# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
print("\n我喜欢的水果：")
for fruit in fruits:
    print(f"- {fruit}")

# 带索引的遍历
print("\n带编号的水果：")
for index, fruit in enumerate(fruits, 1):
    print(f"{index}. {fruit}")

# 猜数字游戏
import random
secret_number = random.randint(1, 100)
attempts = 0
max_attempts = 7
print("🎯 猜数字游戏！我想了一个 1-100 的数字")
print(f"你有{max_attempts}次机会！")

while attempts < max_attempts:
    guess = int(input("请输入你的猜测："))
    attempts += 1
    if guess == secret_number:
        print(f"🎉 恭喜！你用{attempts}次就猜对了！")
        break
    elif guess < secret_number:
        print("太小了！")
    else:
        print("太大了！")
    remaining = max_attempts - attempts
    if remaining > 0:
        print(f"还有{remaining}次机会")
    else:
        print(f"😢 游戏结束！答案是{secret_number}")

# break 和 continue 的使用
print("寻找 1-20 中能被 3 整除但不能被 6 整除的数：")
for num in range(1, 21):
    if num % 3 != 0:
        continue  # 跳过不能被 3 整除的数
    if num % 6 == 0:
        continue  # 跳过能被 6 整除的数
    print(num, end=" ")
print()

def check_password_strength(password):
    """检查密码强度"""
    score = 0
    feedback = []
    
    # 长度检查
    if len(password) >= 8:
        score += 1
    else:
        feedback.append("密码至少需要 8 位")
    
    # 包含数字
    if any(c.isdigit() for c in password):
        score += 1
    else:
        feedback.append("需要包含数字")
    
    # 包含小写字母
    if any(c.islower() for c in password):
        score += 1
    else:
        feedback.append("需要包含小写字母")
    
    # 包含大写字母
    if any(c.isupper() for c in password):
        score += 1
    else:
        feedback.append("需要包含大写字母")
    
    # 包含特殊字符
    special_chars = "!@#$%^&*"
    if any(c in special_chars for c in password):
        score += 1
    else:
        feedback.append("需要包含特殊字符")
    
    # 评估强度
    if score >= 4:
        strength = "强"
    elif score >= 3:
        strength = "中等"
    else:
        strength = "弱"
    return strength, feedback

# 测试密码
test_passwords = ["123456", "Password1", "MyP@ssw0rd"]
for pwd in test_passwords:
    strength, tips = check_password_strength(pwd)
    print(f"\n密码：{pwd}")
    print(f"强度：{strength}")
    if tips:
        print("建议：")
        for tip in tips:
            print(f" - {tip}")

print("九九乘法表：")
for i in range(1, 10):
    for j in range(1, i + 1):
        result = i * j
        print(f"{j}×{i}={result:2d}", end=" ")
    print()  # 换行

# 简单 ATM 模拟
balance = 1000  # 初始余额
while True:
    print("\n=== 欢迎使用 ATM ===")
    print("1. 查询余额")
    print("2. 存款")
    print("3. 取款")
    print("4. 退出")
    choice = input("请选择操作（1-4）：")
    
    if choice == "1":
        print(f"当前余额：￥{balance}")
    elif choice == "2":
        amount = float(input("请输入存款金额："))
        if amount > 0:
            balance += amount
            print(f"存款成功！当前余额：￥{balance}")
        else:
            print("存款金额必须大于 0！")
    elif choice == "3":
        amount = float(input("请输入取款金额："))
        if amount > balance:
            print("余额不足！")
        elif amount <= 0:
            print("取款金额必须大于 0！")
        else:
            balance -= amount
            print(f"取款成功！当前余额：￥{balance}")
    elif choice == "4":
        print("谢谢使用，再见！")
        break
    else:
        print("无效选择，请重新输入！")

# 定义一个简单的函数
def greet(name):
    """向某人问好的函数"""
    return f"你好，{name}！"

# 调用函数
message = greet("小明")
print(message)  # 输出：你好，小明！

def function_name(参数 1, 参数 2):
    """函数的说明文档"""
    # 函数体
    result = 参数 1 + 参数 2
    return result  # 返回值

def calculator(num1, num2, operation):
    """简单计算器函数
    参数：
        num1: 第一个数字
        num2: 第二个数字
        operation: 运算符 (+, -, *, /)
    返回：
        计算结果
    """
    if operation == "+":
        return num1 + num2
    elif operation == "-":
        return num1 - num2
    elif operation == "*":
        return num1 * num2
    elif operation == "/":
        if num2 != 0:
            return num1 / num2
        else:
            return "错误：除数不能为 0"
    else:
        return "错误：不支持的运算符"

# 使用计算器
print(calculator(10, 5, "+"))  # 15
print(calculator(10, 5, "/"))  # 2.0
print(calculator(10, 0, "/"))  # 错误：除数不能为 0

def introduce(name, age, city="北京"):
    """自我介绍函数，城市有默认值"""
    return f"我是{name}，今年{age}岁，来自{city}"

print(introduce("小明", 20))  # 使用默认城市
print(introduce("小红", 22, "上海"))  # 指定城市

def order_coffee(size, coffee_type, sugar=False, milk=False):
    """点咖啡函数"""
    order = f"一杯{size}的{coffee_type}"
    if sugar:
        order += "，加糖"
    if milk:
        order += "，加奶"
    return order

# 使用关键字参数，顺序可以任意
print(order_coffee(coffee_type="拿铁", size="大杯", milk=True))

def calculate_average(*numbers):
    """计算任意个数字的平均值"""
    if not numbers:
        return 0
    total = sum(numbers)
    count = len(numbers)
    return total / count

print(calculate_average(85, 92, 78))  # 3 个数字
print(calculate_average(90, 88, 95, 87, 91))  # 5 个数字

def create_profile(name, **info):
    """创建个人档案"""
    profile = f"姓名：{name}\n"
    for key, value in info.items():
        profile += f"{key}：{value}\n"
    return profile

# 传入任意数量的关键字参数
print(create_profile("小明", 年龄=20, 专业="计算机科学", 爱好="编程", 城市="北京"))

# 普通函数
def square(x):
    return x ** 2

# Lambda 函数（一行搞定）
square_lambda = lambda x: x ** 2
print(square(5))  # 25
print(square_lambda(5))  # 25

# Lambda 在实际中的应用
students = [
    {"name": "小明", "score": 85},
    {"name": "小红", "score": 92},
    {"name": "小刚", "score": 78}
]

# 按成绩排序
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)
for student in sorted_students:
    print(f"{student['name']}: {student['score']}")

def timer(func):
    """计时装饰器"""
    import time
    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():
    """一个慢函数"""
    import time
    time.sleep(1)
    return "完成！"

result = slow_function()  # 会显示执行时间

# 学生管理系统
students_db = []

def add_student(name, age, grade):
    """添加学生"""
    student = {
        "id": len(students_db) + 1,
        "name": name,
        "age": age,
        "grade": grade,
        "courses": []
    }
    students_db.append(student)
    return f"学生 {name} 添加成功，ID: {student['id']}"

def find_student(student_id):
    """查找学生"""
    for student in students_db:
        if student["id"] == student_id:
            return student
    return None

def add_course(student_id, course, score):
    """添加课程成绩"""
    student = find_student(student_id)
    if student:
        student["courses"].append({"course": course, "score": score})
        return f"为 {student['name']} 添加课程 {course} 成功"
    return "学生不存在"

def calculate_gpa(student_id):
    """计算 GPA"""
    student = find_student(student_id)
    if student and student["courses"]:
        total_score = sum(course["score"] for course in student["courses"])
        return total_score / len(student["courses"])
    return 0

def display_student(student_id):
    """显示学生信息"""
    student = find_student(student_id)
    if student:
        print(f"\n=== 学生信息 ===")
        print(f"ID: {student['id']}")
        print(f"姓名：{student['name']}")
        print(f"年龄：{student['age']}")
        print(f"年级：{student['grade']}")
        print(f"GPA: {calculate_gpa(student_id):.2f}")
        if student["courses"]:
            print("课程成绩:")
            for course in student["courses"]:
                print(f" {course['course']}: {course['score']}")
    else:
        print("学生不存在")

# 使用示例
print(add_student("小明", 20, "大二"))
print(add_student("小红", 19, "大一"))
print(add_course(1, "数学", 85))
print(add_course(1, "英语", 92))
print(add_course(2, "物理", 88))
display_student(1)
display_student(2)

import random
import string

def generate_password(length=8, include_symbols=True):
    """生成随机密码
    参数：
        length: 密码长度
        include_symbols: 是否包含特殊字符
    """
    # 字符集
    letters = string.ascii_letters  # a-z, A-Z
    digits = string.digits  # 0-9
    symbols = "!@#$%^&*"
    
    # 构建字符池
    char_pool = letters + digits
    if include_symbols:
        char_pool += symbols
    
    # 生成密码
    password = ''.join(random.choice(char_pool) for _ in range(length))
    return password

# 测试密码生成器
for i in range(3):
    pwd = generate_password(12, True)
    print(f"密码 {i+1}: {pwd}")

def analyze_text(text):
    """分析文本的各种统计信息"""
    # 基本统计
    char_count = len(text)
    word_count = len(text.split())
    sentence_count = text.count('.') + text.count('!') + text.count('?')
    
    # 字符频率
    char_freq = {}
    for char in text.lower():
        if char.isalpha():
            char_freq[char] = char_freq.get(char, 0) + 1
    
    # 最常见的字符
    most_common_char = max(char_freq, key=char_freq.get) if char_freq else None
    
    # 返回分析结果
    return {
        "字符数": char_count,
        "单词数": word_count,
        "句子数": sentence_count,
        "最常见字符": most_common_char,
        "字符频率": char_freq
    }

# 测试文本分析
sample_text = "Python is a great programming language. It's easy to learn and powerful!"
result = analyze_text(sample_text)
print("文本分析结果：")
for key, value in result.items():
    if key != "字符频率":
        print(f"{key}: {value}")

print("\n字符频率前 5 名：")
sorted_chars = sorted(result["字符频率"].items(), key=lambda x: x[1], reverse=True)
for char, freq in sorted_chars[:5]:
    print(f"'{char}': {freq}次")

# 定义一个类 - 就像设计图纸
class Dog:
    """狗狗类"""
    def __init__(self, name, breed, age):
        """初始化方法 - 创建狗狗时调用"""
        self.name = name  # 名字
        self.breed = breed  # 品种
        self.age = age  # 年龄
        self.energy = 100  # 精力值

    def bark(self):
        """狗狗叫"""
        return f"{self.name}：汪汪汪！"

    def play(self):
        """玩耍"""
        if self.energy > 20:
            self.energy -= 20
            return f"{self.name}开心地玩耍！精力剩余：{self.energy}"
        else:
            return f"{self.name}太累了，需要休息"

    def sleep(self):
        """睡觉恢复精力"""
        self.energy = min(100, self.energy + 50)
        return f"{self.name}睡了一觉，精力恢复到：{self.energy}"

# 创建对象 - 根据设计图制造积木
my_dog = Dog("小白", "金毛", 3)
friend_dog = Dog("小黑", "拉布拉多", 2)

# 使用对象
print(my_dog.bark())
print(my_dog.play())
print(my_dog.play())
print(my_dog.sleep())

class Student:
    """学生类示例"""
    # 类变量 - 所有学生共享
    school_name = "Python 学院"
    student_count = 0

    def __init__(self, name, student_id, major):
        """构造方法"""
        self.name = name  # 实例变量
        self.student_id = student_id
        self.major = major
        self.courses = []
        self.gpa = 0.0
        
        # 每创建一个学生，计数加 1
        Student.student_count += 1

    def add_course(self, course_name, score):
        """添加课程"""
        self.courses.append({"course": course_name, "score": score})
        self._calculate_gpa()  # 私有方法

    def _calculate_gpa(self):
        """计算 GPA（私有方法）"""
        if self.courses:
            total_score = sum(course["score"] for course in self.courses)
            self.gpa = total_score / len(self.courses)

    def get_info(self):
        """获取学生信息"""
        info = f"姓名：{self.name}\n"
        info += f"学号：{self.student_id}\n"
        info += f"专业：{self.major}\n"
        info += f"GPA：{self.gpa:.2f}\n"
        info += f"学校：{Student.school_name}"
        return info

    @classmethod
    def get_student_count(cls):
        """类方法 - 获取学生总数"""
        return cls.student_count

    @staticmethod
    def is_passing_grade(score):
        """静态方法 - 判断是否及格"""
        return score >= 60

# 使用示例
student1 = Student("小明", "2023001", "计算机科学")
student2 = Student("小红", "2023002", "数据科学")
student1.add_course("Python 编程", 95)
student1.add_course("数据结构", 88)
print(student1.get_info())
print(f"\n学生总数：{Student.get_student_count()}")
print(f"95 分是否及格：{Student.is_passing_grade(95)}")

# 父类（基类）
class Animal:
    """动物基类"""
    def __init__(self, name, species):
        self.name = name
        self.species = species
        self.energy = 100

    def eat(self):
        self.energy = min(100, self.energy + 20)
        return f"{self.name}吃饱了，精力：{self.energy}"

    def sleep(self):
        self.energy = 100
        return f"{self.name}睡了一觉，精力恢复满了"

    def make_sound(self):
        return f"{self.name}发出了声音"

# 子类继承父类
class Cat(Animal):
    """猫类 - 继承自动物类"""
    def __init__(self, name, breed):
        super().__init__(name, "猫")  # 调用父类构造方法
        self.breed = breed

    def make_sound(self):
        # 重写父类方法
        return f"{self.name}：喵喵喵~"

    def climb_tree(self):
        # 猫特有的方法
        if self.energy > 30:
            self.energy -= 30
            return f"{self.name}爬上了树！"
        else:
            return f"{self.name}太累了，爬不动树"

class Dog(Animal):
    """狗类 - 继承自动物类"""
    def __init__(self, name, breed):
        super().__init__(name, "狗")
        self.breed = breed

    def make_sound(self):
        # 重写父类方法
        return f"{self.name}：汪汪汪！"

    def fetch_ball(self):
        # 狗特有的方法
        if self.energy > 25:
            self.energy -= 25
            return f"{self.name}捡回了球！"
        else:
            return f"{self.name}太累了，不想捡球"

# 使用继承
my_cat = Cat("小咪", "波斯猫")
my_dog = Dog("小汪", "金毛")
print(my_cat.make_sound())
print(my_cat.climb_tree())
print(my_cat.eat())
print(my_dog.make_sound())
print(my_dog.fetch_ball())

# 多态示例
def animal_concert(animals):
    """动物音乐会 - 展示多态"""
    print("🎵 动物音乐会开始了！")
    for animal in animals:
        print(f" {animal.make_sound()}")

# 创建不同的动物
animals = [
    Cat("小咪", "波斯猫"),
    Dog("小汪", "金毛"),
    Cat("小花", "英短"),
    Dog("小黑", "拉布拉多")
]

# 同样的方法调用，不同的结果
animal_concert(animals)

class BankAccount:
    """银行账户类 - 演示封装"""
    def __init__(self, account_number, initial_balance=0):
        self.account_number = account_number
        self.__balance = initial_balance  # 私有属性（双下划线）
        self.__transaction_history = []  # 私有属性

    def deposit(self, amount):
        """存款"""
        if amount > 0:
            self.__balance += amount
            self.__add_transaction("存款", amount)
            return f"存款成功！当前余额：￥{self.__balance}"
        else:
            return "存款金额必须大于 0"

    def withdraw(self, amount):
        """取款"""
        if amount <= 0:
            return "取款金额必须大于 0"
        elif amount > self.__balance:
            return "余额不足"
        else:
            self.__balance -= amount
            self.__add_transaction("取款", amount)
            return f"取款成功！当前余额：￥{self.__balance}"

    def get_balance(self):
        """获取余额（只读）"""
        return self.__balance

    def __add_transaction(self, transaction_type, amount):
        """私有方法 - 添加交易记录"""
        import datetime
        self.__transaction_history.append({
            "type": transaction_type,
            "amount": amount,
            "time": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        })

    def get_transaction_history(self):
        """获取交易历史"""
        return self.__transaction_history.copy()  # 返回副本，保护原数据

# 使用银行账户
account = BankAccount("123456789", 1000)
print(account.deposit(500))
print(account.withdraw(200))
print(f"当前余额：￥{account.get_balance()}")

# 尝试直接访问私有属性（会失败）
# print(account.__balance)  # 这会报错

# 查看交易历史
for transaction in account.get_transaction_history():
    print(f"{transaction['time']}: {transaction['type']} ￥{transaction['amount']}")

class Book:
    """图书类"""
    def __init__(self, title, author, isbn, copies=1):
        self.title = title
        self.author = author
        self.isbn = isbn
        self.total_copies = copies
        self.available_copies = copies
        self.borrowed_by = []

    def borrow(self, borrower_name):
        """借书"""
        if self.available_copies > 0:
            self.available_copies -= 1
            self.borrowed_by.append(borrower_name)
            return f"《{self.title}》借阅成功！"
        else:
            return f"《{self.title}》暂无库存"

    def return_book(self, borrower_name):
        """还书"""
        if borrower_name in self.borrowed_by:
            self.available_copies += 1
            self.borrowed_by.remove(borrower_name)
            return f"《{self.title}》归还成功！"
        else:
            return "还书信息有误"

    def get_info(self):
        """获取图书信息"""
        return f"《{self.title}》- {self.author} (可借：{self.available_copies}/{self.total_copies})"

class Library:
    """图书馆类"""
    def __init__(self, name):
        self.name = name
        self.books = {}  # ISBN -> Book 对象

    def add_book(self, book):
        """添加图书"""
        if book.isbn in self.books:
            # 如果书已存在，增加库存
            self.books[book.isbn].total_copies += book.total_copies
            self.books[book.isbn].available_copies += book.available_copies
        else:
            self.books[book.isbn] = book
        return f"图书《{book.title}》添加成功"

    def search_book(self, keyword):
        """搜索图书"""
        results = []
        for book in self.books.values():
            if keyword.lower() in book.title.lower() or keyword.lower() in book.author.lower():
                results.append(book)
        return results

    def list_all_books(self):
        """列出所有图书"""
        if not self.books:
            return "图书馆暂无图书"
        book_list = f"\n=== {self.name} 图书列表 ===\n"
        for book in self.books.values():
            book_list += book.get_info() + "\n"
        return book_list

# 使用图书管理系统
library = Library("Python 学习图书馆")

# 添加图书
books = [
    Book("Python 编程入门", "张三", "978-1-1111-1111-1", 3),
    Book("数据结构与算法", "李四", "978-2-2222-2222-2", 2),
    Book("机器学习实战", "王五", "978-3-3333-3333-3", 1)
]
for book in books:
    print(library.add_book(book))

print(library.list_all_books())

# 借书和还书
python_book = library.books["978-1-1111-1111-1"]
print(python_book.borrow("小明"))
print(python_book.borrow("小红"))
print(python_book.return_book("小明"))

# 导入整个模块
import math
print(f"圆周率：{math.pi}")
print(f"平方根：{math.sqrt(16)}")

# 导入特定函数
from random import randint, choice
print(f"随机数：{randint(1, 10)}")
print(f"随机选择：{choice(['苹果', '香蕉', '橙子'])}")

# 给模块起别名
import datetime as dt
now = dt.datetime.now()
print(f"现在时间：{now.strftime('%Y-%m-%d %H:%M:%S')}")

"""
我的工具模块
包含一些常用的工具函数
"""

def greet(name, language="中文"):
    """多语言问候函数"""
    greetings = {
        "中文": f"你好，{name}！",
        "英文": f"Hello, {name}!",
        "日文": f"こんにちは、{name}！",
        "韩文": f"안녕하세요, {name}!"
    }
    return greetings.get(language, f"Hello, {name}!")

def calculate_bmi(weight, height):
    """计算 BMI 指数"""
    bmi = weight / (height ** 2)
    if bmi < 18.5:
        category = "偏瘦"
    elif bmi < 24:
        category = "正常"
    elif bmi < 28:
        category = "偏胖"
    else:
        category = "肥胖"
    return {"bmi": round(bmi, 2), "category": category}

class SimpleCalculator:
    """简单计算器类"""
    @staticmethod
    def add(a, b):
        return a + b

    @staticmethod
    def multiply(a, b):
        return a * b

# 模块级别的变量
VERSION = "1.0.0"
AUTHOR = "Python 学习者"

# 当模块被直接运行时执行的代码
if __name__ == "__main__":
    print("这是我的工具模块")
    print(f"版本：{VERSION}")
    print(f"作者：{AUTHOR}")

# 导入自定义模块
import my_utils

# 使用模块中的函数
print(my_utils.greet("小明"))
print(my_utils.greet("Tom", "英文"))

# 使用模块中的类
calc = my_utils.SimpleCalculator()
print(f"3 + 5 = {calc.add(3, 5)}")

# 访问模块变量
print(f"模块版本：{my_utils.VERSION}")

# 计算 BMI
bmi_result = my_utils.calculate_bmi(70, 1.75)
print(f"BMI: {bmi_result['bmi']} ({bmi_result['category']})")

import os

# 获取当前工作目录
print(f"当前目录：{os.getcwd()}")

# 列出目录内容
print(f"目录内容：{os.listdir('.')}")

# 检查文件是否存在
if os.path.exists("my_file.txt"):
    print("文件存在")
else:
    print("文件不存在")

# 创建目录
if not os.path.exists("test_folder"):
    os.makedirs("test_folder")
    print("目录创建成功")

from datetime import datetime, timedelta, date

# 获取当前时间
now = datetime.now()
print(f"现在：{now}")

# 格式化时间
formatted = now.strftime("%Y年%m月%d日 %H:%M:%S")
print(f"格式化时间：{formatted}")

# 时间计算
tomorrow = now + timedelta(days=1)
print(f"明天：{tomorrow.strftime('%Y-%m-%d')}")

# 计算年龄
birthday = date(2000, 5, 15)
today = date.today()
age = today.year - birthday.year
print(f"年龄：{age}岁")

import json

# Python 对象转 JSON
student_data = {
    "name": "小明",
    "age": 20,
    "courses": ["Python", "数学", "英语"],
    "is_active": True
}

# 转换为 JSON 字符串
json_string = json.dumps(student_data, ensure_ascii=False, indent=2)
print("JSON 字符串：")
print(json_string)

# JSON 字符串转 Python 对象
parsed_data = json.loads(json_string)
print(f"\n解析后的姓名：{parsed_data['name']}")

# 保存到文件
with open("student.json", "w", encoding="utf-8") as f:
    json.dump(student_data, f, ensure_ascii=False, indent=2)

# 从文件读取
with open("student.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)
print(f"从文件读取的数据：{loaded_data}")

# 写入文件
def write_diary(content):
    """写日记"""
    from datetime import datetime
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    diary_entry = f"[{timestamp}] {content}\n"
    with open("diary.txt", "a", encoding="utf-8") as f:
        f.write(diary_entry)
    print("日记写入成功！")

# 读取文件
def read_diary():
    """读取日记"""
    try:
        with open("diary.txt", "r", encoding="utf-8") as f:
            content = f.read()
        if content:
            print("=== 我的日记 ===")
            print(content)
        else:
            print("日记本是空的")
    except FileNotFoundError:
        print("还没有日记文件，开始写第一篇日记吧！")

# 使用示例
write_diary("今天学习了 Python 文件操作，很有趣！")
write_diary("明天要继续学习异常处理")
read_diary()

import csv

def save_students_csv(students):
    """保存学生数据到 CSV 文件"""
    with open("students.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        # 写入表头
        writer.writerow(["姓名", "年龄", "专业", "成绩"])
        # 写入数据
        for student in students:
            writer.writerow([
                student["name"],
                student["age"],
                student["major"],
                student["score"]
            ])
    print("学生数据保存成功！")

def read_students_csv():
    """从 CSV 文件读取学生数据"""
    students = []
    try:
        with open("students.csv", "r", encoding="utf-8") as f:
            reader = csv.DictReader(f)
            for row in reader:
                students.append({
                    "name": row["姓名"],
                    "age": int(row["年龄"]),
                    "major": row["专业"],
                    "score": float(row["成绩"])
                })
        return students
    except FileNotFoundError:
        print("CSV 文件不存在")
        return []

# 使用示例
sample_students = [
    {"name": "小明", "age": 20, "major": "计算机", "score": 85.5},
    {"name": "小红", "age": 19, "major": "数学", "score": 92.0},
    {"name": "小刚", "age": 21, "major": "物理", "score": 78.5}
]
save_students_csv(sample_students)
loaded_students = read_students_csv()
print("读取的学生数据：")
for student in loaded_students:
    print(f"{student['name']} - {student['major']} - {student['score']}")

def safe_divide(a, b):
    """安全的除法运算"""
    try:
        result = a / b
        return f"{a} ÷ {b} = {result}"
    except ZeroDivisionError:
        return "错误：不能除以零！"
    except TypeError:
        return "错误：请输入数字！"
    except Exception as e:
        return f"未知错误：{e}"
    else:
        print("计算成功完成")  # 没有异常时执行
    finally:
        print("除法运算结束")  # 总是执行

# 测试异常处理
print(safe_divide(10, 2))  # 正常情况
print(safe_divide(10, 0))  # 除零异常
print(safe_divide(10, "a"))  # 类型异常

def safe_file_reader(filename):
    """安全的文件读取器"""
    try:
        with open(filename, "r", encoding="utf-8") as f:
            content = f.read()
        return content
    except FileNotFoundError:
        print(f"错误：文件 '{filename}' 不存在")
        return None
    except PermissionError:
        print(f"错误：没有权限读取文件 '{filename}'")
        return None
    except UnicodeDecodeError:
        print(f"错误：文件 '{filename}' 编码格式不正确")
        return None
    except Exception as e:
        print(f"读取文件时发生未知错误：{e}")
        return None

# 自定义异常
class InvalidAgeError(Exception):
    """年龄无效异常"""
    def __init__(self, age, message="年龄必须在 0-150 之间"):
        self.age = age
        self.message = message
        super().__init__(self.message)

def validate_age(age):
    """验证年龄"""
    if not isinstance(age, int):
        raise TypeError("年龄必须是整数")
    if age < 0 or age > 150:
        raise InvalidAgeError(age)
    return True

# 使用自定义异常
try:
    validate_age(200)
except InvalidAgeError as e:
    print(f"年龄验证失败：{e.message}，输入的年龄是：{e.age}")
except TypeError as e:
    print(f"类型错误：{e}")

import json
import datetime

class TaskManager:
    """个人任务管理器"""
    def __init__(self, filename="tasks.json"):
        self.filename = filename
        self.tasks = self.load_tasks()

    def load_tasks(self):
        """加载任务"""
        try:
            with open(self.filename, "r", encoding="utf-8") as f:
                return json.load(f)
        except FileNotFoundError:
            return []

    def save_tasks(self):
        """保存任务"""
        with open(self.filename, "w", encoding="utf-8") as f:
            json.dump(self.tasks, f, ensure_ascii=False, indent=2)

    def add_task(self, title, description="", priority="中"):
        """添加任务"""
        task = {
            "id": len(self.tasks) + 1,
            "title": title,
            "description": description,
            "priority": priority,
            "status": "待完成",
            "created_at": datetime.datetime.now().isoformat(),
            "completed_at": None
        }
        self.tasks.append(task)
        self.save_tasks()
        return f"任务 '{title}' 添加成功！"

    def complete_task(self, task_id):
        """完成任务"""
        for task in self.tasks:
            if task["id"] == task_id:
                task["status"] = "已完成"
                task["completed_at"] = datetime.datetime.now().isoformat()
                self.save_tasks()
                return f"任务 '{task['title']}' 已完成！"
        return "任务不存在！"

    def list_tasks(self, status=None):
        """列出任务"""
        filtered_tasks = self.tasks
        if status:
            filtered_tasks = [t for t in self.tasks if t["status"] == status]
        if not filtered_tasks:
            return "没有任务"
        result = "\n=== 任务列表 ===\n"
        for task in filtered_tasks:
            result += f"[{task['id']}] {task['title']} - {task['status']} ({task['priority']})\n"
            if task['description']:
                result += f" 描述：{task['description']}\n"
        return result

    def delete_task(self, task_id):
        """删除任务"""
        for i, task in enumerate(self.tasks):
            if task["id"] == task_id:
                deleted_task = self.tasks.pop(i)
                self.save_tasks()
                return f"任务 '{deleted_task['title']}' 已删除！"
        return "任务不存在！"

# 使用任务管理器
def main():
    """主程序"""
    tm = TaskManager()
    while True:
        print("\n=== 个人任务管理器 ===")
        print("1. 添加任务")
        print("2. 查看所有任务")
        print("3. 查看待完成任务")
        print("4. 完成任务")
        print("5. 删除任务")
        print("6. 退出")
        choice = input("请选择操作（1-6）：")
        
        if choice == "1":
            title = input("任务标题：")
            description = input("任务描述（可选）：")
            priority = input("优先级（高/中/低，默认中）：") or "中"
            print(tm.add_task(title, description, priority))
        elif choice == "2":
            print(tm.list_tasks())
        elif choice == "3":
            print(tm.list_tasks("待完成"))
        elif choice == "4":
            print(tm.list_tasks("待完成"))
            try:
                task_id = int(input("请输入要完成的任务 ID："))
                print(tm.complete_task(task_id))
            except ValueError:
                print("请输入有效的任务 ID！")
        elif choice == "5":
            print(tm.list_tasks())
            try:
                task_id = int(input("请输入要删除的任务 ID："))
                print(tm.delete_task(task_id))
            except ValueError:
                print("请输入有效的任务 ID！")
        elif choice == "6":
            print("再见！")
            break
        else:
            print("无效选择，请重新输入！")

# 运行程序
if __name__ == "__main__":
    main()

Python 零基础学习指南

Python 零基础学习指南

第 1 章：Python 简介与环境搭建

🤔 什么是 Python？

🛠️ 安装 Python

Windows 用户：

验证安装：

🎮 第一个 Python 程序

🎯 Python 能做什么？

✅ 第 1 章练习

第 2 章：基础语法入门

🏷️ 变量 - 给数据起名字

📝 变量命名规则

💬 注释 - 给代码写说明

🧮 基本运算

🔄 比较和逻辑运算

📥📤 输入和输出

🎨 字符串格式化

⚠️ 常见错误

✅ 第 2 章练习

第 3 章：数据类型详解

🔢 数字类型

整数 (int)

浮点数 (float)

数字运算技巧

📝 字符串 (str)

字符串操作

字符串方法

📋 列表 (list)

列表操作

列表推导式 - 快速创建列表

📦 元组 (tuple)

📖 字典 (dict)

🎯 集合 (set)

🎨 数据类型转换

✅ 第 3 章练习

第 4 章：控制流程

🤔 条件判断 (if 语句)

实际应用：成绩等级判定

复杂条件判断

🔄 循环语句

for 循环 - 已知次数的循环

while 循环 - 条件循环

循环控制

🎯 实际应用案例

案例 1：密码强度检查

✅ 第 4 章练习

第 5 章：函数的世界

🔧 什么是函数？

🎯 函数的基本结构

📝 实际例子：计算器函数

🎨 参数的不同类型

1. 默认参数

2. 关键字参数

3. 可变参数

4. 关键字可变参数

🌟 函数的高级特性

Lambda 函数（匿名函数）

装饰器 - 给函数加特效

🎯 实际应用：学生管理系统

✅ 第 5 章练习

第 6 章：面向对象编程

🏗️ 什么是面向对象？

🎯 类的基本概念

🧬 继承 - 代码的遗传

🎭 多态 - 同样的动作，不同的表现

🔒 封装 - 保护数据

✅ 第 6 章练习

第 7 章：模块和包

📦 什么是模块？

🛠️ 创建自己的模块

📚 常用内置模块

1. os 模块 - 操作系统接口

2. datetime 模块 - 日期时间处理

3. json 模块 - JSON 数据处理

第 8 章：文件操作

📁 文件读写基础

📊 CSV 文件处理

第 9 章：异常处理

⚠️ 什么是异常？