一、开篇：3分钟跑通第一个Python程序

核心知识点

Python是解释型编程语言，语法极简，无需复杂的编译步骤，写一行就能运行一行，是新手入门编程的最佳选择。

环境准备

去Python官网下载对应系统的Python版本，安装时务必勾选Add Python to PATH

你的第一行Python代码

# 向世界打个招呼吧
print("Hello Python World!")

运行代码，控制台会直接输出：Hello Python World!

配图示意：

📷 图注：VS Code中运行Hello World的效果，左侧是代码，右侧是运行结果

二、变量与数据类型：Python的“数据容器”

核心知识点

变量就是给数据起个名字，方便后续调用；Python有5种基础数据类型，是所有代码的基石。

数据类型	说明	示例
字符串(str)	文本内容，用单/双引号包裹	name = "Python"
整型(int)	整数，无小数点	age = 20
浮点型(float)	带小数点的数字	height = 1.75
布尔型(bool)	真假值，只有True/False两个结果	is_study = True
空值(None)	表示“什么都没有”	result = None

必学操作：字符串常用方法

# 1. 大小写转换
name = "python"
print(name.title())  # 首字母大写：Python
print(name.upper())  # 全大写：PYTHON
print(name.lower())  # 全小写：python

# 2. 拼接字符串
first_name = "Li"
last_name = "Hua"
full_name = first_name + " " + last_name
print(full_name)  # 输出：Li Hua

# 3. f-string格式化（Python3.6+推荐）
age = 18
print(f"我今年{age}岁了")  # 输出：我今年18岁了

配图示意：

📷图注：变量在内存中的存储逻辑，变量名指向对应的数据值，方便我们重复调用

三、列表：Python最常用的“数据序列”

核心知识点

列表是有序、可修改的元素集合，用[]包裹，元素之间用逗号分隔，能存数字、字符串、甚至另一个列表，是Python里最常用的数据结构。

1. 列表的基础操作

# 创建列表
fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 1. 访问元素：索引从0开始！
print(fruits[0])  # 输出：苹果
print(fruits[-1]) # 负数索引，取最后一个元素：葡萄

# 2. 修改元素
fruits[1] = "西瓜"
print(fruits)  # 输出：['苹果', '西瓜', '橙子', '葡萄']

# 3. 添加元素
fruits.append("芒果")  # 末尾添加
fruits.insert(1, "草莓") # 指定位置插入
print(fruits)  # 输出：['苹果', '草莓', '西瓜', '橙子', '葡萄', '芒果']

# 4. 删除元素
del fruits[2]  # 删除指定索引的元素
fruits.remove("橙子") # 删除指定值的元素
last_fruit = fruits.pop() # 弹出末尾元素，可接收
print(fruits)  # 输出：['苹果', '草莓', '葡萄']

2. 列表排序与遍历

# 排序
nums = [5, 2, 9, 1, 7]
nums.sort()  # 永久升序排序
nums.sort(reverse=True) # 永久降序排序
sorted(nums) # 临时排序，不改变原列表

# 遍历列表（循环）
for fruit in fruits:
    print(f"我喜欢吃{fruit}")

配图示意：

📷 图注：列表的正索引和负索引对应关系，新手最容易踩坑的“索引从0开始”一目了然

四、字典：键值对存储的“数据映射表”

核心知识点

字典用{}包裹，是无序的键值对(key-value) 集合，通过键快速查找值，就像查字典，通过“词语”找“释义”，适合存储一个事物的多个属性。

基础操作

# 创建字典：键是唯一的，值可以是任意数据类型
student = {
    "name": "张三",
    "age": 20,
    "gender": "男",
    "score": 95
}

# 1. 取值
print(student["name"])  # 输出：张三
print(student.get("height", "未知")) # 安全取值，键不存在返回默认值

# 2. 添加/修改键值对
student["height"] = 180  # 新增
student["score"] = 98    # 修改

# 3. 删除键值对
del student["gender"]

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

# 遍历键
for key in student.keys():
    print(key)

# 遍历值
for value in student.values():
    print(value)

配图示意：

📷 图注：字典的key和value一一对应关系，通过key能快速定位到对应的值

五、流程控制：让代码有“判断和循环”的能力

代码不只是从上到下执行，通过条件判断和循环，能让代码实现复杂的逻辑，这是编程的核心。

1. if条件判断：让代码做选择

核心语法：if 满足条件执行 → elif 其他条件 → else 都不满足执行

age = 18

if age < 18:
    print("未成年")
elif age == 18:
    print("刚成年")
else:
    print("已成年")

# 多条件判断
score = 85
if score >= 90 and score <= 100:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

配图示意：

📷 图注：if-elif-else的执行流程，代码会按顺序判断条件，满足一个就停止后续判断

2. for循环：遍历序列，重复执行

适合知道循环次数的场景，比如遍历列表、字典、固定次数循环

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

# 用range生成数字序列，循环固定次数
for i in range(1, 6): # 生成1-5的数字，左闭右开
    print(f"第{i}次循环")

# 列表推导式：快速生成列表（Python特色）
nums = [i*2 for i in range(1, 6)]
print(nums) # 输出：[2, 4, 6, 8, 10]

3. while循环：满足条件就一直循环

适合不知道循环次数，只知道循环结束条件的场景

# 计数循环
count = 0
while count < 5:
    print(f"count={count}")
    count += 1 # 计数+1，避免死循环

# 用户交互循环
active = True
while active:
    message = input("输入quit退出程序：")
    if message == "quit":
        active = False
    else:
        print(f"你输入了：{message}")

重点提醒：写while循环一定要写循环结束的条件，否则会出现死循环！

六、函数：封装代码，实现复用

核心知识点

函数是把重复使用的代码块封装起来，起一个名字，后续需要用的时候直接调用，不用重复写代码，让程序更简洁、易维护。

1. 函数基础定义与调用

# def 关键字定义函数，括号里是参数
def greet(name):
    """打招呼的函数（文档字符串，说明函数作用）"""
    print(f"你好，{name}！")

# 调用函数
greet("张三")
greet("李四")

# 带返回值的函数
def add_num(a, b):
    """计算两个数的和，返回结果"""
    result = a + b
    return result

# 接收返回值
sum_result = add_num(5, 3)
print(f"5+3={sum_result}")

2. 函数进阶用法

# 1. 默认参数
def describe_pet(pet_name, animal_type="狗"):
    """描述宠物信息，animal_type有默认值"""
    print(f"我的宠物是{animal_type}，名字叫{pet_name}")

describe_pet("旺财") # 用默认值
describe_pet("咪咪", "猫") # 覆盖默认值

# 2. 传递任意数量的参数
def make_pizza(*toppings):
    """接收任意数量的披萨配料"""
    print("披萨配料：")
    for topping in toppings:
        print(f"- {topping}")

make_pizza("芝士", "培根", "蘑菇")

# 3. 任意数量的关键字参数
def build_user(name, age, **user_info):
    """构建用户信息字典，接收额外的任意键值对"""
    user = {"name": name, "age": age}
    user.update(user_info)
    return user

user = build_user("张三", 20, gender="男", city="北京")
print(user)

配图示意：

📷 图注：函数的执行流程，调用函数时传入参数，函数内部执行代码，可返回结果给调用处

七、类与面向对象：Python的编程思想

核心知识点

面向对象编程(OOP)是把事物的属性和行为封装成类，类是模板，对象是根据模板创建的实例，适合写大型、复杂的程序，让代码结构更清晰、易扩展。

基础用法

# 定义类，类名用大驼峰命名法
class Dog:
    """小狗类的模板"""

    def __init__(self, name, age):
        """初始化方法，创建实例时自动调用"""
        # 属性：小狗的特征
        self.name = name
        self.age = age

    # 方法：小狗的行为
    def sit(self):
        """小狗坐下"""
        print(f"{self.name} 现在坐下了")

    def roll_over(self):
        """小狗打滚"""
        print(f"{self.name} 打了个滚")


# 根据类创建实例（对象）
my_dog = Dog("旺财", 3)
your_dog = Dog("咪咪", 2)

# 访问属性
print(f"我的小狗叫{my_dog.name}，今年{my_dog.age}岁")

# 调用方法
my_dog.sit()
your_dog.roll_over()

类的继承

继承是让一个类继承另一个类的所有属性和方法，还能重写/新增自己的内容，实现代码复用。

# 父类写在前面
class Car:
    """汽车类"""
    def __init__(self, brand, model, year):
        self.brand = brand
        self.model = model
        self.year = year
        self.mileage = 0

    def get_descriptive_name(self):
        """获取汽车描述信息"""
        return f"{self.year}年 {self.brand} {self.model}"

    def read_mileage(self):
        print(f"这辆车已经行驶了{self.mileage}公里")


# 子类，继承Car类
class ElectricCar(Car):
    """电动汽车类，继承汽车类"""
    def __init__(self, brand, model, year, battery_size=70):
        # 先调用父类的初始化方法
        super().__init__(brand, model, year)
        # 子类自己的属性
        self.battery_size = battery_size

    # 子类自己的方法
    def describe_battery(self):
        print(f"这辆车的电池容量是{self.battery_size}度")

    # 重写父类的方法
    def read_mileage(self):
        print(f"电动车已行驶{self.mileage}公里，续航还剩500公里")


# 创建电动车实例
my_tesla = ElectricCar("特斯拉", "Model 3", 2024)
print(my_tesla.get_descriptive_name()) # 调用父类方法
my_tesla.describe_battery() # 调用子类方法
my_tesla.read_mileage() # 调用重写后的方法

八、文件操作与异常处理

1. 文件读写：Python操作本地文件

Python可以轻松读取、写入本地文件，处理txt、csv等文本文件，核心是open()函数和上下文管理器with（自动关闭文件，避免出错）。

# 1. 读取文件
# 读取整个文件
with open("pi_digits.txt", "r", encoding="utf-8") as file_object:
    contents = file_object.read()
    print(contents)

# 逐行读取
with open("pi_digits.txt", "r", encoding="utf-8") as file_object:
    for line in file_object:
        print(line.strip()) # strip()去除换行和空格

# 2. 写入文件
# w模式：覆盖写入，文件不存在会创建，存在会清空原有内容
with open("write_test.txt", "w", encoding="utf-8") as file_object:
    file_object.write("Hello Python!\n")
    file_object.write("我是写入的第二行内容\n")

# a模式：追加写入，在文件末尾添加内容，不覆盖原有内容
with open("write_test.txt", "a", encoding="utf-8") as file_object:
    file_object.write("我是追加的内容\n")

2. 异常处理：让程序不崩溃

Python执行出错会抛出异常，程序会直接停止，用try-except代码块捕获异常，让程序能优雅处理错误，继续运行。

# 常见异常：ZeroDivisionError（除零错误）
try:
    result = 5 / 0
except ZeroDivisionError:
    print("错误：不能除以0")
else:
    print(f"计算结果是{result}")
finally:
    print("这句话无论是否出错，都会执行")

# 常见异常：FileNotFoundError（文件不存在）
filename = "不存在的文件.txt"
try:
    with open(filename, "r", encoding="utf-8") as f:
        contents = f.read()
except FileNotFoundError:
    print(f"抱歉，文件{filename}不存在")
else:
    print(contents)

# 静默失败：捕获异常后什么都不做
try:
    5/0
except ZeroDivisionError:
    pass # 跳过，不做任何处理