python入门学习

Python编程入门学习文档

适用于零基础学习者的Python完全指南

---

1. Python简介

1.1 什么是Python？

Python是一种高级编程语言，由Guido van Rossum在1991年创建。它的设计目标是让代码易于阅读和编写。

Python的特点：

• 简单易学：语法简洁，接近英语
• 功能强大：可用于网页开发、数据分析、人工智能等
• 跨平台：可以在Windows、Mac、Linux上运行
• 免费开源：完全免费使用

1.2 Python能做什么？

# Python的应用领域示例：

# 1. 网页开发
# 例如：使用Django、Flask框架开发网站

# 2. 数据分析和科学计算
import numpy as np  # 数值计算库
import pandas as pd  # 数据处理库

# 3. 人工智能和机器学习
# 例如：使用TensorFlow、PyTorch开发AI模型

# 4. 自动化脚本
# 例如：自动处理文件、批量操作

# 5. 游戏开发
# 例如：使用Pygame库开发游戏

print("Python是一种用途广泛的编程语言！")

---

2. 环境搭建

2.1 安装Python

Windows系统：

1. 访问Python官网：https://www.python.org
2. 下载最新版本的Python安装包
3. 运行安装程序，务必勾选”Add Python to PATH”
4. 点击”Install Now”完成安装

验证安装：

# 打开命令提示符（按Win+R，输入cmd），输入：
python --version

# 如果显示版本号（如Python 3.x.x），说明安装成功

2.2 选择代码编辑器

推荐使用以下编辑器：

编辑器	特点	适合人群
VS Code	免费、功能强大、插件丰富	初学者和专业开发者
PyCharm	专业Python IDE，功能全面	专业开发者
IDLE	Python自带，简单易用	初学者

VS Code安装Python插件：

1. 打开VS Code
2. 点击左侧扩展图标
3. 搜索”Python”
4. 安装Microsoft官方Python插件

---

3. 第一个Python程序

3.1 Hello World

# 这是你的第一个Python程序！
# print()函数用于在屏幕上显示文字

print("Hello, World!")
print("你好，世界！")

# 运行结果：
# Hello, World!
# 你好，世界！

3.2 运行Python程序

方法1：使用交互模式

# 打开命令提示符，输入python进入交互模式
python

# 在>>>提示符后输入代码
>>> print("Hello!")
Hello!

# 输入exit()退出交互模式
>>> exit()

方法2：使用脚本文件

# 将代码保存为文件（如hello.py），然后运行
# 保存文件后，在命令提示符中运行：
# python hello.py

---

4. 变量和数据类型

4.1 什么是变量？

变量是用来存储数据的容器，就像一个贴了标签的盒子。

# 变量的定义和使用

# 定义一个字符串变量
name = "小明"
print(name)  # 输出：小明

# 定义一个数字变量
age = 18
print(age)  # 输出：18

# 同时定义多个变量
x, y, z = 1, 2, 3
print(x, y, z)  # 输出：1 2 3

# 变量命名规则：
# 1. 只能包含字母、数字和下划线
# 2. 不能以数字开头
# 3. 区分大小写（name和Name是不同的变量）
# 4. 不能使用Python关键字（如if、for等）

4.2 数据类型

Python有几种基本数据类型：

# 1. 整数（int）- 没有小数点的数字
score = 100
print(type(score))  # 输出：<class 'int'>

# 2. 浮点数（float）- 有小数点的数字
price = 19.99
print(type(price))  # 输出：<class 'float'>

# 3. 字符串（str）- 文本内容
message = "Hello"
print(type(message))  # 输出：<class 'str'>

# 4. 布尔值（bool）- True或False
is_student = True
print(type(is_student))  # 输出：<class 'bool'>

# 5. 查看数据类型
print(type(100))        # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type("hello"))    # <class 'str'>
print(type(True))       # <class 'bool'>

4.3 类型转换

# 不同类型之间的转换

# 字符串转整数
num_str = "100"
num_int = int(num_str)  # 使用int()函数
print(num_int + 1)  # 输出：101

# 整数转字符串
num = 200
str_num = str(num)  # 使用str()函数
print("数字是：" + str_num)

# 整数转浮点数
x = int(3.14)  # 输出：3（会丢失小数部分）
y = float(5)   # 输出：5.0

# 注意：不是所有字符串都能转换为数字
# int("hello")  # 这会报错！

---

5. 字符串操作

5.1 创建字符串

# 字符串可以用单引号或双引号创建
name1 = '张三'
name2 = "李四"

# 包含特殊字符的字符串
sentence = "Hello, World!"  # 逗号和感叹号都可以

# 多行字符串
paragraph = """这是第一行
这是第二行
这是第三行"""
print(paragraph)

# 转义字符
print("Hello\tWorld")  # \t是制表符（Tab）
print("Hello\nWorld")  # \n是换行符
print("他说：\"你好\"")  # \"用于在字符串中显示引号
print("路径：C:\\Users")  # \\用于显示反斜杠

5.2 字符串索引

# 字符串中的每个字符都有一个位置（索引）
# 索引从0开始
text = "Hello"

# 获取单个字符
print(text[0])  # 输出：H（第一个字符）
print(text[1])  # 输出：e（第二个字符）
print(text[-1]) # 输出：o（最后一个字符）

# 获取子字符串（切片）
print(text[0:3])  # 输出：Hel（从索引0到3，不包含3）
print(text[2:])   # 输出：llo（从索引2到最后）
print(text[:3])   # 输出：Hel（从开始到索引3）

# 字符串长度
print(len(text))  # 输出：5

5.3 字符串方法

# 常用字符串方法

text = "  Hello, Python!  "

# 转换大小写
print(text.upper())      # 输出：  HELLO, PYTHON!  
print(text.lower())      # 输出：  hello, python!  
print(text.title())      # 输出：  Hello, Python!  

# 去除空白
print(text.strip())      # 输出：Hello, Python!（去除两边空白）
print(text.lstrip())     # 输出：Hello, Python!  （去除左边空白）
print(text.rstrip())     # 输出：  Hello, Python!（去除右边空白）

# 查找和替换
print(text.find("Python"))  # 输出：9（找到的位置）
print(text.replace("Python", "World"))  # 输出：  Hello, World!  

# 判断方法
email = "test@example.com"
print(email.startswith("test"))  # 输出：True
print(email.endswith(".com"))    # 输出：True
print(email.isalpha())           # 输出：False（包含@和.）

# 分割和连接
fruits = "apple,banana,cherry"
fruit_list = fruits.split(",")  # 按逗号分割
print(fruit_list)  # 输出：['apple', 'banana', 'cherry']

# 连接字符串
joined = "-".join(fruit_list)
print(joined)  # 输出：apple-banana-cherry

5.4 字符串格式化

# 方法1：f-string（推荐，Python 3.6+）
name = "小明"
age = 18
print(f"我叫{name}，今年{age}岁")

# 方法2：format方法
print("我叫{}，今年{}岁".format(name, age))

# 方法3：%格式化（旧式）
print("我叫%s，今年%d岁" % (name, age))

# 格式化数字
price = 19.99
print(f"价格：{price:.2f}")  # 保留2位小数：价格：19.99

# 对齐和填充
print(f"{'左对齐':<10}")     # 左对齐
print(f"{'右对齐':>10}")     # 右对齐
print(f"{'居中':^10}")       # 居中
print(f"{'填充':*^10}")      # 用*填充

---

6. 数字和运算符

6.1 算术运算符

# 基本算术运算
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.3333...
print(f"{a} // {b} = {a // b}")  # 整除：3（取整）
print(f"{a} % {b} = {a % b}")    # 取余：1（余数）
print(f"{a} ** {b} = {a ** b}")  # 幂运算：1000（10的3次方）

6.2 赋值运算符

# 赋值运算符
x = 10

x += 5   # 等同于 x = x + 5
print(x)  # 输出：15

x -= 3   # 等同于 x = x - 3
print(x)  # 输出：12

x *= 2   # 等同于 x = x * 2
print(x)  # 输出：24

x //= 5  # 等同于 x = x // 5
print(x)  # 输出：4

6.3 比较运算符

# 比较运算符返回布尔值（True或False）
x = 10
y = 20

print(x == y)  # 等于：False
print(x != y)  # 不等于：True
print(x > y)   # 大于：False
print(x < y)   # 小于：True
print(x >= 10) # 大于等于：True
print(x <= 5)  # 小于等于：False

6.4 逻辑运算符

# 逻辑运算符
a = True
b = False

print(a and b)  # 与：两个都为True才是True
print(a or b)   # 或：有一个为True就是True
print(not a)    # 非：取反

# 实际应用示例
age = 25
income = 5000

# 判断是否满足贷款条件（年龄>=18且收入>=3000）
can_loan = age >= 18 and income >= 3000
print(f"是否可以贷款：{can_loan}")  # 输出：True

6.5 数学函数

import math

# 常用数学函数
print(abs(-5))        # 绝对值：5
print(max(10, 20, 30))  # 最大值：30
print(min(10, 20, 30))  # 最小值：10

# 数学模块函数
print(math.sqrt(16))     # 平方根：4.0
print(math.pow(2, 3))    # 幂运算：8.0
print(math.ceil(3.2))    # 向上取整：4
print(math.floor(3.8))   # 向下取整：3
print(math.pi)           # 圆周率：3.141592653589793
print(math.e)            # 自然常数：2.718281828459045

---

7. 输入输出

7.1 输出（print）

# 基本输出
print("Hello, World!")

# 输出多个值
print("姓名：", "小明", "年龄：", 18)

# 自定义分隔符
print("2024", "01", "01", sep="-")  # 输出：2024-01-01

# 自定义结尾（默认是换行符）
print("Hello", end=" ")
print("World")  # 输出：Hello World

# 输出到文件
with open("output.txt", "w") as f:
    print("写入文件的内容", file=f)

7.2 输入（input）

# 基本输入
name = input("请输入你的名字：")
print(f"你好，{name}！")

# 输入数字
age = int(input("请输入你的年龄："))  # 需要转换为整数
print(f"明年你就{age + 1}岁了")

# 输入浮点数
height = float(input("请输入你的身高（米）："))
print(f"你的身高是{height}米")

# 提示：input()返回的始终是字符串类型
user_input = input("请输入任意内容：")
print(f"输入的内容是：{user_input}")
print(f"输入的类型是：{type(user_input)}")  # 输出：<class 'str'>

---

8. 条件判断

8.1 if语句

# 基本if语句
age = 18

if age >= 18:
    print("你已成年")
    print("可以投票了")

# 注意：Python使用缩进（4个空格）来表示代码块

8.2 if-else语句

# if-else语句
score = 75

if score >= 60:
    print("及格")
else:
    print("不及格")

# 示例：判断奇偶数
number = int(input("请输入一个数字："))

if number % 2 == 0:
    print(f"{number}是偶数")
else:
    print(f"{number}是奇数")

8.3 if-elif-else语句

# 多重条件判断
score = int(input("请输入成绩："))

if score >= 90:
    grade = "优秀"
elif score >= 80:
    grade = "良好"
elif score >= 70:
    grade = "中等"
elif score >= 60:
    grade = "及格"
else:
    grade = "不及格"

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

# 示例：BMI计算器
height = float(input("请输入身高（米）："))
weight = float(input("请输入体重（公斤）："))

bmi = weight / (height ** 2)
print(f"你的BMI指数是：{bmi:.1f}")

if bmi < 18.5:
    print("体重过轻")
elif bmi < 24:
    print("体重正常")
elif bmi < 28:
    print("体重过重")
else:
    print("肥胖")

8.4 嵌套if

# 嵌套条件判断
age = 25
has_id = True

if age >= 18:
    if has_id:
        print("可以进入")
    else:
        print("请出示身份证")
else:
    print("未成年人不能进入")

# 更简洁的写法（使用逻辑运算符）
if age >= 18 and has_id:
    print("可以进入")
else:
    print("不能进入")

---

9. 循环结构

9.1 for循环

# 基本for循环
for i in range(5):
    print(i)  # 输出：0, 1, 2, 3, 4

# range()函数的用法
range(5)        # 0, 1, 2, 3, 4
range(2, 8)     # 2, 3, 4, 5, 6, 7
range(0, 10, 2) # 0, 2, 4, 6, 8（步长为2）

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

# 遍历字符串
for char in "Hello":
    print(char)

# 使用enumerate()获取索引
for index, fruit in enumerate(fruits):
    print(f"第{index + 1}个水果是{fruit}")

9.2 while循环

# 基本while循环
count = 0
while count < 5:
    print(count)
    count += 1  # 必须更新条件，否则会无限循环

# 示例：猜数字游戏
import random

target = random.randint(1, 100)  # 生成1-100的随机数
guess = 0

while guess != target:
    guess = int(input("猜一个1-100的数字："))
    
    if guess < target:
        print("太小了")
    elif guess > target:
        print("太大了")
    else:
        print("恭喜你，猜对了！")

# 示例：计算1到100的和
total = 0
num = 1

while num <= 100:
    total += num
    num += 1

print(f"1到100的和是：{total}")  # 输出：5050

9.3 break和continue

# break：跳出循环
for i in range(10):
    if i == 5:
        break  # 当i等于5时，跳出循环
    print(i)
# 输出：0, 1, 2, 3, 4

# continue：跳过本次循环
for i in range(10):
    if i % 2 == 0:
        continue  # 跳过偶数
    print(i)
# 输出：1, 3, 5, 7, 9

# 示例：查找第一个能被7整除的数
numbers = [23, 45, 12, 56, 78, 34, 91]

for num in numbers:
    if num % 7 == 0:
        print(f"第一个能被7整除的数是：{num}")
        break
# 输出：第一个能被7整除的数是：56

9.4 嵌套循环

# 嵌套循环：九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j} x {i} = {i * j}", end="\t")
    print()  # 换行

# 输出：
# 1 x 1 = 1
# 1 x 2 = 2   2 x 2 = 4
# 1 x 3 = 3   2 x 3 = 6   3 x 3 = 9
# ...

# 示例：打印菱形图案
n = 5

# 上半部分
for i in range(1, n + 1):
    print(" " * (n - i) + "*" * (2 * i - 1))

# 下半部分
for i in range(n - 1, 0, -1):
    print(" " * (n - i) + "*" * (2 * i - 1))

---

10. 列表

10.1 创建列表

# 列表是Python中最常用的数据结构
# 用方括号[]表示，元素之间用逗号分隔

# 创建不同类型的列表
numbers = [1, 2, 3, 4, 5]
fruits = ["苹果", "香蕉", "橙子"]
mixed = [1, "hello", 3.14, True]  # 可以包含不同类型

# 空列表
empty_list = []

# 使用list()函数创建列表
chars = list("Hello")  # ['H', 'e', 'l', 'l', 'o']

10.2 访问列表元素

fruits = ["苹果", "香蕉", "橙子", "葡萄"]

# 通过索引访问（从0开始）
print(fruits[0])    # 苹果
print(fruits[1])    # 香蕉
print(fruits[-1])   # 葡萄（最后一个）

# 切片操作
print(fruits[1:3])   # ['香蕉', '橙子']
print(fruits[:2])    # ['苹果', '香蕉']
print(fruits[2:])    # ['橙子', '葡萄']
print(fruits[:])     # 所有元素

# 列表长度
print(len(fruits))   # 4

10.3 修改列表

fruits = ["苹果", "香蕉", "橙子"]

# 修改元素
fruits[1] = "草莓"
print(fruits)  # ['苹果', '草莓', '橙子']

# 添加元素
fruits.append("葡萄")  # 末尾添加
print(fruits)  # ['苹果', '草莓', '橙子', '葡萄']

fruits.insert(1, "香蕉")  # 指定位置插入
print(fruits)  # ['苹果', '香蕉', '草莓', '橙子', '葡萄']

# 删除元素
fruits.remove("橙子")  # 按值删除
print(fruits)  # ['苹果', '香蕉', '草莓', '葡萄']

popped = fruits.pop()  # 删除最后一个并返回
print(popped)  # 葡萄
print(fruits)  # ['苹果', '香蕉', '草莓']

del fruits[0]  # 按索引删除
print(fruits)  # ['香蕉', '草莓']

# 清空列表
fruits.clear()
print(fruits)  # []

10.4 列表方法

# 常用列表方法
numbers = [3, 1, 4, 1, 5, 9, 2, 6]

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

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

#  sorted()函数返回新列表，不修改原列表
original = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_list = sorted(original)
print(sorted_list)   # [1, 1, 2, 3, 4, 5, 6, 9]
print(original)      # [3, 1, 4, 1, 5, 9, 2, 6]

# 查找
print(numbers.index(5))  # 查找5的位置：4
print(numbers.count(1))  # 统计1出现的次数：2

# 复制列表
list1 = [1, 2, 3]
list2 = list1.copy()  # 浅拷贝
list3 = list1[:]      # 另一种浅拷贝方式

# 反转
numbers.reverse()
print(numbers)  # [1, 2, 3, 4, 5, 6, 9]

# 合并列表
list_a = [1, 2]
list_b = [3, 4]
merged = list_a + list_b
print(merged)  # [1, 2, 3, 4]

# 列表推导式
squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 带条件的列表推导式
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

---

11. 元组

11.1 创建和使用元组

# 元组是不可变的列表，用圆括号()表示

# 创建元组
colors = ("红色", "绿色", "蓝色")
numbers = (1, 2, 3, 4, 5)
single = (1,)  # 单元素元组必须加逗号
empty = ()

# 访问元组元素
print(colors[0])    # 红色
print(colors[-1])   # 蓝色

# 切片操作
print(numbers[1:3])  # (2, 3)

# 元组不可修改
# colors[0] = "黄色"  # 这会报错！

# 遍历元组
for color in colors:
    print(color)

# 元组解包
x, y, z = (1, 2, 3)
print(x, y, z)  # 1 2 3

# 交换变量值
a, b = 1, 2
a, b = b, a
print(a, b)  # 2 1

11.2 元组和列表的区别

# 元组 vs 列表

# 1. 可变性
my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

my_list[0] = 10   # 可以修改
# my_tuple[0] = 10  # 不能修改，会报错

# 2. 性能
# 元组比列表更快，占用内存更少

# 3. 使用场景
# 列表：需要修改的数据
# 元组：不需要修改的数据，如坐标、颜色等

# 4. 元组可以作为字典的键
point = (10, 20)
location = {point: "北京"}
print(location[(10, 20)])  # 北京

# 列表不能作为字典的键
# point_list = [10, 20]
# location = {point_list: "北京"}  # 这会报错

---

12. 字典

12.1 创建字典

# 字典是键值对的集合，用花括号{}表示

# 创建字典
student = {
    "name": "小明",
    "age": 18,
    "score": 95
}

# 另一种创建方式
person = dict(name="小红", age=20, city="北京")

# 空字典
empty = {}

# 使用字典推导式
squares = {x: x ** 2 for x in range(5)}
print(squares)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

12.2 访问字典

student = {"name": "小明", "age": 18, "score": 95}

# 通过键访问值
print(student["name"])  # 小明

# 使用get()方法（更安全）
print(student.get("name"))  # 小明
print(student.get("gender", "未知"))  # 未知（键不存在时返回默认值）

# 检查键是否存在
print("name" in student)   # True
print("gender" in student)  # False

# 获取所有键、值和键值对
print(student.keys())    # dict_keys(['name', 'age', 'score'])
print(student.values())  # dict_values(['小明', 18, 95])
print(student.items())   # dict_items([('name', '小明'), ('age', 18), ('score', 95)])

12.3 修改字典

student = {"name": "小明", "age": 18}

# 添加/修改键值对
student["score"] = 95     # 添加新键
student["age"] = 19       # 修改已有键
print(student)  # {'name': '小明', 'age': 19, 'score': 95}

# 删除键值对
del student["score"]
print(student)  # {'name': '小明', 'age': 19}

popped = student.pop("name")
print(popped)    # 小明
print(student)  # {'age': 19}

# 更新字典
student.update({"score": 100, "grade": "高三"})
print(student)  # {'age': 19, 'score': 100, 'grade': '高三'}

12.4 遍历字典

student = {"name": "小明", "age": 18, "score": 95}

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

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

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

# 示例：统计字符出现次数
text = "hello world"
char_count = {}

for char in text:
    if char in char_count:
        char_count[char] += 1
    else:
        char_count[char] = 1

print(char_count)
# {'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}

12.5 嵌套字典

# 字典可以嵌套使用
students = {
    "小明": {
        "age": 18,
        "scores": {"数学": 95, "英语": 88}
    },
    "小红": {
        "age": 19,
        "scores": {"数学": 90, "英语": 92}
    }
}

# 访问嵌套数据
print(students["小明"]["scores"]["数学"])  # 95

# 遍历嵌套字典
for name, info in students.items():
    print(f"\n{name}的信息：")
    for key, value in info.items():
        print(f"  {key}: {value}")

---

13. 集合

13.1 创建集合

# 集合是无序、不重复的元素集合

# 创建集合
fruits = {"苹果", "香蕉", "橙子"}
numbers = {1, 2, 3, 4, 5}

# 注意：空集合必须用set()，不能用{}
empty = set()  # 空集合
empty_dict = {}  # 这是空字典！

# 从其他类型创建
chars = set("Hello")  # {'H', 'e', 'l', 'o'}
nums = set([1, 2, 2, 3, 3, 3])  # {1, 2, 3}（自动去重）

13.2 集合操作

# 添加和删除元素
fruits = {"苹果", "香蕉"}

fruits.add("橙子")
print(fruits)  # {'苹果', '香蕉', '橙子'}

fruits.remove("香蕉")
print(fruits)  # {'苹果', '橙子'}

# discard()方法不会报错
fruits.discard("不存在")  # 不会报错

# 集合运算
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# 并集
print(A | B)  # {1, 2, 3, 4, 5, 6, 7, 8}
print(A.union(B))

# 交集
print(A & B)  # {4, 5}
print(A.intersection(B))

# 差集
print(A - B)  # {1, 2, 3}
print(A.difference(B))

# 对称差集（不包含交集）
print(A ^ B)  # {1, 2, 3, 6, 7, 8}
print(A.symmetric_difference(B))

13.3 集合方法

# 常用集合方法
A = {1, 2, 3}
B = {2, 3, 4}

# 子集和超集
print(A.issubset({1, 2, 3, 4}))   # True
print({1, 2, 3}.issubset(A))      # True
print(A.issuperset({1, 2}))       # True

# 不相交判断
C = {5, 6, 7}
print(A.isdisjoint(C))  # True（没有共同元素）

# 更新集合
A.update({4, 5, 6})
print(A)  # {1, 2, 3, 4, 5, 6}

A.intersection_update({4, 5, 6, 7})
print(A)  # {4, 5, 6}

---

14. 函数

14.1 定义和调用函数

# 函数是可重复使用的代码块

# 定义函数
def greet():
    """这是一个打招呼的函数"""
    print("Hello!")
    print("欢迎学习Python！")

# 调用函数
greet()  # 输出两行文字

# 带参数的函数
def greet_user(name):
    """向指定用户打招呼"""
    print(f"Hello, {name}!")

greet_user("小明")  # 输出：Hello, 小明!
greet_user("小红")  # 输出：Hello, 小红!

14.2 参数和返回值

# 多个参数
def add(a, b):
    """返回两个数的和"""
    return a + b

result = add(3, 5)
print(result)  # 8

# 默认参数
def greet(name, greeting="你好"):
    """带默认参数的函数"""
    print(f"{greeting}, {name}!")

greet("小明")          # 你好, 小明!
greet("小明", "早上好")  # 早上好, 小明!

# 关键字参数
def create_profile(name, age, city):
    """创建用户档案"""
    return {"name": name, "age": age, "city": city}

profile = create_profile(age=20, name="小红", city="北京")
print(profile)  # {'name': '小红', 'age': 20, 'city': '北京'}

# *args和**kwargs
def print_info(*args, **kwargs):
    """接受任意数量的参数"""
    print("位置参数：", args)
    print("关键字参数：", kwargs)

print_info(1, 2, 3, name="小明", age=18)
# 位置参数： (1, 2, 3)
# 关键字参数： {'name': '小明', 'age': 18}

14.3 变量作用域

# 全局变量和局部变量
x = 10  # 全局变量

def func():
    x = 20  # 局部变量（与全局变量同名）
    print(x)  # 20

func()  # 20
print(x)  # 10（全局变量未改变）

# 使用global关键字修改全局变量
def func2():
    global x
    x = 30

func2()
print(x)  # 30

14.4 Lambda函数

# Lambda函数是匿名函数，用于简单操作

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

# Lambda函数
square_lambda = lambda x: x ** 2

print(square(5))         # 25
print(square_lambda(5))  # 25

# 多参数Lambda
add = lambda x, y: x + y
print(add(3, 5))  # 8

# Lambda在排序中的应用
students = [("小明", 85), ("小红", 92), ("小刚", 78)]
students.sort(key=lambda x: x[1], reverse=True)
print(students)  # [('小红', 92), ('小明', 85), ('小刚', 78)]

# 使用map()和filter()
numbers = [1, 2, 3, 4, 5]

# map：对每个元素应用函数
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# filter：过滤元素
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

14.5 递归函数

# 递归是函数调用自身的技巧

# 阶乘函数
def factorial(n):
    """计算n的阶乘"""
    if n == 0 or n == 1:  # 基准条件
        return 1
    else:  # 递归条件
        return n * factorial(n - 1)

print(factorial(5))  # 120（5! = 5 * 4 * 3 * 2 * 1）

# 斐波那契数列
def fibonacci(n):
    """返回第n个斐波那契数"""
    if n <= 1:
        return n
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

# 打印前10个斐波那契数
for i in range(10):
    print(fibonacci(i), end=" ")  # 0 1 1 2 3 5 8 13 21 34

# 注意：递归深度有限制，默认约1000层

---

15. 文件操作

15.1 读写文件

# 写入文件
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.write("第二行\n")
    f.write("Hello, World!")

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

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

# 读取所有行到列表
with open("test.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    print(lines)  # ['第一行\n', '第二行\n', 'Hello, World!']

15.2 文件模式

# 文件打开模式
# "r"  - 只读（默认）
# "w"  - 写入（覆盖已有内容）
# "a"  - 追加（在末尾添加）
# "x"  - 创建（文件已存在则报错）
# "r+" - 读写
# "rb" - 二进制读取
# "wb" - 二进制写入

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

# 使用try-finally确保文件关闭
f = open("test.txt", "r", encoding="utf-8")
try:
    content = f.read()
finally:
    f.close()  # 确保文件被关闭

# 推荐使用with语句（自动关闭文件）
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()
# with语句结束后，文件自动关闭

15.3 处理CSV文件

import csv

# 写入CSV文件
data = [
    ["姓名", "年龄", "成绩"],
    ["小明", 18, 95],
    ["小红", 19, 88],
    ["小刚", 20, 92]
]

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

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

# 输出：
# ['姓名', '年龄', '成绩']
# ['小明', '18', '95']
# ['小红', '19', '88']
# ['小刚', '20', '92']

15.4 JSON文件操作

import json

# 写入JSON文件
data = {
    "name": "小明",
    "age": 18,
    "scores": {"数学": 95, "英语": 88}
}

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_data = json.load(f)
    print(loaded_data)
    print(f"姓名：{loaded_data['name']}")
    print(f"数学成绩：{loaded_data['scores']['数学']}")

---

16. 异常处理

16.1 基本异常处理

# 异常处理用于捕获和处理程序运行时的错误

# 基本语法
try:
    # 可能出错的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理特定异常
    print("除数不能为零！")

# 处理多种异常
try:
    num = int(input("请输入数字："))
    result = 100 / num
except ValueError:
    print("请输入有效的数字！")
except ZeroDivisionError:
    print("除数不能为零！")

# 处理所有异常
try:
    # 可能出错的代码
    pass
except Exception as e:
    print(f"发生错误：{e}")

16.2 完整的异常处理

# 完整的try-except结构
try:
    # 可能出错的代码
    num = int(input("请输入数字："))
    result = 100 / num
except ValueError:
    print("请输入有效的数字！")
except ZeroDivisionError:
    print("除数不能为零！")
else:
    # 没有异常时执行
    print(f"结果是：{result}")
finally:
    # 无论如何都会执行
    print("程序结束")

# 实际应用示例
def safe_divide(a, b):
    """安全的除法运算"""
    try:
        result = a / b
    except ZeroDivisionError:
        print("错误：除数不能为零")
        return None
    else:
        return result
    finally:
        print("计算完成")

print(safe_divide(10, 3))   # 3.3333...
print(safe_divide(10, 0))   # 错误：除数不能为零

16.3 自定义异常

# 自定义异常类
class InsufficientFundsError(Exception):
    """余额不足异常"""
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"余额不足：当前余额{balance}，需要{amount}")

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance
    
    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientFundsError(self.balance, amount)
        self.balance -= amount
        return self.balance

# 使用自定义异常
account = BankAccount(100)
try:
    account.withdraw(150)
except InsufficientFundsError as e:
    print(e)  # 余额不足：当前余额100，需要150

---

17. 模块和包

17.1 导入模块

# Python的强大之处在于丰富的模块库

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

# 导入模块的特定函数
from math import sqrt
print(sqrt(16))  # 4.0

# 导入模块并起别名
import math as m
print(m.sqrt(16))  # 4.0

# 从模块导入多个函数
from math import sqrt, pi, e
print(sqrt(16))  # 4.0
print(pi)        # 3.141592653589793

# 导入模块中的所有函数（不推荐）
from math import *

17.2 常用内置模块

# 1. math模块 - 数学运算
import math
print(math.pi)           # 3.141592653589793
print(math.sqrt(25))     # 5.0
print(math.ceil(3.2))    # 4
print(math.floor(3.8))   # 3

# 2. random模块 - 随机数
import random
print(random.randint(1, 100))  # 1-100的随机整数
print(random.random())         # 0-1的随机浮点数
print(random.choice([1,2,3,4,5]))  # 从列表随机选择
print(random.shuffle([1,2,3,4,5])) # 打乱列表

# 3. datetime模块 - 日期时间
from datetime import datetime
now = datetime.now()
print(now)  # 2024-01-15 10:30:45.123456
print(now.year)   # 2024
print(now.month)  # 1
print(now.day)    # 15

# 4. os模块 - 操作系统相关
import os
print(os.getcwd())  # 当前工作目录
print(os.listdir("."))  # 列出当前目录内容
print(os.path.exists("test.txt"))  # 检查文件是否存在

# 5. sys模块 - 系统相关
import sys
print(sys.version)  # Python版本
print(sys.path)     # 模块搜索路径

17.3 创建自己的模块

# 创建一个名为my_module.py的文件
# 内容如下：

# my_module.py
def greet(name):
    """打招呼函数"""
    return f"Hello, {name}!"

def add(a, b):
    """加法函数"""
    return a + b

PI = 3.14159

# 在另一个文件中导入使用
# main.py
import my_module

print(my_module.greet("小明"))  # Hello, 小明!
print(my_module.add(3, 5))      # 8
print(my_module.PI)             # 3.14159

17.4 包

# 包是包含__init__.py文件的目录

# 目录结构示例：
# my_package/
#     __init__.py
#     module1.py
#     module2.py
#     sub_package/
#         __init__.py
#         module3.py

# __init__.py可以使目录被识别为包
# 可以为空，也可以包含初始化代码

# 导入包中的模块
import my_package.module1
from my_package import module2
from my_package.sub_package import module3

# 使用pip安装第三方包
# 在命令行中运行：
# pip install package_name
# pip install numpy pandas matplotlib

---

18. 面向对象编程

18.1 类和对象

# 类是对象的蓝图，对象是类的实例

# 定义类
class Dog:
    """狗类"""
    
    # 类属性（所有实例共享）
    species = "犬科"
    
    def __init__(self, name, age):
        """初始化方法（构造函数）"""
        # 实例属性（每个实例独有）
        self.name = name
        self.age = age
    
    def bark(self):
        """实例方法"""
        return f"{self.name}在叫：汪汪汪！"
    
    def info(self):
        """显示狗的信息"""
        return f"{self.name}，{self.age}岁，{self.species}"

# 创建对象（实例化）
dog1 = Dog("旺财", 3)
dog2 = Dog("小黑", 5)

# 使用对象
print(dog1.bark())    # 旺财在叫：汪汪汪！
print(dog2.info())    # 小黑，5岁，犬科
print(Dog.species)    # 犬科

18.2 继承

# 继承允许子类复用父类的属性和方法

# 父类
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def speak(self):
        return "..."
    
    def info(self):
        return f"{self.name}，{self.age}岁"

# 子类
class Cat(Animal):
    def __init__(self, name, age, color):
        super().__init__(name, age)  # 调用父类构造函数
        self.color = color
    
    def speak(self):  # 重写父类方法
        return "喵喵喵！"
    
    def purr(self):
        return f"{self.name}在打呼噜"

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)
        self.breed = breed
    
    def speak(self):
        return "汪汪汪！"
    
    def fetch(self):
        return f"{self.name}在捡球"

# 使用继承
cat = Cat("小花", 2, "白色")
dog = Dog("旺财", 3, "金毛")

print(cat.info())    # 小花，2岁（继承自Animal）
print(cat.speak())   # 喵喵喵！（重写的方法）
print(cat.purr())    # 小花在打呼噜

print(dog.info())    # 旺财，3岁
print(dog.speak())   # 汪汪汪！
print(dog.fetch())   # 旺财在捡球

# 检查继承关系
print(isinstance(cat, Cat))    # True
print(isinstance(cat, Animal)) # True
print(issubclass(Cat, Animal)) # True

18.3 封装

# 封装是隐藏对象内部状态，只暴露必要接口

class Student:
    def __init__(self, name, score):
        self.name = name
        self.__score = score  # 双下划线表示私有属性
    
    # 使用@property装饰器创建getter
    @property
    def score(self):
        """获取成绩"""
        return self.__score
    
    # 使用@score.setter创建setter
    @score.setter
    def score(self, value):
        """设置成绩（带验证）"""
        if 0 <= value <= 100:
            self.__score = value
        else:
            raise ValueError("成绩必须在0-100之间")
    
    def get_grade(self):
        """根据成绩获取等级"""
        if self.__score >= 90:
            return "A"
        elif self.__score >= 80:
            return "B"
        elif self.__score >= 70:
            return "C"
        elif self.__score >= 60:
            return "D"
        else:
            return "F"

# 使用封装
student = Student("小明", 85)
print(student.name)      # 小明
print(student.score)     # 85（通过getter）
# print(student.__score)  # 报错！不能直接访问私有属性

student.score = 95       # 通过setter设置
print(student.score)     # 95

# student.score = 150    # 报错！成绩必须在0-100之间
print(student.get_grade())  # A

18.4 多态

# 多态是指同一个方法在不同对象上有不同的行为

class Shape:
    def area(self):
        raise NotImplementedError("子类必须实现area方法")

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height
    
    def area(self):
        return 0.5 * self.base * self.height

# 多态的应用
def print_area(shape):
    """打印任何形状的面积"""
    print(f"面积：{shape.area()}")

# 创建不同形状
shapes = [
    Circle(5),
    Rectangle(4, 6),
    Triangle(3, 8)
]

# 多态：同一个函数处理不同类型的对象
for shape in shapes:
    print_area(shape)

# 输出：
# 面积：78.53975
# 面积：24
# 面积：12.0

18.5 魔术方法

# 魔术方法（双下划线方法）让类支持内置操作

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __repr__(self):
        """定义打印时的表示"""
        return f"Vector({self.x}, {self.y})"
    
    def __str__(self):
        """定义str()函数的行为"""
        return f"({self.x}, {self.y})"
    
    def __add__(self, other):
        """定义加法运算"""
        return Vector(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        """定义减法运算"""
        return Vector(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        """定义乘法运算"""
        return Vector(self.x * scalar, self.y * scalar)
    
    def __eq__(self, other):
        """定义相等比较"""
        return self.x == other.x and self.y == other.y
    
    def __len__(self):
        """定义len()函数的行为"""
        return int((self.x ** 2 + self.y ** 2) ** 0.5)

# 使用魔术方法
v1 = Vector(3, 4)
v2 = Vector(1, 2)

print(v1)          # (3, 4)
print(repr(v1))    # Vector(3, 4)
print(v1 + v2)     # (4, 6)
print(v1 - v2)     # (2, 2)
print(v1 * 2)      # (6, 8)
print(v1 == v2)    # False

---

19. 综合项目实战

19.1 猜数字游戏

import random

def guess_number_game():
    """猜数字游戏"""
    print("=== 猜数字游戏 ===")
    print("我想了一个1-100之间的数字，猜猜看！")
    
    target = random.randint(1, 100)
    attempts = 0
    max_attempts = 10
    
    while attempts < max_attempts:
        try:
            guess = int(input(f"\n第{attempts + 1}次猜测（剩余{max_attempts - attempts}次）："))
        except ValueError:
            print("请输入有效的数字！")
            continue
        
        attempts += 1
        
        if guess < target:
            print("太小了！再大一点")
        elif guess > target:
            print("太大了！再小一点")
        else:
            print(f"\n恭喜你！猜对了！答案是{target}")
            print(f"你用了{attempts}次就猜对了！")
            
            if attempts <= 3:
                print("太厉害了！你是天才！")
            elif attempts <= 6:
                print("很不错！")
            else:
                print("还不错，继续努力！")
            return
    
    print(f"\n很遗憾，你没有猜对。答案是{target}")
    print("下次再接再厉！")

# 运行游戏
guess_number_game()

19.2 学生成绩管理系统

class StudentManager:
    """学生成绩管理系统"""
    
    def __init__(self):
        self.students = {}
    
    def add_student(self, name, scores):
        """添加学生"""
        self.students[name] = scores
        print(f"已添加学生：{name}")
    
    def remove_student(self, name):
        """删除学生"""
        if name in self.students:
            del self.students[name]
            print(f"已删除学生：{name}")
        else:
            print(f"未找到学生：{name}")
    
    def get_student_average(self, name):
        """获取学生平均分"""
        if name in self.students:
            scores = self.students[name]
            return sum(scores.values()) / len(scores)
        return None
    
    def get_subject_average(self, subject):
        """获取科目平均分"""
        total = 0
        count = 0
        for scores in self.students.values():
            if subject in scores:
                total += scores[subject]
                count += 1
        return total / count if count > 0 else 0
    
    def get_top_students(self, n=3):
        """获取成绩最好的n个学生"""
        averages = [(name, self.get_student_average(name)) 
                    for name in self.students]
        averages.sort(key=lambda x: x[1], reverse=True)
        return averages[:n]
    
    def display_all(self):
        """显示所有学生信息"""
        print("\n=== 学生成绩 ===")
        for name, scores in self.students.items():
            avg = self.get_student_average(name)
            print(f"\n{name}：")
            for subject, score in scores.items():
                print(f"  {subject}: {score}")
            print(f"  平均分: {avg:.1f}")

# 使用系统
manager = StudentManager()

# 添加学生
manager.add_student("小明", {"数学": 95, "英语": 88, "物理": 92})
manager.add_student("小红", {"数学": 88, "英语": 95, "物理": 85})
manager.add_student("小刚", {"数学": 78, "英语": 82, "物理": 90})

# 显示所有学生
manager.display_all()

# 获取统计信息
print(f"\n小明的平均分：{manager.get_student_average('小明'):.1f}")
print(f"数学平均分：{manager.get_subject_average('数学'):.1f}")
print("\n成绩最好的3个学生：")
for name, avg in manager.get_top_students():
    print(f"  {name}: {avg:.1f}")

19.3 简单计算器

def calculator():
    """简单计算器"""
    print("=== 简单计算器 ===")
    print("支持的运算：+  -  *  /")
    
    while True:
        try:
            # 获取用户输入
            num1 = float(input("\n请输入第一个数字（输入q退出）："))
        except ValueError:
            print("请输入有效的数字！")
            continue
        
        if num1 == 'q':
            print("再见！")
            break
        
        operator = input("请输入运算符（+ - * /）：")
        if operator not in ['+', '-', '*', '/']:
            print("无效的运算符！")
            continue
        
        try:
            num2 = float(input("请输入第二个数字："))
        except ValueError:
            print("请输入有效的数字！")
            continue
        
        # 执行计算
        if operator == '+':
            result = num1 + num2
        elif operator == '-':
            result = num1 - num2
        elif operator == '*':
            result = num1 * num2
        elif operator == '/':
            if num2 == 0:
                print("错误：除数不能为零！")
                continue
            result = num1 / num2
        
        print(f"\n{num1} {operator} {num2} = {result}")

# 运行计算器
calculator()

---

20. 学习资源和下一步

20.1 推荐学习资源

在线教程：

• Python官方教程：https://docs.python.org/zh-cn/3/tutorial/
• 廖雪峰Python教程：https://www.liaoxuefeng.com/wiki/1016959663602400
• 菜鸟教程Python：https://www.runoob.com/python3/python3-tutorial.html

练习平台：

• LeetCode：https://leetcode.cn/（算法练习）
• 力扣：https://leetcode.cn/（中文算法平台）
• Codewars：https://www.codewars.com/（编程练习）

推荐书籍：

• 《Python编程：从入门到实践》
• 《笨办法学Python》
• 《Python基础教程》

20.2 下一步学习建议

1. 深入学习数据结构和算法

   • 栈、队列、链表
   • 排序和搜索算法
   • 时间复杂度和空间复杂度

2. 学习Web开发

   • Flask或Django框架
   • HTML、CSS、JavaScript基础
   • 数据库操作

3. 学习数据分析

   • NumPy数值计算
   • Pandas数据处理
   • Matplotlib数据可视化

4. 学习人工智能

   • 机器学习基础
   • TensorFlow或PyTorch
   • 深度学习

5. 参与开源项目

   • 在GitHub上学习别人的代码
   • 贡献自己的代码
   • 与其他开发者交流

20.3 学习建议

• 多动手实践：编程是实践性很强的技能，一定要多写代码
• 不要怕犯错：错误是最好的老师，从错误中学习
• 保持耐心：学习编程需要时间，不要急于求成
• 加入社区：与其他学习者交流，互相帮助
• 定期复习：定期回顾学过的知识，加深理解

---

总结

恭喜你完成了Python入门学习！你现在已经掌握了：

• Python基础语法
• 变量、数据类型和运算符
• 条件判断和循环结构
• 列表、元组、字典、集合
• 函数和模块
• 文件操作和异常处理
• 面向对象编程

记住，编程是一项需要持续练习的技能。保持好奇心，多动手实践，你一定会越来越棒！

祝你学习愉快，编程之路一帆风顺！ 🐍