1. Python简介与环境搭建

1.1 Python是什么？

Python 是一种高级、解释型、通用的编程语言，由 Guido van Rossum 于 1991 年首次发布。它以简洁明了的语法、强大的标准库和丰富的第三方生态而闻名，广泛应用于 Web 开发、数据分析、人工智能、自动化运维等领域。

1.2 安装Python

访问 Python 官网（https://www.python.org）下载对应操作系统的安装包。推荐安装 Python 3.7 及以上版本。

Windows 安装验证：

python --version
# 或
python3 --version

macOS/Linux 安装验证：

python3 --version

虚拟环境

虚拟环境可以为每个项目创建独立的 Python 运行环境，避免依赖冲突。

# 创建虚拟环境
python -m venv myenv

# 激活（Windows）
myenv\Scripts\activate

# 激活（macOS/Linux）
source myenv/bin/activate

# 退出
deactivate

### 1.3 第一个Python程序

创建一个名为 hello.py 的文件，写入以下内容：

print("Hello, World!")

在终端中运行：

python hello.py

2. 基础语法要素

2.1 注释

注释用于解释代码，不会被解释器执行。

# 这是单行注释

"""
这是多行注释（文档字符串）
可以跨越多行
常用于函数、模块的说明
"""

def example():
    """函数文档字符串"""
    pass

2.2 变量与数据类型

Python 是动态类型语言，无需声明变量类型。

# 基本数据类型
name = "Python"          # 字符串 (str)
age = 30                 # 整数 (int)
price = 99.99            # 浮点数 (float)
is_active = True         # 布尔值 (bool)
empty_value = None       # 空值

# 查看变量类型
print(type(name))        # <class 'str'>
print(type(age))         # <class 'int'>

输入与输出

通过 input() 读取用户输入，用 print() 进行输出。输入的内容始终为字符串，需要转换。

# 基本输出
print("欢迎学习Python")

# 格式化输出
name = "Alice"
age = 25
print(f"姓名：{name}，年龄：{age}")

# 接收用户输入
user_name = input("请输入您的姓名：")
age_input = input("请输入您的年龄：")
age = int(age_input)  # 将字符串转为整数
print(f"{user_name}明年就{age + 1}岁了")

### 2.3 标识符命名规则

• 由字母、数字、下划线组成
• 不能以数字开头
• 区分大小写
• 不能使用 Python 关键字

# 合法命名
user_name = "张三"
user_age = 25
_private_var = "私有"
MAX_SIZE = 100  # 常量（约定全大写）

# 非法命名
# 2name = "错误"      # 数字开头
# class = "关键字"    # 使用关键字

3. 基本数据类型详解

3.1 数字类型

# 整数
a = 10
b = -5
c = 0b1010    # 二进制 10
d = 0o12      # 八进制 10
e = 0xA       # 十六进制 10

# 浮点数
f1 = 3.14
f2 = 2.0e3    # 2000.0
f3 = 1.23e-4  # 0.000123

# 复数
complex_num = 3 + 4j
print(complex_num.real)  # 3.0
print(complex_num.imag)  # 4.0

3.2 字符串

# 创建字符串
str1 = '单引号'
str2 = "双引号"
str3 = '''三引号
可以跨行'''

# 字符串操作
text = "Python Programming"
print(len(text))           # 18
print(text[0])            # 'P'
print(text[7:18])         # 'Programming'
print(text.upper())       # 'PYTHON PROGRAMMING'
print(text.lower())       # 'python programming'
print(text.replace('Python', 'Java'))  # 'Java Programming'

# 格式化字符串
name = "Alice"
age = 25
# f-string (Python 3.6+)
print(f"姓名：{name}，年龄：{age}")
# format方法
print("姓名：{}，年龄：{}".format(name, age))

3.3 布尔类型

# 布尔值
true_value = True
false_value = False

# 布尔运算
print(True and False)   # False
print(True or False)    # True
print(not True)         # False

# 比较运算
print(10 > 5)           # True
print(10 == 10)         # True
print(10 != 5)          # True

4. 数据结构

4.1 列表（List）

有序、可变的集合。

# 创建列表
fruits = ['apple', 'banana', 'orange']
numbers = [1, 2, 3, 4, 5]
mixed = [1, 'hello', True, 3.14]

# 基本操作
print(fruits[0])           # 'apple'
print(fruits[-1])          # 'orange'（倒数第一个）
fruits[1] = 'grape'        # 修改元素
fruits.append('mango')     # 添加元素
fruits.insert(1, 'pear')   # 插入元素
fruits.remove('apple')     # 删除元素
popped = fruits.pop()      # 弹出最后一个元素

# 列表切片
numbers = [0, 1, 2, 3, 4, 5]
print(numbers[1:4])        # [1, 2, 3]
print(numbers[:3])         # [0, 1, 2]
print(numbers[3:])         # [3, 4, 5]
print(numbers[::2])        # [0, 2, 4]（步长为2）

# 列表推导式
squares = [x**2 for x in range(10)]
even_numbers = [x for x in range(20) if x % 2 == 0]

4.2 元组（Tuple）

有序、不可变的集合。

# 创建元组
point = (10, 20)
colors = ('red', 'green', 'blue')
single = (5,)              # 单元素元组需要逗号

# 基本操作
print(point[0])            # 10
print(len(colors))         # 3

# 元组解包
x, y = point
print(f"x={x}, y={y}")     # x=10, y=20

# 元组不可变
# point[0] = 15           # 错误！元组元素不可修改

4.3 字典（Dictionary）

键值对的无序集合。

# 创建字典
student = {
    'name': '张三',
    'age': 20,
    'major': '计算机科学'
}

# 访问元素
print(student['name'])          # '张三'
print(student.get('age'))       # 20
print(student.get('grade', '未知'))  # '未知'（默认值）

# 修改和添加
student['age'] = 21             # 修改
student['grade'] = 'A'          # 添加

# 遍历字典
for key in student:
    print(f"{key}: {student[key]}")

for key, value in student.items():
    print(f"{key}: {value}")

# 字典推导式
squares = {x: x**2 for x in range(5)}

4.4 集合（Set）

无序、不重复元素的集合。

# 创建集合
set1 = {1, 2, 3, 4, 5}
set2 = set([4, 5, 6, 7, 8])

# 集合操作
print(set1 | set2)      # 并集：{1, 2, 3, 4, 5, 6, 7, 8}
print(set1 & set2)      # 交集：{4, 5}
print(set1 - set2)      # 差集：{1, 2, 3}
print(set1 ^ set2)      # 对称差集：{1, 2, 3, 6, 7, 8}

# 集合推导式
even_squares = {x**2 for x in range(10) if x % 2 == 0}

5. 流程控制

5.1 条件语句

# if-elif-else
score = 85

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'F'

print(f"成绩等级：{grade}")

# 三元表达式
result = "及格" if score >= 60 else "不及格"

5.2 循环语句

# for循环
fruits = ['apple', 'banana', 'orange']

# 遍历列表
for fruit in fruits:
    print(fruit)

# 遍历数字范围
for i in range(5):          # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 10, 2):   # 2, 4, 6, 8
    print(i)

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

# 循环控制
for i in range(10):
    if i == 3:
        continue        # 跳过本次循环
    if i == 7:
        break           # 终止循环
    print(i)

遍历字典与枚举

# 遍历字典的键值对
student = {'name': '张三', 'age': 20, 'major': '计算机'}
for key, value in student.items():
    print(f"{key}: {value}")

# 使用 enumerate 同时获取索引和值
fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits, 1):
    print(f"{index}. {fruit}")

for-else 与 while-else

Python 的循环支持 else 子句，当循环正常结束（未被 break 中断）时执行。

# for-else 示例
numbers = [1, 3, 5, 7, 9]
for num in numbers:
    if num % 2 == 0:
        print("找到偶数")
        break
else:
    print("没有找到偶数")  # 循环正常结束，执行 else

# while-else 示例
count = 0
while count < 3:
    print(count)
    count += 1
else:
    print("循环正常结束")

 kwargs.items():
    print(f"{key}: {value}")

print_info(name=“张三”, age=25, city=“北京”)

### 6.3 匿名函数
```python
# lambda表达式
square = lambda x: x ** 2
print(square(5))  # 25

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

print(squared)  # [1, 4, 9, 16, 25]
print(even)     # [2, 4]

### 6.3 匿名函数

# lambda表达式
square = lambda x: x ** 2
print(square(5))  # 25

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

print(squared)  # [1, 4, 9, 16, 25]
print(even)     # [2, 4]

7. 文件操作

7.1 文件读写

# 写入文件
with open('example.txt', 'w', encoding='utf-8') as f:
    f.write("第一行内容\n")
    f.write("第二行内容\n")

# 读取文件
with open('example.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

# 逐行读取
with open('example.txt', 'r', encoding='utf-8') as f:
    for line in f:
        print(line.strip())  # 去除换行符

# 追加内容
with open('example.txt', 'a', encoding='utf-8') as f:
    f.write("追加的内容\n")

7.2 CSV文件操作

import csv

# 写入CSV
data = [
    ['姓名', '年龄', '城市'],
    ['张三', '25', '北京'],
    ['李四', '30', '上海']
]

with open('data.csv', 'w', newline='', encoding='utf-8') as f:
    writer = csv.writer(f)
    writer.writerows(data)

# 读取CSV
with open('data.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)

JSON 文件操作

Python 内置 json 模块，方便处理 JSON 格式数据。

import json

# 将 Python 对象转为 JSON 字符串
data = {'name': '张三', 'age': 25, 'scores': [85, 92, 78]}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print(json_str)

# 将 JSON 字符串解析为 Python 对象
parsed = json.loads(json_str)
print(parsed['name'])  # 张三

# 写入 JSON 文件
with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# 读取 JSON 文件
with open('data.json', 'r', encoding='utf-8') as f:
    loaded = json.load(f)
    print(loaded)

## 8. 异常处理

8.1 基本异常处理

try:
    # 可能出错的代码
    num = int(input("请输入一个数字："))
    result = 10 / num
    print(f"结果是：{result}")
except ValueError:
    print("错误：请输入有效的数字！")
except ZeroDivisionError:
    print("错误：不能除以零！")
except Exception as e:
    print(f"发生未知错误：{e}")
else:
    print("计算成功完成！")
finally:
    print("程序执行结束。")

8.2 自定义异常

class AgeError(Exception):
    """年龄异常"""
    def __init__(self, age, message="年龄必须在0-150之间"):
        self.age = age
        self.message = message
        super().__init__(self.message)

def set_age(age):
    if not 0 <= age <= 150:
        raise AgeError(age)
    return age

try:
    set_age(200)
except AgeError as e:
    print(f"错误：{e.message}，当前年龄：{e.age}")

异常链与 raise

使用 raise 主动抛出异常，raise ... from ... 可以保留异常链信息。

# 主动抛出异常
def validate_age(age):
    if age < 0:
        raise ValueError("年龄不能为负数")
    return age

# 异常链：保留原始异常上下文
def process_data(filename):
    try:
        with open(filename, 'r') as f:
            return f.read()
    except FileNotFoundError as e:
        raise RuntimeError(f"无法处理文件：{filename}") from e

# 使用示例
try:
    process_data("不存在的文件.txt")
except RuntimeError as e:
    print(f"错误：{e}")
    print(f"原始异常：{e.__cause__}")

## 9. 模块与包

9.1 导入模块

# 导入整个模块
import math
print(math.sqrt(16))  # 4.0

# 导入特定函数
from math import sqrt, pi
print(sqrt(9))        # 3.0
print(pi)             # 3.141592653589793

# 导入并重命名
import numpy as np
import pandas as pd

# 导入所有（不推荐）
from math import *

9.2 创建自定义模块

my_module.py

"""自定义模块示例"""

def greet(name):
    return f"Hello, {name}!"

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

PI = 3.14159

if __name__ == "__main__":
    # 模块测试代码
    print(greet("World"))

main.py

import my_module

print(my_module.greet("Alice"))
print(my_module.add(10, 20))
print(my_module.PI)

10. 面向对象编程

10.1 类与对象

class Person:
    """人类"""
    
    # 类属性
    species = "人类"
    
    def __init__(self, name, age):
        """初始化方法"""
        self.name = name  # 实例属性
        self.age = age
    
    def introduce(self):
        """实例方法"""
        return f"我叫{self.name}，今年{self.age}岁"
    
    @classmethod
    def get_species(cls):
        """类方法"""
        return f"物种：{cls.species}"
    
    @staticmethod
    def is_adult(age):
        """静态方法"""
        return age >= 18

# 创建对象
person1 = Person("张三", 25)
person2 = Person("李四", 30)

# 访问属性和方法
print(person1.introduce())          # 我叫张三，今年25岁
print(Person.get_species())         # 物种：人类
print(Person.is_adult(20))          # True

10.2 继承

class Animal:
    """动物基类"""
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        return "动物叫声"

class Dog(Animal):
    """狗类"""
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类初始化
        self.breed = breed
    
    def speak(self):  # 方法重写
        return "汪汪！"
    
    def info(self):
        return f"{self.name}是一只{self.breed}"

# 使用继承
dog = Dog("旺财", "金毛")
print(dog.speak())    # 汪汪！
print(dog.info())     # 旺财是一只金毛

封装与私有属性

Python 通过命名约定实现封装，单下划线表示保护成员，双下划线触发名称改写实现私有。

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner          # 公开属性
        self._branch = "总行"       # 保护属性（约定）
        self.__balance = balance    # 私有属性（名称改写）
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return f"存款成功，余额：{self.__balance}"
        return "存款金额必须大于0"
    
    def get_balance(self):
        """公开的访问方法"""
        return self.__balance

account = BankAccount("张三", 1000)
print(account.owner)               # 张三
print(account._branch)             # 总行（可访问但不推荐）
# print(account.__balance)         # 报错：AttributeError
print(account.get_balance())       # 1000（通过方法访问）
print(account.deposit(500))        # 存款成功，余额：1500

## 11. 实用技巧与最佳实践

Python 提供了许多简洁高效的技巧，能让代码更 Pythonic、更易读。本部分汇总一些常用技巧与最佳实践。

11.1 列表排序

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 升序排序
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
desc_numbers = sorted(numbers, reverse=True)
print(desc_numbers)    # [9, 6, 5, 4, 3, 2, 1, 1]

# 原地排序
numbers.sort()
print(numbers)         # [1, 1, 2, 3, 4, 5, 6, 9]

# 自定义排序
students = [
    {'name': '张三', 'score': 85},
    {'name': '李四', 'score': 92},
    {'name': '王五', 'score': 78}
]

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

11.2 列表推导式

列表推导式是一种快速生成列表的语法，兼具简洁与高效。

# 基本形式
squares = [x**2 for x in range(10)]          # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 带条件过滤
even_squares = [x**2 for x in range(10) if x % 2 == 0]   # [0, 4, 16, 36, 64]

# 嵌套循环
pairs = [(x, y) for x in 'ab' for y in '12']  # [('a','1'),('a','2'),('b','1'),('b','2')]

11.3 枚举与 zip

enumerate 可以同时获取索引和值；zip 将多个可迭代对象按元素位置合并。

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits, start=1):
    print(f"{index}. {fruit}")

names = ['张三', '李四', '王五']
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name}：{score}")

11.4 类型检查与转换

Python 是动态类型语言，必要时可通过内置函数检查和转换类型。

# 类型检查
print(type(123))           # <class 'int'>
print(isinstance(3.14, float))  # True

# 类型转换
num_str = "100"
num = int(num_str)         # 转整数
price = float("99.99")     # 转浮点数
text = str(2024)           # 转字符串

# 尝试安全转换，使用 try-except
def safe_int(s):
    try:
        return int(s)
    except ValueError:
        return None

print(safe_int("abc"))     # None

11.5 调试技巧

• 使用 print() 打印中间变量是最简单的调试方法；
• 利用 assert 断言检查预期条件；
• 使用 Python 的内置调试器 pdb 进行逐行调试；
• 善用 type() 和 dir() 探索对象。

# assert 示例
def divide(a, b):
    assert b != 0, "除数不能为零"
    return a / b

# 在代码中插入断点（Python 3.7+）
# breakpoint()   # 运行到此处会进入 pdb 调试环境

掌握这些技巧能显著提升开发效率和代码质量。