Python编程入门完全教程

📘 本教程专为零基础学习者编写，从最基础的概念讲起，循序渐进地带你掌握Python编程的核心知识。每个章节都配有详细的代码示例和通俗易懂的解释，让你在学习过程中有据可依、有码可循。

Python简介与发展历史
环境安装与配置
第一个Python程序
变量与数据类型
运算符
字符串操作
列表、元组、字典、集合
条件语句
循环语句
函数定义与调用
模块与包
文件操作
异常处理
面向对象编程基础
常用内置函数
实战项目：简易计算器
实战项目：猜数字游戏
学习资源推荐

1. Python简介与发展历史

1.1 什么是Python？

Python是一种高级编程语言，由荷兰程序员吉多·范罗苏姆（Guido van Rossum）于1991年首次发布。Python的设计哲学强调代码的可读性和简洁性，使得即使是编程初学者也能快速上手。Python的名字来源于英国喜剧团体"Monty Python"，而非蟒蛇——这也许是很多初学者不知道的趣闻。

Python之所以受到全球开发者的喜爱，主要有以下几个原因：

语法简洁明了：Python使用缩进来表示代码块，而不是使用大括号或其他特殊符号，这让代码看起来更加整洁。
丰富的标准库：Python内置了大量的模块和函数，几乎可以满足日常开发中的所有需求。
跨平台兼容：Python可以在Windows、macOS、Linux等多种操作系统上运行，无需修改代码。
强大的社区支持：Python拥有全球数百万开发者组成的社区，遇到问题时很容易找到解决方案。
广泛的应用领域：从Web开发到人工智能，从数据分析到自动化脚本，Python几乎无处不在。

1.2 Python的发展历史

Python的发展历程可以分为几个重要阶段：

Python 1.0（1994年）：这是Python的第一个正式版本，包含了lambda、map、filter等函数式编程特性，奠定了Python作为一门现代编程语言的基础。

Python 2.0（2000年）：引入了列表推导式、垃圾回收机制和Unicode支持等重要特性。Python 2系列在此后的十多年里成为了最流行的版本，大量项目和库都是基于Python 2开发的。

Python 3.0（2008年）：这是一个重大更新版本，修复了Python 2中的一些设计缺陷，但同时也引入了与Python 2不兼容的变更。Python 3的设计目标是"只保留一种显而易见的方式来做事"。

Python 2的终结（2020年）：Python 2于2020年1月1日正式停止维护，这意味着所有新项目都应该使用Python 3。

持续演进（至今）：Python 3持续更新，每个新版本都会带来性能提升和新特性。目前推荐使用Python 3.10或更高版本。

1.3 Python的应用领域

Python的应用非常广泛，以下是几个主要领域：

Web开发：使用Django、Flask等框架，可以快速构建功能强大的网站和Web应用。Instagram、Pinterest、Mozilla等知名网站都大量使用了Python。

数据科学与人工智能：NumPy、Pandas、Matplotlib、Scikit-learn、TensorFlow、PyTorch等库让Python成为了数据科学和机器学习领域的首选语言。

自动化运维：Python可以编写各种自动化脚本，用于系统管理、网络配置、日志分析等工作。

游戏开发：虽然不是游戏开发的主流语言，但Python的Pygame库可以用来开发简单的2D游戏。

科学计算：SciPy等库让Python在科学计算领域有着广泛的应用，许多科研机构和大学都使用Python进行数据分析和模拟。

1.4 为什么选择Python作为第一门编程语言？

对于编程初学者来说，Python是最理想的选择之一。原因如下：

第一，Python的语法接近自然语言，学习曲线平缓。你可以把更多的精力放在理解编程逻辑上，而不是纠结于复杂的语法规则。比如，打印"Hello, World!"在Python中只需要一行代码：print("Hello, World!")，而在某些其他语言中可能需要好几行。

第二，Python的即时反馈特性非常适合学习。你可以打开Python解释器，输入一行代码立即看到结果，这种交互式的学习方式大大降低了学习门槛。

第三，Python的就业前景广阔。根据多个编程语言排行榜的数据，Python长期位居最受欢迎编程语言的前列，掌握Python可以为你打开很多职业发展的大门。

2. 环境安装与配置

2.1 Windows系统安装Python

方法一：从官网下载安装

打开浏览器，访问Python官方网站：https://www.python.org
点击导航栏中的"Downloads"，网站会自动检测你的操作系统并推荐合适的版本
点击下载按钮，获取安装包
双击运行下载的安装程序
重要：在安装界面的底部，务必勾选"Add Python to PATH"选项，这会将Python添加到系统环境变量中
点击"Install Now"进行默认安装，或者选择"Customize installation"进行自定义安装
等待安装完成

验证安装：

打开命令提示符（按Win+R，输入cmd，回车），输入以下命令：

python --version

如果显示类似Python 3.12.0的版本信息，说明安装成功。

方法二：使用Microsoft Store

Windows 10和Windows 11用户也可以通过Microsoft Store安装Python：

打开Microsoft Store应用
搜索"Python"
选择最新版本（如Python 3.12）
点击"获取"或"安装"

这种方式的优点是自动处理环境变量配置，适合新手。

2.2 macOS系统安装Python

macOS系统通常预装了Python，但可能是较旧的版本。建议安装最新版本：

方法一：从官网下载

访问 https://www.python.org/downloads/macos/
下载最新版本的macOS安装包（.pkg文件）
双击运行安装程序，按照提示完成安装
安装完成后，打开终端（Terminal），输入python3 --version验证

方法二：使用Homebrew

Homebrew是macOS上非常流行的包管理器，使用它可以方便地安装和管理各种软件：

# 首先安装Homebrew（如果还没有安装）
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 使用Homebrew安装Python
brew install python

安装完成后，在终端输入python3 --version验证。

注意：在macOS上，python命令可能指向系统自带的旧版本Python 2，建议使用python3命令来调用新安装的Python 3。

2.3 Linux系统安装Python

大多数Linux发行版都预装了Python。你可以通过包管理器安装或更新Python：

Ubuntu/Debian系统：

# 更新软件包列表
sudo apt update

# 安装Python 3
sudo apt install python3 python3-pip

# 验证安装
python3 --version

CentOS/RHEL系统：

# 安装Python 3
sudo yum install python3

# 或者在较新版本中使用dnf
sudo dnf install python3

# 验证安装
python3 --version

Fedora系统：

sudo dnf install python3
python3 --version

Arch Linux系统：

sudo pacman -S python
python --version

2.4 安装pip包管理器

pip是Python的包管理工具，用于安装和管理第三方库。Python 3.4及以上版本通常已经自带pip。

# 检查pip是否已安装
pip3 --version

# 如果没有安装，可以通过以下方式安装
python3 -m ensurepip --upgrade

使用pip安装第三方库的示例：

# 安装requests库
pip3 install requests

# 安装特定版本的库
pip3 install numpy==1.24.0

# 升级已安装的库
pip3 install --upgrade requests

# 查看已安装的库
pip3 list

# 卸载库
pip3 uninstall requests

2.5 选择代码编辑器

一个好的代码编辑器可以大大提高编程效率。以下是几款推荐的编辑器：

Visual Studio Code（推荐）：

免费开源，由微软开发
支持丰富的Python扩展（代码补全、调试、Linting等）
轻量级但功能强大
下载地址：https://code.visualstudio.com

PyCharm：

JetBrains公司开发的专业Python IDE
社区版免费，专业版收费
功能非常全面，适合大型项目开发
下载地址：https://www.jetbrains.com/pycharm/

IDLE：

Python自带的集成开发环境
适合初学者进行简单的代码练习
安装Python后自动可用

Jupyter Notebook：

交互式编程环境，特别适合数据分析和学习
支持代码、文本、图表混合展示
通过pip3 install jupyter安装

3. 第一个Python程序

3.1 使用交互式解释器

Python最方便的特性之一就是它的交互式解释器，也叫REPL（Read-Eval-Print Loop，读取-求值-打印循环）。你可以打开终端或命令提示符，输入python3（Windows上可能是python）进入交互模式：

>>> print("Hello, World!")
Hello, World!

>>> 2 + 3
5

>>> name = "Python"
>>> print(f"我喜欢{name}编程！")
我喜欢Python编程！

在交互模式下，输入的代码会立即执行并显示结果。这对于快速测试代码片段非常方便。要退出交互模式，可以输入exit()或按Ctrl+D（Linux/macOS）或Ctrl+Z后回车（Windows）。

3.2 编写Python脚本文件

虽然交互模式很方便，但实际开发中我们通常将代码保存在文件中。Python脚本文件的扩展名是.py。

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

# 这是我的第一个Python程序
# 注释以#开头，不会被程序执行

print("Hello, World!")
print("欢迎来到Python的世界！")
print("让我们开始学习编程吧！")

在终端中运行这个脚本：

python3 hello.py

输出结果：

Hello, World!
欢迎来到Python的世界！
让我们开始学习编程吧！

3.3 理解print()函数

print()是Python中最常用的内置函数之一，用于在屏幕上输出信息。让我们更深入地了解它的用法：

# 输出字符串
print("这是一段文字")

# 输出数字
print(42)
print(3.14)

# 输出多个值，用逗号分隔
print("我的年龄是", 25, "岁")

# 使用sep参数指定分隔符
print("苹果", "香蕉", "橙子", sep=", ")
# 输出: 苹果, 香蕉, 橙子

# 使用end参数指定结尾字符
print("你好", end=" ")
print("世界")
# 输出: 你好 世界（在一行上）

# 输出空行
print()

3.4 理解注释

注释是代码中不会被执行的部分，用于解释代码的功能和逻辑。良好的注释习惯是优秀程序员的标志：

# 这是单行注释，以#开头
# 单行注释通常用于解释下一行代码的作用

"""
这是多行注释，使用三个引号包裹
多行注释可以跨越多行
通常用于描述函数、类或模块的功能
"""

print("注释不会影响程序执行")  # 行末注释也可以

# 好的注释示例
# 计算圆的面积，半径为5
radius = 5
area = 3.14159 * radius * radius

# 不好的注释示例（注释只是重复代码本身）
# 将5赋值给radius
radius = 5

3.5 理解缩进

Python使用缩进来表示代码块，这是Python最重要的语法规则之一。其他语言通常使用大括号{}来定义代码块，而Python使用空白字符（通常是4个空格或1个制表符）：

# 正确的缩进
if True:
    print("这行代码在if代码块内")
    print("这行也在if代码块内，缩进相同")
print("这行代码不在if代码块内")

# 错误的缩进会导致IndentationError
# if True:
# print("这行代码没有缩进，会报错")

重要提示：

统一使用4个空格作为缩进（这是Python社区的惯例）
不要混用空格和制表符，这会导致难以发现的错误
大多数代码编辑器可以设置为按Tab键自动插入4个空格

4. 变量与数据类型

4.1 什么是变量？

变量是程序中用来存储数据的容器。你可以把变量想象成一个贴了标签的盒子，标签就是变量名，盒子里装的东西就是变量的值。

在Python中创建变量非常简单：

# 创建变量并赋值
name = "小明"
age = 18
height = 1.75
is_student = True

# 输出变量的值
print(name)      # 输出: 小明
print(age)       # 输出: 18
print(height)    # 输出: 1.75
print(is_student) # 输出: True

4.2 变量命名规则

给变量命名时需要遵循以下规则：

# 合法的变量名
my_name = "小明"
myName = "小明"
_private = "私有变量"
name2 = "带数字的名字"
MAX_VALUE = 100  # 常量通常用全大写

# 非法的变量名（会报错）
# 2name = "错误"      # 不能以数字开头
# my-name = "错误"    # 不能包含连字符
# my name = "错误"    # 不能包含空格
# class = "错误"      # 不能使用Python关键字

命名建议：

使用有意义的名字，让人一看就知道变量的用途
Python中推荐使用小写字母加下划线的方式（snake_case）
常量使用全大写字母
避免使用单个字符作为变量名（循环变量i、j等除外）

# 好的命名
student_name = "小明"
total_price = 99.9
is_valid = True

# 不好的命名
a = "小明"      # 不知道a代表什么
tp = 99.9       # 缩写太简短

4.3 Python的基本数据类型

Python有几种基本的数据类型：

整数（int）：没有小数点的数字

age = 25
count = -10
big_number = 1000000
binary = 0b1010     # 二进制，等于10
octal = 0o17        # 八进制，等于15
hexadecimal = 0xFF  # 十六进制，等于255

print(type(age))    # 输出: <class 'int'>

浮点数（float）：有小数点的数字

height = 1.75
price = 99.9
temperature = -5.5
scientific = 1.5e2  # 科学计数法，等于150.0

print(type(height))  # 输出: <class 'float'>

字符串（str）：文本数据，用引号括起来

name = "小明"
message = '你好，世界！'
multiline = """这是
一个多行
字符串"""

print(type(name))    # 输出: <class 'str'>

布尔值（bool）：只有True和False两个值

is_student = True
is_rich = False

print(type(is_student))  # 输出: <class 'bool'>

None类型：表示空值或没有值

result = None
print(result)        # 输出: None
print(type(result))  # 输出: <class 'NoneType'>

4.4 类型转换

不同数据类型之间可以相互转换：

# 字符串转整数
age_str = "25"
age_int = int(age_str)
print(age_int)       # 输出: 25
print(type(age_int)) # 输出: <class 'int'>

# 整数转字符串
num = 100
num_str = str(num)
print(num_str)        # 输出: 100
print(type(num_str))  # 输出: <class 'str'>

# 字符串转浮点数
price_str = "99.9"
price = float(price_str)
print(price)          # 输出: 99.9

# 整数转浮点数
x = 10
y = float(x)
print(y)              # 输出: 10.0

# 浮点数转整数（会截断小数部分）
pi = 3.14
pi_int = int(pi)
print(pi_int)         # 输出: 3

# 布尔值转换
print(int(True))      # 输出: 1
print(int(False))     # 输出: 0
print(bool(1))        # 输出: True
print(bool(0))        # 输出: False
print(bool(""))       # 输出: False（空字符串为False）
print(bool("hello"))  # 输出: True（非空字符串为True）

4.5 动态类型

Python是动态类型语言，这意味着变量的类型可以在运行时改变：

x = 10          # x是整数
print(type(x))  # 输出: <class 'int'>

x = "Hello"     # x变成了字符串
print(type(x))  # 输出: <class 'str'>

x = 3.14        # x变成了浮点数
print(type(x))  # 输出: <class 'float'>

x = True        # x变成了布尔值
print(type(x))  # 输出: <class 'bool'>

这种灵活性是Python的特点之一，但也意味着程序员需要注意变量的类型，避免类型错误。

4.6 多重赋值

Python支持同时给多个变量赋值：

# 同时赋值多个变量
a, b, c = 1, 2, 3
print(a, b, c)  # 输出: 1 2 3

# 交换两个变量的值
x = 10
y = 20
x, y = y, x
print(x, y)     # 输出: 20 10

# 多个变量赋相同的值
a = b = c = 0
print(a, b, c)  # 输出: 0 0 0

5. 运算符

5.1 算术运算符

算术运算符用于执行基本的数学运算：

a = 15
b = 4

# 加法
print(a + b)    # 输出: 19

# 减法
print(a - b)    # 输出: 11

# 乘法
print(a * b)    # 输出: 60

# 除法（结果是浮点数）
print(a / b)    # 输出: 3.75

# 整数除法（向下取整）
print(a // b)   # 输出: 3

# 取余数（模运算）
print(a % b)    # 输出: 3

# 幂运算
print(a ** b)   # 输出: 50625（15的4次方）

实际应用示例：

# 计算购物总价
price = 89.9     # 单价
quantity = 3     # 数量
total = price * quantity
print(f"总价: {total}元")  # 输出: 总价: 269.7元

# 计算平均分
chinese = 85
math = 92
english = 78
average = (chinese + math + english) / 3
print(f"平均分: {average:.1f}")  # 输出: 平均分: 85.0

# 判断奇偶数
number = 7
remainder = number % 2
if remainder == 0:
    print(f"{number}是偶数")
else:
    print(f"{number}是奇数")

5.2 比较运算符

比较运算符用于比较两个值，返回布尔值True或False：

x = 10
y = 20

print(x == y)   # 等于，输出: False
print(x != y)   # 不等于，输出: True
print(x > y)    # 大于，输出: False
print(x < y)    # 小于，输出: True
print(x >= y)   # 大于等于，输出: False
print(x <= y)   # 小于等于，输出: True

字符串比较：

# 字符串按字典顺序比较
print("apple" < "banana")   # 输出: True
print("abc" == "abc")       # 输出: True
print("abc" < "abd")        # 输出: True

5.3 逻辑运算符

逻辑运算符用于组合多个条件：

a = True
b = False

# and：两个条件都为True时结果才为True
print(a and b)   # 输出: False
print(a and True) # 输出: True

# or：至少一个条件为True时结果就为True
print(a or b)    # 输出: True
print(False or False)  # 输出: False

# not：取反
print(not a)     # 输出: False
print(not b)     # 输出: True

实际应用示例：

age = 25
income = 8000

# 判断是否可以申请信用卡
if age >= 18 and income >= 5000:
    print("可以申请信用卡")
else:
    print("暂不满足申请条件")

# 判断是否为周末
day = "周六"
if day == "周六" or day == "周日":
    print("今天是周末，可以休息！")
else:
    print("今天是工作日，需要上班。")

5.4 赋值运算符

赋值运算符用于给变量赋值：

x = 10       # 基本赋值

x += 5       # 等价于 x = x + 5，x现在是15
print(x)

x -= 3       # 等价于 x = x - 3，x现在是12
print(x)

x *= 2       # 等价于 x = x * 2，x现在是24
print(x)

x /= 4       # 等价于 x = x / 4，x现在是6.0
print(x)

x //= 2      # 等价于 x = x // 2，x现在是3.0
print(x)

x **= 3      # 等价于 x = x ** 3，x现在是27.0
print(x)

x %= 5       # 等价于 x = x % 5，x现在是2.0
print(x)

5.5 成员运算符

成员运算符用于判断某个值是否存在于序列中：

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

# in：判断是否在序列中
print("苹果" in fruits)      # 输出: True
print("西瓜" in fruits)      # 输出: False

# not in：判断是否不在序列中
print("西瓜" not in fruits)  # 输出: True
print("苹果" not in fruits)  # 输出: False

# 也可以用于字符串
message = "Hello, Python!"
print("Python" in message)   # 输出: True
print("java" in message)     # 输出: False

5.6 身份运算符

身份运算符用于比较两个对象的内存地址是否相同：

a = [1, 2, 3]
b = [1, 2, 3]
c = a

# is：判断两个变量是否引用同一个对象
print(a is c)       # 输出: True（c引用了a指向的对象）
print(a is b)       # 输出: False（a和b是不同的对象，即使值相同）

# is not：判断两个变量是否引用不同的对象
print(a is not b)   # 输出: True

# 注意：is比较的是内存地址，==比较的是值
print(a == b)       # 输出: True（值相同）
print(a is b)       # 输出: False（内存地址不同）

5.7 运算符优先级

当表达式中有多个运算符时，Python会按照优先级顺序进行计算：

# 优先级从高到低：
# 1. 括号 ()
# 2. 幂运算 **
# 3. 正负号 +x, -x
# 4. 乘除 *, /, //, %
# 5. 加减 +, -
# 6. 比较运算符 ==, !=, <, >, <=, >=
# 7. 逻辑运算符 not, and, or

# 示例
result = 2 + 3 * 4      # 乘法优先，结果是14
print(result)

result = (2 + 3) * 4    # 括号优先，结果是20
print(result)

result = 2 ** 3 ** 2    # 幂运算右结合，等于2 ** (3 ** 2) = 2 ** 9 = 512
print(result)

6. 字符串操作

6.1 创建字符串

字符串是Python中最常用的数据类型之一。可以用单引号、双引号或三引号来创建字符串：

# 单引号
name = '小明'

# 双引号
message = "Hello, Python!"

# 三引号（可以包含换行符）
multiline = """这是第一行
这是第二行
这是第三行"""

# 字符串中包含引号
quote1 = "他说：'你好！'"
quote2 = '他说："你好！"'
quote3 = """他说：'你好！' "欢迎！" """

print(name)
print(message)
print(multiline)
print(quote1)
print(quote2)

6.2 字符串索引和切片

字符串中的每个字符都有一个索引（位置编号），可以通过索引来访问单个字符或子字符串：

text = "Hello, Python!"

# 正向索引（从0开始）
print(text[0])     # 输出: H
print(text[7])     # 输出: P
print(text[-1])    # 输出: !（负索引从末尾开始）
print(text[-5])    # 输出: h

# 切片操作：text[start:end:step]
print(text[0:5])   # 输出: Hello（索引0到4）
print(text[7:13])  # 输出: Python
print(text[:5])    # 输出: Hello（省略start表示从开头）
print(text[7:])    # 输出: Python!（省略end表示到末尾）
print(text[:])     # 输出: Hello, Python!（完整复制）
print(text[::2])   # 输出: Hlo yhn（每隔一个字符取一个）
print(text[::-1])  # 输出: !nohtyP ,olleH（反转字符串）

6.3 字符串常用方法

Python提供了丰富的字符串方法：

text = "  Hello, Python World!  "

# 去除首尾空白
print(text.strip())       # 输出: Hello, Python World!
print(text.lstrip())      # 输出: Hello, Python World!   （只去左边）
print(text.rstrip())      # 输出:   Hello, Python World!（只去右边）

# 大小写转换
print(text.lower())       # 全部转小写
print(text.upper())       # 全部转大写
print(text.title())       # 每个单词首字母大写
print(text.capitalize())  # 只有第一个字母大写

# 查找和替换
print(text.find("Python"))      # 输出: 9（返回首次出现的位置）
print(text.find("Java"))        # 输出: -1（未找到返回-1）
print(text.count("l"))          # 输出: 2（统计出现次数）
print(text.replace("Python", "Java"))  # 替换子字符串

# 判断方法
print("hello".isalpha())    # 输出: True（是否全是字母）
print("12345".isdigit())    # 输出: True（是否全是数字）
print("hello123".isalnum()) # 输出: True（是否全是字母或数字）
print("  ".isspace())       # 输出: True（是否全是空白字符）
print("Hello".startswith("He"))  # 输出: True
print("Hello".endswith("lo"))    # 输出: True

6.4 字符串格式化

Python提供了多种字符串格式化方式：

f-string（推荐）：

name = "小明"
age = 18
score = 95.5

# 基本用法
print(f"我叫{name}，今年{age}岁")

# 表达式
print(f"明年{age + 1}岁")

# 格式化数字
print(f"分数: {score:.1f}")      # 保留1位小数: 95.5
print(f"百分比: {0.856:.1%}")    # 百分比格式: 85.6%
print(f"补零: {42:05d}")         # 5位数补零: 00042

# 对齐
print(f"{'左对齐':<10}")         # 左对齐，宽度10
print(f"{'右对齐':>10}")         # 右对齐，宽度10
print(f"{'居中':^10}")           # 居中，宽度10

format()方法：

# 位置参数
print("我叫{}，今年{}岁".format("小明", 18))

# 索引参数
print("我叫{0}，今年{1}岁，我是{0}".format("小明", 18))

# 关键字参数
print("我叫{name}，今年{age}岁".format(name="小明", age=18))

%格式化（旧式）：

name = "小明"
age = 18
print("我叫%s，今年%d岁" % (name, age))

6.5 字符串拼接和分割

# 拼接
first = "Hello"
second = "World"
result = first + " " + second
print(result)  # 输出: Hello World

# 使用join拼接
words = ["Python", "是", "一门", "优秀的", "语言"]
sentence = " ".join(words)
print(sentence)  # 输出: Python 是一门 优秀的 语言

# 分割
text = "苹果,香蕉,橙子,葡萄"
fruits = text.split(",")
print(fruits)  # 输出: ['苹果', '香蕉', '橙子', '葡萄']

# 按行分割
multiline = "第一行\n第二行\n第三行"
lines = multiline.splitlines()
print(lines)  # 输出: ['第一行', '第二行', '第三行']

6.6 转义字符

转义字符用于表示一些特殊字符：

# 换行符 \n
print("第一行\n第二行")

# 制表符 \t
print("姓名\t年龄\t城市")
print("小明\t18\t北京")

# 反斜杠 \\
print("路径: C:\\Users\\Desktop")

# 引号
print("他说：\"你好！\"")
print('他说：\'你好！\'')

# 原始字符串（忽略转义）
print(r"C:\Users\new\test")  # 输出: C:\Users\new\test

7. 列表、元组、字典、集合

7.1 列表（list）

列表是Python中最常用的数据结构，它可以存储多个值，并且可以随时添加、删除或修改元素。

创建列表：

# 创建空列表
empty_list = []
empty_list2 = list()

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

# 使用range创建数字列表
range_list = list(range(1, 11))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 列表推导式
squares = [x**2 for x in range(1, 6)]  # [1, 4, 9, 16, 25]

访问列表元素：

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

# 正向索引
print(fruits[0])     # 输出: 苹果
print(fruits[2])     # 输出: 橙子

# 负索引
print(fruits[-1])    # 输出: 西瓜
print(fruits[-2])    # 输出: 葡萄

# 切片
print(fruits[1:3])   # 输出: ['香蕉', '橙子']
print(fruits[:3])    # 输出: ['苹果', '香蕉', '橙子']
print(fruits[2:])    # 输出: ['橙子', '葡萄', '西瓜']
print(fruits[::-1])  # 输出: ['西瓜', '葡萄', '橙子', '香蕉', '苹果']（反转）

修改列表：

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

# 修改元素
fruits[0] = "草莓"
print(fruits)  # 输出: ['草莓', '香蕉', '橙子']

# 添加元素
fruits.append("葡萄")          # 在末尾添加
print(fruits)  # 输出: ['草莓', '香蕉', '橙子', '葡萄']

fruits.insert(1, "西瓜")       # 在指定位置插入
print(fruits)  # 输出: ['草莓', '西瓜', '香蕉', '橙子', '葡萄']

fruits.extend(["芒果", "荔枝"]) # 扩展列表
print(fruits)  # 输出: ['草莓', '西瓜', '香蕉', '橙子', '葡萄', '芒果', '荔枝']

# 删除元素
fruits.remove("香蕉")          # 删除指定元素
print(fruits)

popped = fruits.pop()          # 弹出最后一个元素
print(popped)  # 输出: 荔枝
print(fruits)

popped = fruits.pop(0)         # 弹出指定位置的元素
print(popped)  # 输出: 草莓

del fruits[0]                  # 删除指定位置的元素
print(fruits)

列表常用方法：

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

# 排序
numbers.sort()               # 原地排序（升序）
print(numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]

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

# 不修改原列表的排序
new_list = sorted(numbers)   # 返回新列表
print(new_list)

# 反转
numbers.reverse()
print(numbers)

# 统计和查找
print(numbers.count(5))      # 输出: 2（5出现的次数）
print(numbers.index(5))      # 输出: 2（5首次出现的位置）
print(len(numbers))          # 输出: 10（列表长度）
print(sum(numbers))          # 输出: 38（元素之和）
print(min(numbers))          # 输出: 1（最小值）
print(max(numbers))          # 输出: 9（最大值）

7.2 元组（tuple）

元组与列表类似，但元组是不可变的——一旦创建就不能修改。

# 创建元组
colors = ("红", "绿", "蓝")
single = (42,)  # 只有一个元素时需要加逗号
empty = ()

# 访问元素（与列表相同）
print(colors[0])      # 输出: 红
print(colors[-1])     # 输出: 蓝
print(colors[0:2])    # 输出: ('红', '绿')

# 元组是不可变的，以下操作会报错
# colors[0] = "黄"    # TypeError!

# 元组的常用方法
print(colors.count("红"))  # 输出: 1
print(colors.index("绿"))  # 输出: 1
print(len(colors))         # 输出: 3

# 元组解包
a, b, c = colors
print(a, b, c)  # 输出: 红 绿 蓝

# 什么时候用元组？
# 1. 数据不应被修改时（如坐标、日期）
# 2. 作为字典的键（列表不行）
# 3. 函数返回多个值时
point = (10, 20)
date = (2024, 1, 15)

7.3 字典（dict）

字典是键值对的集合，通过键来访问值。字典在Python中非常常用，适合存储具有映射关系的数据。

# 创建字典
student = {
    "name": "小明",
    "age": 18,
    "grade": "高三",
    "scores": {"语文": 85, "数学": 92, "英语": 78}
}

# 访问值
print(student["name"])       # 输出: 小明
print(student.get("age"))    # 输出: 18
print(student.get("phone", "未填写"))  # 键不存在时返回默认值

# 修改和添加
student["age"] = 19                    # 修改已有键
student["phone"] = "13800138000"       # 添加新键
print(student)

# 删除
del student["phone"]                   # 删除键值对
grade = student.pop("grade")           # 弹出并返回值
print(grade)  # 输出: 高三

# 检查键是否存在
print("name" in student)    # 输出: True
print("phone" in student)   # 输出: False

# 获取所有键、值、键值对
print(student.keys())       # 输出: dict_keys(['name', 'age', 'scores'])
print(student.values())     # 输出: dict_values(['小明', 19, {...}])
print(student.items())      # 输出: dict_items([('name', '小明'), ...])

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

# 字典推导式
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 合并字典
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
merged = {**dict1, **dict2}  # Python 3.5+
print(merged)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 或者使用update方法
dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

7.4 集合（set）

集合是无序的、不重复的元素集合，常用于去重和集合运算。

# 创建集合
fruits = {"苹果", "香蕉", "橙子", "苹果"}  # 重复元素会自动去除
print(fruits)  # 输出: {'苹果', '香蕉', '橙子'}

# 创建空集合（注意：{}创建的是空字典）
empty_set = set()

# 从列表创建集合（去重）
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique_numbers = set(numbers)
print(unique_numbers)  # 输出: {1, 2, 3, 4}

# 添加和删除
fruits.add("葡萄")
print(fruits)

fruits.remove("香蕉")     # 元素不存在会报错
fruits.discard("西瓜")    # 元素不存在不会报错

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

# 并集
print(set_a | set_b)       # 输出: {1, 2, 3, 4, 5, 6, 7, 8}
print(set_a.union(set_b))

# 交集
print(set_a & set_b)       # 输出: {4, 5}
print(set_a.intersection(set_b))

# 差集
print(set_a - set_b)       # 输出: {1, 2, 3}
print(set_a.difference(set_b))

# 对称差集（只在其中一个集合中出现的元素）
print(set_a ^ set_b)       # 输出: {1, 2, 3, 6, 7, 8}

# 判断子集和超集
set_c = {1, 2, 3}
print(set_c.issubset(set_a))    # 输出: True
print(set_a.issuperset(set_c))  # 输出: True

8. 条件语句

8.1 if语句

条件语句让程序能够根据不同的条件执行不同的代码：

# 基本的if语句
age = 18

if age >= 18:
    print("你已经成年了")
    print("可以考驾照了")

8.2 if-else语句

age = 15

if age >= 18:
    print("你已经成年了")
else:
    print("你还未成年")

8.3 if-elif-else语句

当有多个条件需要判断时，使用elif（else if的缩写）：

score = 85

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

print(f"成绩等级: {grade}")  # 输出: 成绩等级: 良好

8.4 嵌套条件

age = 25
has_id = True

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

8.5 三元表达式

Python支持简洁的三元表达式：

age = 20
status = "成年" if age >= 18 else "未成年"
print(status)  # 输出: 成年

# 等价于
if age >= 18:
    status = "成年"
else:
    status = "未成年"

8.6 条件语句的实际应用

# 实例1：判断闰年
year = 2024

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year}年是闰年")
else:
    print(f"{year}年不是闰年")

# 实例2：BMI计算器
height = 1.75  # 身高（米）
weight = 70    # 体重（公斤）

bmi = weight / (height ** 2)

if bmi < 18.5:
    print(f"BMI: {bmi:.1f}，体重过轻")
elif bmi < 24:
    print(f"BMI: {bmi:.1f}，体重正常")
elif bmi < 28:
    print(f"BMI: {bmi:.1f}，体重超重")
else:
    print(f"BMI: {bmi:.1f}，肥胖")

# 实例3：判断成绩等级并给出建议
score = 72

if score >= 90:
    print("优秀！继续保持！")
elif score >= 80:
    print("良好，再努力一点就能到优秀了！")
elif score >= 70:
    print("中等，还有进步空间。")
elif score >= 60:
    print("及格，需要加油了！")
else:
    print("不及格，建议重新学习相关内容。")

9. 循环语句

9.1 for循环

for循环用于遍历序列（如列表、元组、字符串、字典等）中的每个元素：

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

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

# 使用range()生成数字序列
# range(stop): 从0到stop-1
for i in range(5):
    print(i)  # 输出: 0, 1, 2, 3, 4

# range(start, stop): 从start到stop-1
for i in range(1, 6):
    print(i)  # 输出: 1, 2, 3, 4, 5

# range(start, stop, step): 指定步长
for i in range(0, 10, 2):
    print(i)  # 输出: 0, 2, 4, 6, 8

# 使用enumerate获取索引和值
fruits = ["苹果", "香蕉", "橙子"]
for index, fruit in enumerate(fruits):
    print(f"第{index + 1}个水果是{fruit}")

# 遍历字典
student = {"name": "小明", "age": 18, "grade": "高三"}
for key, value in student.items():
    print(f"{key}: {value}")

9.2 while循环

while循环在条件为True时重复执行代码块：

# 基本的while循环
count = 0
while count < 5:
    print(f"当前计数: {count}")
    count += 1

# 用户输入验证
while True:
    password = input("请输入密码: ")
    if password == "123456":
        print("密码正确！")
        break
    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：立即终止循环

# 找到第一个能被7整除的数
for i in range(1, 100):
    if i % 7 == 0:
        print(f"第一个能被7整除的数是: {i}")
        break

# 输出: 第一个能被7整除的数是: 7

continue：跳过当前迭代，继续下一次循环

# 只打印奇数
for i in range(1, 11):
    if i % 2 == 0:
        continue  # 跳过偶数
    print(i)
# 输出: 1, 3, 5, 7, 9

9.4 for-else和while-else

Python的循环可以有一个else子句，当循环正常结束（没有被break中断）时执行：

# 查找质数
for num in range(2, 20):
    for i in range(2, num):
        if num % i == 0:
            print(f"{num}不是质数，因为{num} = {i} * {num // i}")
            break
    else:
        print(f"{num}是质数")

9.5 嵌套循环

循环可以嵌套使用：

# 打印乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}×{i}={i*j}", end="\t")
    print()  # 换行

# 打印三角形
rows = 5
for i in range(1, rows + 1):
    print(" " * (rows - i) + "*" * (2 * i - 1))

# 打印九九乘法表（完整版）
print("九九乘法表:")
print("=" * 50)
for i in range(1, 10):
    for j in range(1, 10):
        print(f"{i}×{j}={i*j:2d}", end="  ")
    print()

9.6 列表推导式

列表推导式是Python中创建列表的简洁方式：

# 基本语法：[表达式 for 变量 in 可迭代对象]
squares = [x**2 for x in range(1, 11)]
print(squares)  # 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

# 嵌套的列表推导式
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]

# 字典推导式
squares_dict = {x: x**2 for x in range(1, 6)}
print(squares_dict)  # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 集合推导式
even_set = {x for x in range(1, 11) if x % 2 == 0}
print(even_set)  # 输出: {2, 4, 6, 8, 10}

9.7 循环的实际应用

# 实例1：猜数字游戏
import random

secret = random.randint(1, 100)
attempts = 0

print("欢迎来到猜数字游戏！")
print("我已经想好了一个1到100之间的数字。")

while True:
    guess = int(input("请猜一个数字: "))
    attempts += 1

    if guess < secret:
        print("太小了！再大一点。")
    elif guess > secret:
        print("太大了！再小一点。")
    else:
        print(f"恭喜你猜对了！答案就是{secret}")
        print(f"你一共猜了{attempts}次")
        break

# 实例2：统计字符出现次数
text = "hello world python programming"
char_count = {}

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

print("字符统计结果:")
for char, count in sorted(char_count.items()):
    print(f"'{char}': {count}次")

# 实例3：斐波那契数列
def fibonacci(n):
    """生成前n个斐波那契数"""
    fib = [0, 1]
    for i in range(2, n):
        fib.append(fib[i-1] + fib[i-2])
    return fib[:n]

print(fibonacci(10))
# 输出: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

10. 函数定义与调用

10.1 什么是函数？

函数是一段可重用的代码块，用于执行特定的任务。使用函数可以避免重复编写相同的代码，使程序更加模块化和易于维护。

10.2 定义和调用函数

# 定义函数
def greet(name):
    """向某人打招呼（这是文档字符串，描述函数的功能）"""
    print(f"你好，{name}！欢迎学习Python！")

# 调用函数
greet("小明")   # 输出: 你好，小明！欢迎学习Python！
greet("小红")   # 输出: 你好，小红！欢迎学习Python！

# 查看文档字符串
print(greet.__doc__)  # 输出: 向某人打招呼（这是文档字符串，描述函数的功能）

10.3 函数参数

# 位置参数
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 describe_pet(name, animal_type):
    print(f"我有一只{animal_type}，它叫{name}")

describe_pet(animal_type="猫", name="咪咪")  # 顺序可以不同

# 可变位置参数 *args
def calculate_sum(*numbers):
    """计算任意个数字的和"""
    total = 0
    for num in numbers:
        total += num
    return total

print(calculate_sum(1, 2, 3))        # 输出: 6
print(calculate_sum(1, 2, 3, 4, 5))  # 输出: 15

# 可变关键字参数 **kwargs
def print_info(**info):
    """打印任意个键值对信息"""
    for key, value in info.items():
        print(f"{key}: {value}")

print_info(name="小明", age=18, city="北京")

# 参数组合
def func(a, b, *args, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"kwargs={kwargs}")

func(1, 2, 3, 4, x=5, y=6)

10.4 返回值

# 返回单个值
def square(x):
    return x ** 2

result = square(5)
print(result)  # 输出: 25

# 返回多个值
def get_min_max(numbers):
    return min(numbers), max(numbers)

minimum, maximum = get_min_max([3, 1, 4, 1, 5, 9])
print(f"最小值: {minimum}, 最大值: {maximum}")

# 没有return语句的函数返回None
def print_message(msg):
    print(msg)

result = print_message("Hello")
print(result)  # 输出: None

# 提前返回
def divide(a, b):
    if b == 0:
        return "错误：除数不能为零"
    return a / b

print(divide(10, 3))   # 输出: 3.3333333333333335
print(divide(10, 0))   # 输出: 错误：除数不能为零

10.5 变量作用域

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

def func():
    x = 20  # 局部变量（与全局变量同名但互不影响）
    print(f"函数内的x: {x}")

func()           # 输出: 函数内的x: 20
print(f"函数外的x: {x}")  # 输出: 函数外的x: 10

# 使用global关键字修改全局变量
count = 0

def increment():
    global count
    count += 1

increment()
increment()
print(count)  # 输出: 2

# 嵌套函数和nonlocal
def outer():
    x = 10
    def inner():
        nonlocal x
        x += 1
        print(f"inner中的x: {x}")
    inner()
    print(f"outer中的x: {x}")

outer()

10.6 Lambda函数

Lambda函数是匿名的、单行的小函数：

# 基本语法：lambda 参数: 表达式
square = lambda x: x ** 2
print(square(5))  # 输出: 25

add = lambda a, b: a + b
print(add(3, 5))  # 输出: 8

# 常见用途：作为排序的key参数
students = [
    ("小明", 85),
    ("小红", 92),
    ("小华", 78)
]

# 按成绩排序
students.sort(key=lambda s: s[1])
print(students)

# 按成绩降序排序
students.sort(key=lambda s: s[1], reverse=True)
print(students)

# 与map、filter等函数配合使用
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4]

10.7 递归函数

递归函数是调用自身的函数，常用于解决可以分解为相似子问题的问题：

# 计算阶乘
def factorial(n):
    """计算n的阶乘"""
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 输出: 120 (5! = 5 × 4 × 3 × 2 × 1)

# 斐波那契数列（递归）
def fibonacci(n):
    """返回第n个斐波那契数"""
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

for i in range(10):
    print(fibonacci(i), end=" ")
print()  # 输出: 0 1 1 2 3 5 8 13 21 34

# 注意：递归深度有限制，过深的递归会导致RecursionError
# Python默认递归深度限制约为1000层

10.8 函数的实际应用

# 实例1：温度转换
def celsius_to_fahrenheit(celsius):
    """摄氏度转华氏度"""
    return celsius * 9 / 5 + 32

def fahrenheit_to_celsius(fahrenheit):
    """华氏度转摄氏度"""
    return (fahrenheit - 32) * 5 / 9

# 测试
print(f"100°C = {celsius_to_fahrenheit(100):.1f}°F")  # 输出: 212.0°F
print(f"212°F = {fahrenheit_to_celsius(212):.1f}°C")  # 输出: 100.0°C

# 实例2：密码强度检测
def check_password_strength(password):
    """检测密码强度"""
    strength = 0
    feedback = []

    if len(password) >= 8:
        strength += 1
    else:
        feedback.append("密码长度应至少8位")

    if any(c.isupper() for c in password):
        strength += 1
    else:
        feedback.append("应包含大写字母")

    if any(c.islower() for c in password):
        strength += 1
    else:
        feedback.append("应包含小写字母")

    if any(c.isdigit() for c in password):
        strength += 1
    else:
        feedback.append("应包含数字")

    if any(c in "!@#$%^&*()_+-=" for c in password):
        strength += 1
    else:
        feedback.append("应包含特殊字符")

    levels = ["非常弱", "弱", "一般", "强", "非常强"]
    return levels[strength], feedback

level, suggestions = check_password_strength("Abc123!")
print(f"密码强度: {level}")
if suggestions:
    print("改进建议:")
    for s in suggestions:
        print(f"  - {s}")

# 实例3：统计文本信息
def analyze_text(text):
    """分析文本的基本信息"""
    words = text.split()
    sentences = text.count('.') + text.count('!') + text.count('?')

    return {
        "字符数": len(text),
        "单词数": len(words),
        "句子数": sentences,
        "平均单词长度": sum(len(w) for w in words) / len(words) if words else 0
    }

text = "Python is great. It is easy to learn. Many people love it!"
result = analyze_text(text)
for key, value in result.items():
    if isinstance(value, float):
        print(f"{key}: {value:.1f}")
    else:
        print(f"{key}: {value}")

11. 模块与包

11.1 什么是模块？

模块是一个包含Python代码的文件（以.py为扩展名）。使用模块可以将代码组织成可重用的单元，避免所有代码都写在一个文件中。

11.2 导入模块

# 导入整个模块
import math
print(math.pi)        # 输出: 3.141592653589793
print(math.sqrt(16))  # 输出: 4.0

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

# 导入并重命名
import math as m
print(m.pi)

from math import sqrt as square_root
print(square_root(16))

# 导入模块中的所有内容（不推荐，可能导致命名冲突）
from math import *

11.3 常用标准库模块

# os模块：操作系统相关功能
import os
print(os.getcwd())           # 获取当前工作目录
print(os.listdir("."))       # 列出当前目录的文件
print(os.path.exists("test.txt"))  # 判断文件是否存在

# sys模块：系统相关功能
import sys
print(sys.version)           # Python版本
print(sys.platform)          # 操作系统平台
print(sys.path)              # 模块搜索路径

# datetime模块：日期和时间
from datetime import datetime, timedelta
now = datetime.now()
print(f"当前时间: {now}")
print(f"年: {now.year}, 月: {now.month}, 日: {now.day}")
print(f"时: {now.hour}, 分: {now.minute}, 秒: {now.second}")

# 计算明天的日期
tomorrow = now + timedelta(days=1)
print(f"明天: {tomorrow.strftime('%Y-%m-%d')}")

# random模块：随机数
import random
print(random.random())          # 0到1之间的随机浮点数
print(random.randint(1, 100))   # 1到100之间的随机整数
print(random.choice(["苹果", "香蕉", "橙子"]))  # 随机选择一个元素

items = [1, 2, 3, 4, 5]
random.shuffle(items)           # 随机打乱列表
print(items)

# json模块：JSON数据处理
import json
data = {"name": "小明", "age": 18}
json_str = json.dumps(data, ensure_ascii=False)
print(json_str)  # 输出: {"name": "小明", "age": 18}

parsed = json.loads(json_str)
print(parsed["name"])  # 输出: 小明

# collections模块：高级数据结构
from collections import Counter, defaultdict

# Counter：计数器
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
counter = Counter(words)
print(counter)  # 输出: Counter({'apple': 3, 'banana': 2, 'cherry': 1})
print(counter.most_common(2))  # 输出: [('apple', 3), ('banana', 2)]

11.4 创建自己的模块

创建一个名为myutils.py的文件：

# myutils.py
"""我的工具模块"""

def greet(name):
    """打招呼"""
    return f"你好，{name}！"

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

def is_even(n):
    """判断是否为偶数"""
    return n % 2 == 0

# 模块级别的变量
VERSION = "1.0.0"

在另一个文件中使用这个模块：

# main.py
import myutils

print(myutils.greet("小明"))     # 输出: 你好，小明！
print(myutils.add(3, 5))        # 输出: 8
print(myutils.is_even(4))       # 输出: True
print(myutils.VERSION)          # 输出: 1.0.0

# 或者导入特定函数
from myutils import greet, add
print(greet("小红"))

11.5 包（Package）

包是包含多个模块的文件夹，其中必须包含一个__init__.py文件（可以是空文件）。

mypackage/
    __init__.py
    module1.py
    module2.py
    subpackage/
        __init__.py
        module3.py

# 导入包中的模块
from mypackage import module1
from mypackage.module2 import some_function
from mypackage.subpackage.module3 import another_function

11.6 使用pip安装第三方库

# 安装库
pip3 install requests

# 安装指定版本
pip3 install requests==2.28.0

# 升级库
pip3 install --upgrade requests

# 查看已安装的库
pip3 list

# 查看库的详细信息
pip3 show requests

# 导出依赖
pip3 freeze > requirements.txt

# 从文件安装依赖
pip3 install -r requirements.txt

# 卸载库
pip3 uninstall requests

12. 文件操作

12.1 打开和关闭文件

# 基本的文件操作
# 写入文件
file = open("test.txt", "w", encoding="utf-8")
file.write("Hello, Python!\n")
file.write("这是第二行\n")
file.close()

# 读取文件
file = open("test.txt", "r", encoding="utf-8")
content = file.read()
print(content)
file.close()

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

12.2 文件打开模式

# 'r'：只读模式（默认）
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()

# 'w'：写入模式（会覆盖原文件）
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("覆盖原内容")

# 'a'：追加模式（在文件末尾添加内容）
with open("test.txt", "a", encoding="utf-8") as f:
    f.write("追加的内容\n")

# 'r+'：读写模式
with open("test.txt", "r+", encoding="utf-8") as f:
    content = f.read()
    f.write("追加的内容")

# 'b'：二进制模式
with open("image.jpg", "rb") as f:
    binary_content = f.read()

with open("copy.jpg", "wb") as f:
    f.write(binary_content)

12.3 读取文件的不同方式

# 准备测试文件
with open("sample.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n第二行\n第三行\n第四行\n第五行")

# 方式1：read()读取整个文件
with open("sample.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# 方式2：readline()逐行读取
with open("sample.txt", "r", encoding="utf-8") as f:
    line = f.readline()
    while line:
        print(line.strip())  # strip()去除行末的换行符
        line = f.readline()

# 方式3：readlines()读取所有行到列表
with open("sample.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    print(lines)  # 输出: ['第一行\n', '第二行\n', ...]

# 方式4：直接遍历文件对象（推荐，内存效率高）
with open("sample.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

12.4 文件指针操作

with open("sample.txt", "r", encoding="utf-8") as f:
    # tell()：返回当前文件指针位置
    print(f.tell())  # 输出: 0

    content = f.read(5)
    print(content)
    print(f.tell())  # 输出: 读取5个字符后的位置

    # seek()：移动文件指针
    f.seek(0)        # 移回文件开头
    print(f.tell())  # 输出: 0

12.5 使用pathlib模块

pathlib是Python 3.4引入的面向对象的文件系统路径库：

from pathlib import Path

# 创建路径对象
p = Path(".")

# 列出当前目录的文件
for item in p.iterdir():
    print(item)

# 创建目录
new_dir = Path("new_folder")
new_dir.mkdir(exist_ok=True)

# 创建文件并写入
file_path = new_dir / "test.txt"
file_path.write_text("Hello, pathlib!", encoding="utf-8")

# 读取文件
content = file_path.read_text(encoding="utf-8")
print(content)

# 判断文件/目录是否存在
print(file_path.exists())    # True
print(file_path.is_file())   # True
print(file_path.is_dir())    # False

# 获取文件信息
print(file_path.name)        # test.txt
print(file_path.suffix)      # .txt
print(file_path.stem)        # test
print(file_path.parent)      # new_folder

# 查找文件
txt_files = list(Path(".").rglob("*.txt"))
print(txt_files)

12.6 CSV文件操作

import csv

# 写入CSV文件
data = [
    ["姓名", "年龄", "城市"],
    ["小明", 18, "北京"],
    ["小红", 20, "上海"],
    ["小华", 19, "广州"]
]

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)

# 使用字典方式读写
with open("students.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"姓名: {row['姓名']}, 年龄: {row['年龄']}, 城市: {row['城市']}")

12.7 JSON文件操作

import json

# 写入JSON文件
data = {
    "students": [
        {"name": "小明", "age": 18, "scores": [85, 92, 78]},
        {"name": "小红", "age": 20, "scores": [90, 88, 95]}
    ]
}

with open("students.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=4)

# 读取JSON文件
with open("students.json", "r", encoding="utf-8") as f:
    loaded_data = json.load(f)
    print(loaded_data)
    for student in loaded_data["students"]:
        print(f"{student['name']}: {student['scores']}")

13. 异常处理

13.1 什么是异常？

异常是程序运行时发生的错误。如果不处理异常，程序会崩溃。Python提供了try-except语句来捕获和处理异常。

13.2 常见的异常类型

# ZeroDivisionError：除以零
# result = 10 / 0

# TypeError：类型错误
# result = "hello" + 5

# ValueError：值错误
# num = int("abc")

# IndexError：索引越界
# lst = [1, 2, 3]
# print(lst[10])

# KeyError：键错误
# d = {"name": "小明"}
# print(d["age"])

# FileNotFoundError：文件不存在
# f = open("nonexistent.txt")

# AttributeError：属性错误
# "hello".append("!")

# ImportError：导入错误
# import nonexistent_module

13.3 try-except语句

# 基本的try-except
try:
    result = 10 / 0
except ZeroDivisionError:
    print("错误：除数不能为零！")

# 捕获多种异常
try:
    num = int(input("请输入一个数字: "))
    result = 100 / num
    print(f"100 / {num} = {result}")
except ValueError:
    print("输入的不是有效的数字！")
except ZeroDivisionError:
    print("除数不能为零！")

# 使用as获取异常信息
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"发生错误: {e}")

# 捕获所有异常（不推荐过度使用）
try:
    # 一些可能出错的代码
    pass
except Exception as e:
    print(f"发生错误: {e}")

13.4 try-except-else-finally

try:
    num = int(input("请输入数字: "))
    result = 100 / num
except ValueError:
    print("输入无效！")
except ZeroDivisionError:
    print("不能除以零！")
else:
    # 没有异常时执行
    print(f"结果是: {result}")
finally:
    # 无论是否发生异常都会执行
    print("程序执行完毕")

13.5 抛出异常

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

try:
    validate_age(-5)
except ValueError as e:
    print(f"验证失败: {e}")

try:
    validate_age("abc")
except TypeError as e:
    print(f"类型错误: {e}")

13.6 自定义异常

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(f"错误: {e}")
    print(f"还差{e.amount - e.balance}元")

13.7 异常处理的最佳实践

# 1. 只捕获你能够处理的异常
# 不好的做法
try:
    result = some_operation()
except Exception:
    pass  # 吞掉所有异常，隐藏问题

# 好的做法
try:
    result = some_operation()
except ValueError as e:
    log_error(e)
    result = default_value

# 2. 使用具体的异常类型
# 不好的做法
try:
    file = open("data.txt")
except Exception:
    print("出错了")

# 好的做法
try:
    file = open("data.txt")
except FileNotFoundError:
    print("文件不存在")
except PermissionError:
    print("没有权限访问文件")

# 3. 保持try块尽可能小
# 不好的做法
try:
    data = read_file()
    processed = process_data(data)
    save_result(processed)
except Exception:
    print("出错了")

# 好的做法
try:
    data = read_file()
except FileNotFoundError:
    print("文件不存在")
    return

try:
    processed = process_data(data)
except ValueError as e:
    print(f"数据处理错误: {e}")
    return

try:
    save_result(processed)
except IOError:
    print("保存失败")

14. 面向对象编程基础

14.1 什么是面向对象编程？

面向对象编程（OOP）是一种编程范式，它将数据和操作数据的方法组织在一起，形成"对象"。OOP的三大特性是封装、继承和多态。

14.2 定义类和创建对象

class Dog:
    """狗狗类"""

    # 类变量（所有实例共享）
    species = "犬科"

    def __init__(self, name, age):
        """初始化方法（构造函数）"""
        # 实例变量（每个实例独有）
        self.name = name
        self.age = age

    def bark(self):
        """实例方法"""
        return f"{self.name}说：汪汪！"

    def get_info(self):
        return f"名字: {self.name}, 年龄: {self.age}岁"

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

# 访问属性和方法
print(dog1.name)          # 输出: 旺财
print(dog1.bark())        # 输出: 旺财说：汪汪！
print(dog2.get_info())    # 输出: 名字: 小白, 年龄: 2岁
print(Dog.species)        # 输出: 犬科

14.3 封装

封装是将数据和方法包装在一起，并控制对它们的访问：

class Student:
    def __init__(self, name, score):
        self.name = name          # 公有属性
        self.__score = score      # 私有属性（双下划线开头）

    def get_score(self):
        """获取成绩（getter）"""
        return self.__score

    def set_score(self, score):
        """设置成绩（setter）"""
        if 0 <= score <= 100:
            self.__score = score
        else:
            print("成绩必须在0到100之间")

    def get_grade(self):
        """根据成绩返回等级"""
        if self.__score >= 90:
            return "优秀"
        elif self.__score >= 80:
            return "良好"
        elif self.__score >= 70:
            return "中等"
        elif self.__score >= 60:
            return "及格"
        else:
            return "不及格"

student = Student("小明", 85)
print(student.name)           # 输出: 小明
print(student.get_score())    # 输出: 85
print(student.get_grade())    # 输出: 良好

student.set_score(95)
print(student.get_score())    # 输出: 95

# student.__score  # 这会报错，因为__score是私有属性

14.4 继承

继承允许我们基于已有的类创建新类，新类继承父类的属性和方法：

class Animal:
    """动物基类"""
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

    def speak(self):
        return f"{self.name}说：{self.sound}"

class Cat(Animal):
    """猫类，继承自Animal"""
    def __init__(self, name, color):
        super().__init__(name, "喵")  # 调用父类的__init__
        self.color = color

    def purr(self):
        return f"{self.name}在打呼噜..."

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

    def fetch(self, item):
        return f"{self.name}去捡{item}了！"

# 创建对象
cat = Cat("咪咪", "白色")
dog = Dog("旺财", "金毛")

# 调用继承的方法
print(cat.speak())    # 输出: 咪咪说：喵
print(dog.speak())    # 输出: 旺财说：汪

# 调用子类特有的方法
print(cat.purr())     # 输出: 咪咪在打呼噜...
print(dog.fetch("球")) # 输出: 旺财去捡球了！

# 判断继承关系
print(isinstance(cat, Cat))      # True
print(isinstance(cat, Animal))   # True
print(isinstance(dog, Dog))      # True
print(isinstance(dog, Animal))   # True

14.5 多态

多态是指不同的类可以有相同的方法名，但行为不同：

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

# 多态的体现：同样的方法调用，不同的行为
shapes = [Circle(5), Rectangle(4, 6), Triangle(3, 8)]

for shape in shapes:
    print(f"{shape.__class__.__name__}的面积: {shape.area():.2f}")

# 输出:
# Circle的面积: 78.54
# Rectangle的面积: 24.00
# Triangle的面积: 12.00

14.6 魔术方法

Python的类有很多特殊的方法（以双下划线开头和结尾），称为魔术方法或dunder方法：

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        """定义print()输出的内容"""
        return f"Point({self.x}, {self.y})"

    def __repr__(self):
        """定义在解释器中的显示内容"""
        return f"Point({self.x}, {self.y})"

    def __eq__(self, other):
        """定义==比较"""
        return self.x == other.x and self.y == other.y

    def __add__(self, other):
        """定义+运算"""
        return Point(self.x + other.x, self.y + other.y)

    def __len__(self):
        """定义len()函数的行为"""
        return int((self.x ** 2 + self.y ** 2) ** 0.5)

    def __getitem__(self, index):
        """定义索引访问"""
        if index == 0:
            return self.x
        elif index == 1:
            return self.y
        raise IndexError("索引超出范围")

# 使用魔术方法
p1 = Point(3, 4)
p2 = Point(1, 2)

print(p1)           # 输出: Point(3, 4)
print(p1 == p2)     # 输出: False
print(p1 + p2)      # 输出: Point(4, 6)
print(len(p1))      # 输出: 5（到原点的距离）
print(p1[0])        # 输出: 3
print(p1[1])        # 输出: 4

14.7 面向对象的实际应用

class BankAccount:
    """银行账户类"""

    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance
        self.__transactions = []

    def deposit(self, amount):
        """存款"""
        if amount <= 0:
            print("存款金额必须大于0")
            return
        self.__balance += amount
        self.__transactions.append(f"存入: +{amount}")
        print(f"成功存入{amount}元，当前余额: {self.__balance}元")

    def withdraw(self, amount):
        """取款"""
        if amount <= 0:
            print("取款金额必须大于0")
            return
        if amount > self.__balance:
            print("余额不足")
            return
        self.__balance -= amount
        self.__transactions.append(f"取出: -{amount}")
        print(f"成功取出{amount}元，当前余额: {self.__balance}元")

    def get_balance(self):
        """查询余额"""
        return self.__balance

    def get_transactions(self):
        """查询交易记录"""
        return self.__transactions.copy()

    def __str__(self):
        return f"账户持有人: {self.owner}, 余额: {self.__balance}元"

# 使用银行账户类
account = BankAccount("小明", 1000)
print(account)

account.deposit(500)
account.withdraw(200)
account.withdraw(2000)  # 余额不足

print(f"\n当前余额: {account.get_balance()}元")
print("\n交易记录:")
for t in account.get_transactions():
    print(f"  {t}")

15. 常用内置函数

15.1 类型转换函数

# int()：转换为整数
print(int("123"))       # 123
print(int(3.99))        # 3（截断小数部分）
print(int(True))        # 1

# float()：转换为浮点数
print(float("3.14"))    # 3.14
print(float(42))        # 42.0

# str()：转换为字符串
print(str(123))         # "123"
print(str(3.14))        # "3.14"
print(str(True))        # "True"

# bool()：转换为布尔值
print(bool(0))          # False
print(bool(1))          # True
print(bool(""))         # False
print(bool("hello"))    # True
print(bool([]))         # False
print(bool([1, 2]))     # True

# list()：转换为列表
print(list("hello"))    # ['h', 'e', 'l', 'l', 'o']
print(list(range(5)))   # [0, 1, 2, 3, 4]

# tuple()：转换为元组
print(tuple([1, 2, 3])) # (1, 2, 3)

# set()：转换为集合
print(set([1, 2, 2, 3])) # {1, 2, 3}

# dict()：创建字典
print(dict([("a", 1), ("b", 2)]))  # {'a': 1, 'b': 2}

15.2 数学函数

# abs()：绝对值
print(abs(-10))         # 10
print(abs(-3.14))       # 3.14

# round()：四舍五入
print(round(3.14))      # 3
print(round(3.14159, 2)) # 3.14

# min()和max()
print(min(3, 1, 4, 1, 5))  # 1
print(max(3, 1, 4, 1, 5))  # 5

# sum()
print(sum([1, 2, 3, 4, 5]))  # 15

# pow()：幂运算
print(pow(2, 10))       # 1024
print(pow(2, 10, 100))  # 24（2的10次方对100取余）

# divmod()：返回商和余数
print(divmod(17, 5))    # (3, 2)

15.3 序列操作函数

# len()：长度
print(len("hello"))     # 5
print(len([1, 2, 3]))   # 3

# sorted()：排序（返回新列表）
numbers = [3, 1, 4, 1, 5, 9]
print(sorted(numbers))              # [1, 1, 3, 4, 5, 9]
print(sorted(numbers, reverse=True)) # [9, 5, 4, 3, 1, 1]

# reversed()：反转
numbers = [1, 2, 3, 4, 5]
print(list(reversed(numbers)))      # [5, 4, 3, 2, 1]

# enumerate()：带索引遍历
fruits = ["苹果", "香蕉", "橙子"]
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# zip()：并行遍历多个序列
names = ["小明", "小红", "小华"]
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

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

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

# any()和all()
print(any([True, False, False]))  # True（至少一个为True）
print(all([True, True, False]))   # False（不全为True）

15.4 输入输出函数

# input()：获取用户输入
name = input("请输入你的名字: ")
print(f"你好，{name}！")

# 注意：input()返回的总是字符串
age = int(input("请输入你的年龄: "))
print(f"明年你{age + 1}岁")

# print()的高级用法
print("Hello", "World", sep=", ")  # 自定义分隔符
print("正在加载", end="...")        # 自定义结尾
print("完成！")

# 格式化输出
name = "小明"
score = 95.5
print(f"姓名: {name:<10}分数: {score:>6.1f}")

15.5 其他实用函数

# type()：查看类型
print(type(42))         # <class 'int'>
print(type("hello"))    # <class 'str'>

# isinstance()：判断类型
print(isinstance(42, int))          # True
print(isinstance("hello", str))     # True
print(isinstance(42, (int, float))) # True

# id()：查看对象的内存地址
a = [1, 2, 3]
b = a
c = [1, 2, 3]
print(id(a) == id(b))   # True（同一个对象）
print(id(a) == id(c))   # False（不同对象）

# help()：查看帮助
# help(len)  # 取消注释可以查看len函数的帮助

# dir()：查看对象的所有属性和方法
print(dir(str))         # 查看字符串的所有方法

# range()：生成数字序列
print(list(range(5)))           # [0, 1, 2, 3, 4]
print(list(range(1, 6)))        # [1, 2, 3, 4, 5]
print(list(range(0, 10, 2)))    # [0, 2, 4, 6, 8]

# hash()：获取对象的哈希值
print(hash("hello"))    # 某个整数
print(hash(42))         # 42

16. 实战项目：简易计算器

让我们综合运用前面学到的知识，创建一个功能完善的简易计算器：

"""
简易计算器
支持基本的四则运算、幂运算、取余运算
具有历史记录功能
"""

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

def subtract(a, b):
    """减法"""
    return a - b

def multiply(a, b):
    """乘法"""
    return a * b

def divide(a, b):
    """除法"""
    if b == 0:
        return "错误：除数不能为零"
    return a / b

def power(a, b):
    """幂运算"""
    return a ** b

def modulo(a, b):
    """取余"""
    if b == 0:
        return "错误：除数不能为零"
    return a % b

def get_number(prompt):
    """获取用户输入的数字"""
    while True:
        try:
            return float(input(prompt))
        except ValueError:
            print("输入无效，请输入一个数字。")

def get_operation():
    """获取用户选择的运算"""
    print("\n可用的运算：")
    print("  + : 加法")
    print("  - : 减法")
    print("  * : 乘法")
    print("  / : 除法")
    print("  **: 幂运算")
    print("  % : 取余")
    print("  q : 退出程序")

    while True:
        op = input("\n请选择运算: ").strip()
        if op in ['+', '-', '*', '/', '**', '%', 'q']:
            return op
        print("无效的选择，请重新输入。")

def calculator():
    """计算器主函数"""
    print("=" * 40)
    print("      欢迎使用简易计算器")
    print("=" * 40)

    history = []  # 存储计算历史

    operations = {
        '+': ('加法', add),
        '-': ('减法', subtract),
        '*': ('乘法', multiply),
        '/': ('除法', divide),
        '**': ('幂运算', power),
        '%': ('取余', modulo)
    }

    while True:
        op = get_operation()

        if op == 'q':
            print("\n感谢使用计算器，再见！")
            break

        num1 = get_number("请输入第一个数字: ")
        num2 = get_number("请输入第二个数字: ")

        op_name, op_func = operations[op]
        result = op_func(num1, num2)

        # 格式化输出
        if isinstance(result, float) and result == int(result):
            result_str = str(int(result))
        elif isinstance(result, str):
            result_str = result
        else:
            result_str = f"{result:.6f}".rstrip('0').rstrip('.')

        print(f"\n{num1} {op} {num2} = {result_str}")

        # 记录历史
        history.append(f"{num1} {op} {num2} = {result_str}")

        # 询问是否查看历史
        if input("\n查看历史记录？(y/n): ").lower() == 'y':
            print("\n计算历史:")
            for i, record in enumerate(history, 1):
                print(f"  {i}. {record}")

    # 程序结束时显示历史
    if history:
        print("\n本次计算的所有记录:")
        for i, record in enumerate(history, 1):
            print(f"  {i}. {record}")

# 运行计算器
if __name__ == "__main__":
    calculator()

代码解析：

功能函数：我们定义了6个运算函数，分别处理加、减、乘、除、幂和取余运算。每个函数都有明确的职责，这是"单一职责原则"的体现。
输入验证：get_number()函数使用try-except来确保用户输入的是有效数字，而不是其他字符。如果输入无效，会提示用户重新输入。
运算选择：get_operation()函数显示菜单并验证用户的选择，确保只接受有效的运算符。
字典映射：使用字典将运算符映射到对应的函数和名称，这是一种非常Pythonic的写法，避免了冗长的if-elif语句。
历史记录：使用列表存储每次计算的结果，用户可以随时查看。
主程序入口：if __name__ == "__main__":确保只有直接运行这个文件时才执行计算器，如果被其他文件导入则不会自动运行。

17. 实战项目：猜数字游戏

这个项目将综合运用条件语句、循环、异常处理等知识：

"""
猜数字游戏
- 电脑随机生成一个数字
- 玩家猜测，电脑给出提示
- 记录游戏历史和最佳成绩
"""

import random

class GuessNumberGame:
    """猜数字游戏类"""

    def __init__(self, min_num=1, max_num=100, max_attempts=10):
        """初始化游戏参数"""
        self.min_num = min_num
        self.max_num = max_num
        self.max_attempts = max_attempts
        self.secret = 0
        self.attempts = 0
        self.history = []  # 存储游戏历史

    def start_new_round(self):
        """开始新一轮游戏"""
        self.secret = random.randint(self.min_num, self.max_num)
        self.attempts = 0
        print(f"\n{'=' * 40}")
        print(f"新一轮游戏开始！")
        print(f"我想了一个{self.min_num}到{self.max_num}之间的数字")
        print(f"你有{self.max_attempts}次机会猜中它")
        print(f"{'=' * 40}")

    def get_guess(self):
        """获取玩家的猜测"""
        while True:
            try:
                guess = int(input(f"\n第{self.attempts + 1}次猜测，请输入数字: "))
                if self.min_num <= guess <= self.max_num:
                    return guess
                else:
                    print(f"请输入{self.min_num}到{self.max_num}之间的数字！")
            except ValueError:
                print("请输入有效的整数！")

    def check_guess(self, guess):
        """检查猜测结果"""
        self.attempts += 1

        if guess == self.secret:
            return "correct"
        elif guess < self.secret:
            return "too_low"
        else:
            return "too_high"

    def give_hint(self, result, guess):
        """给出提示"""
        if result == "too_low":
            diff = self.secret - guess
            if diff > 20:
                print("太小了！差得远呢~")
            elif diff > 10:
                print("小了，但接近了！")
            else:
                print("小了一点点，快猜到了！")
        elif result == "too_high":
            diff = guess - self.secret
            if diff > 20:
                print("太大了！差得远呢~")
            elif diff > 10:
                print("大了，但接近了！")
            else:
                print("大了一点点，快猜到了！")

    def play_round(self):
        """玩一轮游戏"""
        self.start_new_round()

        while self.attempts < self.max_attempts:
            guess = self.get_guess()
            result = self.check_guess(guess)

            if result == "correct":
                print(f"\n🎉 恭喜你猜对了！答案就是{self.secret}！")
                print(f"你用了{self.attempts}次就猜到了！")
                self.history.append({
                    "secret": self.secret,
                    "attempts": self.attempts,
                    "success": True
                })
                return True
            else:
                self.give_hint(result, guess)
                remaining = self.max_attempts - self.attempts
                print(f"还剩{remaining}次机会")

        print(f"\n😢 很遗憾，你没有猜到。答案是{self.secret}。")
        self.history.append({
            "secret": self.secret,
            "attempts": self.attempts,
            "success": False
        })
        return False

    def show_history(self):
        """显示游戏历史"""
        if not self.history:
            print("\n还没有游戏记录。")
            return

        print(f"\n{'=' * 40}")
        print("游戏历史记录")
        print(f"{'=' * 40}")

        wins = 0
        best_attempts = float('inf')

        for i, record in enumerate(self.history, 1):
            status = "✓ 猜对" if record["success"] else "✗ 未猜对"
            print(f"第{i}轮: 答案={record['secret']}, "
                  f"尝试={record['attempts']}次, {status}")

            if record["success"]:
                wins += 1
                best_attempts = min(best_attempts, record["attempts"])

        total = len(self.history)
        print(f"\n总场次: {total}")
        print(f"胜利: {wins}次")
        print(f"胜率: {wins/total*100:.1f}%")
        if best_attempts != float('inf'):
            print(f"最佳成绩: {best_attempts}次猜中")

    def run(self):
        """运行游戏主循环"""
        print("欢迎来到猜数字游戏！")

        while True:
            print("\n主菜单:")
            print("  1. 开始游戏")
            print("  2. 查看历史记录")
            print("  3. 修改游戏难度")
            print("  4. 退出游戏")

            choice = input("\n请选择(1-4): ").strip()

            if choice == '1':
                self.play_round()
            elif choice == '2':
                self.show_history()
            elif choice == '3':
                self.change_difficulty()
            elif choice == '4':
                print("\n感谢游玩，再见！👋")
                break
            else:
                print("无效的选择，请重新输入。")

    def change_difficulty(self):
        """修改游戏难度"""
        print("\n难度选择:")
        print("  1. 简单 (1-50, 15次机会)")
        print("  2. 普通 (1-100, 10次机会)")
        print("  3. 困难 (1-200, 7次机会)")
        print("  4. 地狱 (1-1000, 10次机会)")

        choice = input("请选择难度(1-4): ").strip()

        if choice == '1':
            self.min_num, self.max_num, self.max_attempts = 1, 50, 15
        elif choice == '2':
            self.min_num, self.max_num, self.max_attempts = 1, 100, 10
        elif choice == '3':
            self.min_num, self.max_num, self.max_attempts = 1, 200, 7
        elif choice == '4':
            self.min_num, self.max_num, self.max_attempts = 1, 1000, 10
        else:
            print("无效的选择，保持当前难度。")
            return

        print(f"难度已更新: {self.min_num}-{self.max_num}, {self.max_attempts}次机会")


# 运行游戏
if __name__ == "__main__":
    game = GuessNumberGame()
    game.run()

项目特点：

面向对象设计：整个游戏被封装在一个类中，数据和方法组织清晰。这种设计使得代码更易于理解和维护。
完善的输入验证：无论是猜测数字还是菜单选择，都有输入验证，确保程序不会因为用户的错误输入而崩溃。
智能提示系统：不仅仅是告诉你"大了"或"小了"，还会根据差距给出更具体的提示，增加游戏的趣味性。
历史记录功能：记录每一轮游戏的结果，包括答案、尝试次数和是否成功，让玩家可以看到自己的进步。
多难度级别：支持4种不同的难度级别，满足不同水平玩家的需求。
主菜单系统：清晰的菜单界面，让玩家可以方便地选择功能。

18. 学习资源推荐

18.1 官方文档和教程

Python官方文档（https://docs.python.org/zh-cn/3/）

最权威的参考资料，有中文翻译版本
包含完整的语言参考、标准库文档和教程
遇到问题时首先查阅官方文档

Python官方教程（https://docs.python.org/zh-cn/3/tutorial/）

从基础到进阶的系统教程
由Python核心开发者编写
适合有一定基础后深入学习

18.2 在线学习平台

菜鸟教程（https://www.runoob.com/python3/python3-tutorial.html）

中文Python教程，内容全面
提供在线代码运行环境
适合初学者入门

廖雪峰的Python教程（https://www.liaoxuefeng.com/wiki/1016959663602400）

深入浅出，讲解清晰
涵盖基础到高级内容
包含大量实际案例

W3Schools Python教程（https://www.w3schools.com/python/）

英文教程，结构清晰
每个知识点都有在线练习
适合边学边练

Codecademy（https://www.codecademy.com/learn/learn-python-3）

交互式学习平台
通过实际编码学习
有免费和付费内容

18.3 推荐书籍

《Python编程：从入门到实践》

作者：Eric Matthes
适合零基础入门
前半部分讲基础，后半部分是实战项目
全球畅销的Python入门书

《笨办法学Python 3》

作者：Zed Shaw
通过大量练习来学习
强调动手实践
适合喜欢通过练习学习的读者

《Python Cookbook》

作者：David Beazley, Brian K. Jones
进阶书籍，包含大量实用技巧
适合有一定基础后阅读
涵盖各种常见编程场景

《流畅的Python》

作者：Luciano Ramalho
深入讲解Python的高级特性
适合想要精通Python的读者
帮助写出更Pythonic的代码

18.4 练习平台

LeetCode（https://leetcode.cn/）

算法题库，从简单到困难
提升编程思维和算法能力
面试刷题必备

HackerRank（https://www.hackerrank.com/）

编程挑战平台
有专门的Python练习区
提供各种难度的题目

Codewars（https://www.codewars.com/）

通过解决kata（小挑战）来学习
社区驱动，题目丰富有趣
可以看到其他人的解决方案

Project Euler（https://projecteuler.net/）

数学和编程结合的挑战
锻炼逻辑思维能力
问题从简单到极难

18.5 视频教程

B站（哔哩哔哩）

搜索"Python教程"可以找到大量免费教程
推荐UP主：黑马程序员、小甲鱼、莫烦Python等
中文讲解，适合国内学习者

YouTube

Corey Schafer的Python教程（英文）
Tech With Tim（英文）
Sentdex（英文）

18.6 社区和论坛

Stack Overflow（https://stackoverflow.com/）

全球最大的编程问答社区
遇到问题可以搜索或提问
几乎所有Python问题都能找到答案

GitHub（https://github.com/）

开源代码托管平台
可以学习优秀的开源项目
参与开源项目提升能力

CSDN（https://www.csdn.net/）

国内最大的开发者社区
中文技术文章丰富
适合搜索中文技术问题

知乎（https://www.zhihu.com/）

搜索Python相关话题
有很多经验分享和学习路线
可以关注Python领域的大V

18.7 学习建议

制定学习计划：

每天固定时间学习，哪怕只有30分钟
循序渐进，不要急于求成
设定阶段性目标，比如"一周内掌握列表和字典"

多写代码：

看完教程后一定要动手写代码
尝试修改示例代码，看看会发生什么
不要复制粘贴，手动输入代码可以加深记忆

做项目：

学完基础后尝试做一些小项目
项目可以是解决实际问题的工具
通过项目综合运用所学知识

阅读他人代码：

在GitHub上搜索有趣的Python项目
阅读优秀的开源代码可以学到很多
尝试理解代码的逻辑和设计思路

加入社区：

加入Python学习群或论坛
参与讨论，回答他人的问题
教别人是最好的学习方式

保持好奇心：

Python的生态系统非常庞大，总有新东西可以学
关注Python的最新发展和新特性
探索不同的应用领域，找到自己感兴趣的方向

18.8 学习路线图

第一阶段：基础入门（1-2个月）
├── 变量和数据类型
├── 运算符
├── 字符串操作
├── 列表、元组、字典、集合
├── 条件语句
├── 循环语句
└── 函数基础

第二阶段：进阶提升（2-3个月）
├── 文件操作
├── 异常处理
├── 模块和包
├── 面向对象编程
├── 列表推导式
├── Lambda函数
└── 常用标准库

第三阶段：专项深入（3-6个月）
选择一个方向深入学习：
├── Web开发（Django/Flask）
├── 数据科学（NumPy/Pandas/Matplotlib）
├── 机器学习（Scikit-learn/TensorFlow）
├── 自动化运维
├── 爬虫开发
└── 游戏开发（Pygame）

第四阶段：实战积累（持续）
├── 参与开源项目
├── 开发个人项目
├── 阅读优秀源码
├── 写技术博客
└── 参加编程比赛

结语

恭喜你完成了Python编程入门的全部学习内容！🎉

在这篇教程中，我们从Python的基础概念开始，一步步学习了变量、数据类型、运算符、字符串操作、数据结构、条件和循环语句、函数、模块、文件操作、异常处理、面向对象编程等核心知识。我们还通过两个实战项目——简易计算器和猜数字游戏，将所学知识综合运用到了实际场景中。

学习编程是一个持续的过程，最重要的是坚持练习和动手实践。不要害怕犯错，每一个错误都是学习的机会。当你遇到困难时，记得查阅文档、搜索解决方案，或者向社区求助。

Python的世界非常广阔，从Web开发到人工智能，从数据分析到自动化脚本，Python几乎无所不能。希望这篇教程能为你打开Python编程的大门，祝你在编程的道路上越走越远！

记住：编程最好的学习方式就是写代码。 现在就打开你的编辑器，开始编写你的第一个Python项目吧！

📝 本教程内容为原创编写，旨在帮助初学者入门Python编程。如有任何疑问或建议，欢迎反馈交流。

Python编程入门完全教程

教程简介

Python编程入门完全教程

目录

1. Python简介与发展历史

1.1 什么是Python？

1.2 Python的发展历史

1.3 Python的应用领域

1.4 为什么选择Python作为第一门编程语言？

2. 环境安装与配置

2.1 Windows系统安装Python

2.2 macOS系统安装Python

2.3 Linux系统安装Python

2.4 安装pip包管理器

2.5 选择代码编辑器

3. 第一个Python程序

3.1 使用交互式解释器

3.2 编写Python脚本文件

3.3 理解print()函数

3.4 理解注释

3.5 理解缩进

4. 变量与数据类型

4.1 什么是变量？

4.2 变量命名规则

4.3 Python的基本数据类型

4.4 类型转换

4.5 动态类型

4.6 多重赋值

5. 运算符

5.1 算术运算符

5.2 比较运算符

5.3 逻辑运算符

5.4 赋值运算符

5.5 成员运算符

5.6 身份运算符

5.7 运算符优先级

6. 字符串操作

6.1 创建字符串

6.2 字符串索引和切片

6.3 字符串常用方法

6.4 字符串格式化

6.5 字符串拼接和分割

6.6 转义字符

7. 列表、元组、字典、集合

7.1 列表（list）

7.2 元组（tuple）

7.3 字典（dict）

7.4 集合（set）

8. 条件语句

8.1 if语句

8.2 if-else语句

8.3 if-elif-else语句

8.4 嵌套条件

8.5 三元表达式

8.6 条件语句的实际应用

9. 循环语句

9.1 for循环

9.2 while循环

9.3 break和continue

9.4 for-else和while-else

9.5 嵌套循环

9.6 列表推导式

9.7 循环的实际应用

10. 函数定义与调用

10.1 什么是函数？

10.2 定义和调用函数

10.3 函数参数

10.4 返回值

10.5 变量作用域

10.6 Lambda函数

10.7 递归函数

10.8 函数的实际应用

11. 模块与包

11.1 什么是模块？

11.2 导入模块

11.3 常用标准库模块

11.4 创建自己的模块

11.5 包（Package）

11.6 使用pip安装第三方库

12. 文件操作