Python 语言 —— 新手快速入门

介绍

基本介绍

Python 是由 Guido van Rossum 于 1991 年首次发布的高级解释型编程语言，凭借其简洁易读的语法、跨平台特性（支持 Windows、macOS 和 Linux）以及支持多种编程范式（面向对象、函数式、命令式）的灵活性，成为开发者、数据科学家、教育工作者等广泛使用的语言。 其解释型特性（逐行执行）使其适合快速原型开发，而丰富的标准库和强大的第三方生态（如 PyPI 和 pip 管理工具） 使其在 Web 开发（Django/Flask）、数据科学（NumPy/Pandas）、人工智能（TensorFlow/scikit-learn）、自动化脚本、 科学计算（SciPy/SymPy）等领域占据主导地位。

Python 拥有活跃的社区（Stack Overflow、GitHub等）和丰富的学习资源（如《Python Crash Course》《Fluent Python》），同时 Python 3.x 的持续演进（类型提示、异步编程等）进一步巩固了其在新兴技术（量子计算、边缘计算）中的领先地位，成为当今最受欢迎的编程语言之一。

版本特性

Python 是一种广泛使用的高级编程语言，自 1991 年首次发布以来，经历了多个版本的演变。其中，Python 2 和 Python 3 是两个重要的主要版本，分别于 2000 年和 2008 年推出。

Python 2.x 系列以其简洁和易读性著称，尤其是在早期的 Web 开发和脚本编写中得到了广泛应用。Python 2.7 是该系列的最后一个主要版本，于 2010 年发布。它的特性包括将 print 作为语句使用，例如 print "Hello, World!"，这使得初学者更容易上手。此外，在 Python 2 中，整数除法默认执行的是整数除法，比如 5 / 2 的结果是 2。对于字符串处理，Python 2 中的默认字符串类型是字节串，Unicode 字符串需要特殊标识，如 u"你好"。尽管 Python 2 在当时非常流行，但由于其设计上的一些限制以及对现代编程需求的适应性不足，Python 社区逐渐向 Python 3 转型。

Python 3.x 系列的推出标志着对语言的一次重大改进。它在许多方面进行了重构，以增强可读性和一致性。例如，print 被改为函数形式，使用方法如 print("Hello, World!")，这使得代码更具一致性和可扩展性。Python 3 还引入了真实除法的概念，即使用 / 运算符时，两个整数相除会返回浮点数，如 5 / 2 的结果为 2.5，而 // 运算符则用于执行整数除法。字符串处理方面，Python 3 默认支持 Unicode，这使得国际化和多语言处理变得更加简单和直接。

然而，Python 3 与 Python 2 在语法和功能上并不完全兼容，这意味着许多基于 Python 2 的代码和库需要进行迁移才能在 Python 3 上运行。虽然 Python 2 在一段时间内仍然得到支持，但最终于 2020 年 1 月 1 日停止更新，开发者被鼓励转向 Python 3，以获得更好的性能和安全性。

Python 2 和 Python 3 代表了 Python 语言发展的两个重要阶段。Python 3 采用了更现代的设计理念， 提供了对新兴技术和标准的更好支持。因此，对于新项目，开发者应优先选择 Python 3，以确保代码的长久维护和最佳实践。

Note

如何选择 Python 版本？

除非对 Python 2.x 强烈的需求，否则极力推荐使用 Python 3.x。

环境搭建

安装 Python

在搭建 Python 环境之前，可以先检查本地电脑是否已经安装了 Python 环境。检查方式可以在终端窗口输入：

$ python
Python 3.11.5 (tags/v3.11.5:cce6ba9, Aug 24 2023, 14:38:34) [MSC v.1936 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> 

要是已经安装了，会输出 Python 的版本号。若显示无法识别 python 或其他错误信息，则说明本地电脑没有安装 Python 环境。 安装 Python 环境的步骤大概需要如下几步：

Step 1：下载 Python 安装包

Python 的安装包地址：

https://www.python.org/downloads/

Step 2：配置环境变量

若是 Windows 电脑，先打开环境变量窗口：右键“计算机” > 属性 > 高级系统设置，然后将 Python 的路径配置到环境变量中。

因为这个步骤非常通用，网上资料很多，不清楚可以自行搜索。

Step 3：编写代码，输出 Hello World!

配置完成后，在终端窗口输入 python --versrion，能够输出 python 的版本说明安装成功。然后输出 Hello World：

python
>>> print('Hello World!')

安装多版本 Python

在一台电脑上可以搭建 Python 2.x 和 Python 3.x 版本兼容的环境。需要使用 Python 2.x 时，执行 python <your_command>。 需要使用 Python 3.x，执行 python3 <your_command>。

以配置 Python 2.x 和 Python 3.x 为例，环境搭建的步骤如下：

Step 1：在同一台电脑，分别安装 Python 2.x 和 Python 3.x

Step 2：配置环境变量

以 Windows 11 为例，先打开环境变量窗口：右键“计算机” > 属性 > 高级系统设置，然后将 Python 的路径配置到环境变量中。

Step 3：修改应用的名称

找到 Python 3.x 的安装路径，将 Python 3.x 的 python.exe 和 pythonw.exe 分别修改成：python3.exe 和 pythonw3.exe。

Warning

只修改 Python 3.x 版本，Python 2.x 保持不变。

修改完成后，验证 Python 2.x 和 Python 3.x 的功能是否正常：

# 因为没有修改 Python 2.x 的，所以默认是执行 Python 2.x
$ python --version
Python 2.7.13

$ python3 --version
Python 3.11.5

若可以正确的输出 Python 的版本信息，说明已经配置成功。

Step 4：配置 PIP

因为修改了 Python 3.x 的 python.exe 和 pythonw.exe 的名字，所以会导致 Python 3.x 的 PIP 无法使用。

$ pip --version
pip 9.0.1 from d:\softwares\python27\lib\site-packages (python 2.7)

# 输出异常的信息
$ pip3 --version

此时，需要强制重新安装 PIP 工具：

python -m pip install --upgrade pip --force-reinstall
python3 -m pip install --upgrade pip --force-reinstall

验证 PIP 工具是否配置正确：

$ pip2 --version
pip 9.0.1 from d:\softwares\python27\lib\site-packages (python 2.7)

$ pip3 --version
pip 24.2 from D:\Softwares\Python311\Lib\site-packages\pip (python 3.11)

Step 5：删除多余的 PIP 文件

为了避免以后使用 PIP 工具出现版本冲突，此时可以删除 Python 2.x 和 Python 3.x 的 Scripts 中的 pip.exe 工具，注意：

1. Python 2.x 只保留 pip.exe；
2. Python 3.x 只保留 pip3.exe。

包管理软件

软件包源中拥有庞大且多样化的软件包数量和版本，因此使用软件源管理工具是必不可少的。常见的管理工具包括 pip、conda、Pipenv 以及 Poetry。

• pip 是最为常见的包管理工具，通过简洁的 pip install <package> 命令格式安装软件包，使用的是 PyPI 软件包源。
• conda 多被用作科学计算领域的包管理工具，功能丰富而强大，使用的软件包源是 Anaconda repository 和 Anaconda Cloud。除了支持 Python 软件包外，conda 还能安装 C、C++、R 等其他语言的二进制软件包，并提供了软件环境的隔离功能。
• Pipenv 是由 Kenneth Reitz 于 2017 年发布的 Python 依赖管理工具，现由 PyPA 维护。Pipenv 可自动管理虚拟环境和依赖文件，并提供一系列命令和选项来实现各种依赖和环境管理相关的操作。
• Poetry 类似于 Pipenv，是一个 Python 虚拟环境和依赖管理工具，同时提供包管理功能，如打包和发布。可将其视为 Pipenv 和 Flit 的超集，使你能够同时管理 Python 库和 Python 程序。

下表是上述几种包管理软件的对比：

特性	Conda	Pipenv	Poetry
环境隔离	✅ 支持	✅ 支持	✅ 支持
依赖解析	✅ 较强	✅ 基础	✅ 最先进
非Python包	✅ 支持	❌ 不支持	❌ 不支持
构建发布	❌ 不支持	❌ 不支持	✅ 完整支持
配置文件	environment.yml	Pipfile	pyproject.toml
适用场景	数据科学	应用开发	包开发

PIP

PIP（Pip Installs Packages）是 Python 的官方包管理工具，旨在简化 Python 库的安装、升级和管理过程。作为 Python 开发者的必备工具，PIP 使用户能够轻松地从 Python 包索引（PyPI）及其他源获取各种开源库，这些库覆盖了数据科学、Web 开发、机器学习等多个领域，极大地丰富了 Python 的生态系统。

# 安装包
pip install <package>
# 升级包
pip install --upgrade <package>
# 卸载包
pip uninstall --upgrade <package>
# 查看包
pip list
# 生成需求文件
pip freeze > requirements.txt

Note

为了提升下载速度，全球范围内存在许多 PyPI 的镜像服务器，国内也有多个软件源可供选择:

1. 阿里云：https://mirrors.aliyun.com/pypi/simple/
2. 清华大学：https://pypi.tuna.tsinghua.edu.cn/simple
3. 中国科学技术大学:：https://pypi.mirrors.ustc.edu.cn/simple/
4. 豆瓣：https://pypi.doubanio.com/simple/

要临时使用某个镜像源，可以在安装包时加上 -i 参数，例如临时切换成清华大学源安装某个应用：

pip install <your_package> -i https://pypi.tuna.tsinghua.edu.cn/simple

如果希望永久更改源，可以创建一个配置文件。在 Linux 或 MacOS 上，创建 ~/.pip/pip.conf 文件。 在 Windows 电脑上，创建 <用户家目录>\pip\pip.ini 文件。添加如下内容：

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple

conda

Conda 是一个开源的跨平台包管理与环境管理系统，由 Anaconda 公司开发。它不仅可以管理 Python 包，还能处理非 Python 的二进制依赖，特别适合科学计算和数据分析领域。Conda 通过创建独立的环境来解决不同项目间的依赖冲突问题，其强大的依赖解析能力使其成为数据科学家的首选工具。

# 创建环境
conda create -n <env_name> python=3.8
# 激活环境
conda activate <env_name>
# 安装包
conda install <package>
# 列出环境
conda env list
# 导出环境配置
conda env export > environment.yml

Pipenv

Pipenv 是 Python 官方推荐的依赖管理工具，它结合了虚拟环境管理和包管理功能，旨在替代传统的 pip+virtualenv 工作流。 Pipenv 通过自动创建虚拟环境和生成 Pipfile/Pipfile.lock 文件，实现了依赖的精确控制和可重复构建，特别适合现代 Python 应用开发。

# 初始化项目
pipenv --python 3.8
# 安装包（开发依赖加--dev）
pipenv install <package>
# 进入虚拟环境
pipenv shell
# 生成锁定文件
pipenv lock
# 安装所有依赖
pipenv install --dev

Poetry

Poetry 是新一代的 Python 依赖管理和打包工具，采用 pyproject.toml 作为配置文件。它不仅能够管理项目依赖， 还能处理项目构建和发布，提供了从项目创建到发布的完整工作流。Poetry 的依赖解析算法更为先进，能更好地处理复杂的依赖关系。

# 新建项目
poetry new <project_name>
# 添加依赖
poetry add <package>
# 安装所有依赖
poetry install
# 进入虚拟环境
poetry shell
# 构建项目包
poetry build

虚拟环境

环境变量

环境变量是操作系统和程序之间的信息交换介质，进程可共享或指定环境变量。其中PATH是关键变量，用于定义可执行文件的搜索路径。例如：

• 若将程序a.exe存放在D:\MyProgram，直接执行a.exe会提示"找不到程序"
• 将D:\MyProgram加入PATH后，系统会从PATH列出的路径中查找a.exe

创建虚拟环境

虚拟环境通过临时修改PATH实现环境隔离：

1. 激活时，脚本将当前命令行的PATH指向虚拟环境目录；
2. 执行命令时优先从修改后的PATH查找；
3. 命令行提示符会显示虚拟环境名称（如(.venv) user@host）。

常用的创建虚拟环境的工具主要有：

1. venv（Python 3.3+内置）
2. pyenv
3. pipenv（整合了虚拟环境和依赖管理）

venv

作为 Python 3.3+ 版本内置的虚拟环境工具，venv 以其简洁易用的特性，成为开发者入门环境管理的首选工具。 venv 最大的特点在于其"开箱即用"的特性。作为 Python 标准库的一部分，它不需要额外安装，只需在命令行中调用即可快速创建隔离环境。

venv 通过创建独立的 Python 运行环境来实现隔离。具体来说，它会：

1. 复制基础 Python 解释器；
2. 创建独立的 site-packages 目录；
3. 生成激活脚本用于环境切换。

假设我们正在开发一个名为 "data_analysis" 的项目：

# 创建环境
python -m venv data_analysis_env

# 激活环境(Linux/Mac)
source data_analysis_env/bin/activate

# 激活环境(Windows)
data_analysis_env\Scripts\activate.bat

# 安装项目依赖
pip install pandas matplotlib

# 退出环境
deactivate

但是不可否认的是：venv 作为基础工具也存在一些限制：仅适用于 Python 3.3+ 版本、无法管理不同 Python 版本和缺少依赖管理的高级功能。

pyenv

Python 版本兼容性问题常常让开发者头疼。pyenv 应运而生，成为管理多版本 Python 环境的瑞士军刀，让开发者能够游刃有余地 在不同项目间切换 Python 版本。

pyenv 从根本上解决了 Python 开发中的版本碎片化问题。它通过精巧的设计实现了：

1. 并行安装多个Python版本
2. 按项目灵活指定运行时版本
3. 无缝切换全局和局部Python环境

pyenv 采用 shim 机制实现版本管理。首先 pyenv 在 PATH 最前面插入 shims 目录用于拦截 Python 相关命令调用，其次是根据配置路由到指定版本 实现对 Python 多版本的管理功能。

# 查看所有可安装版本
pyenv install --list
# 安装特定Python版本
pyenv install 3.9.7
# 卸载Python版本
pyenv uninstall 3.8.12
# 查看已安装版本
pyenv versions
# 设置全局Python版本
pyenv global 3.9.7
# 设置当前目录的本地Python版本（会创建.python-version文件）
pyenv local 3.8.12
# 设置shell会话临时版本
pyenv shell 3.10.4
# 重置版本继承（使用全局设置）
pyenv local --unset

pyenv 也可以实现对虚拟环境的管理，但是需要安装 pyenv-virtualenv 插件：

# 创建虚拟环境（基于当前pyenv版本）
pyenv virtualenv 3.9.7 my-project-env
# 列出所有虚拟环境
pyenv virtualenvs
# 激活虚拟环境
pyenv activate my-project-env
# 停用虚拟环境
pyenv deactivate
# 删除虚拟环境
pyenv virtualenv-delete my-project-env

pipenv

Pipenv 是官方推荐的 Python 依赖管理工具，是一个融合了虚拟环境管理和依赖管理的智能工具：

• 虚拟环境管理（类似 virtualenv）
• 依赖管理（替代 requirements.txt）
• 依赖关系解析（生成 Pipfile.lock）

Pipenv 底层实际使用的是 Python 的 virtualenv 技术，但进行了自动化封装：

1. 自动环境创建：当首次运行 pipenv install 时，会自动在 ~/.local/share/virtualenvs/ 目录下创建虚拟环境
2. 哈希映射机制：通过计算项目路径的哈希值来唯一标识环境（可通过 pipenv --venv 查看实际路径）
3. 环境自动激活：使用 pipenv shell 时会通过临时修改 PATH 实现环境切换

# 创建新环境（指定Python版本）
pipenv --python 3.8
# 进入虚拟环境shell
pipenv shell
# 退出虚拟环境
exit
# 删除虚拟环境
pipenv --rm
# 安装包（并添加到Pipfile）
pipenv install requests
# 安装开发依赖
pipenv install pytest --dev
# 从Pipfile安装所有依赖
pipenv install
# 安装开发环境所有依赖
pipenv install --dev
# 卸载包
pipenv uninstall requests
# 查看依赖图
pipenv graph
# 检查安全漏洞
pipenv check
# 锁定当前环境
pipenv lock
# 验证Pipfile.lock是否最新
pipenv verify

IDE

IDE（集成开发环境）是指集成了多种开发工具的软件应用程序，旨在提供程序员开发软件所需的所有工具和功能，从编码到调试和部署。

Python 的IDE有很多种，以下是一些比较流行和常用的：

1. PyCharm：JetBrains 公司开发的强大的 Python IDE，支持多种功能如代码自动补全、调试、版本控制等。

2. Visual Studio Code（VS Code）：由微软开发的轻量级但功能强大的代码编辑器，支持众多插件和扩展，可以通过插件实现 Python 的开发环境。

3. Spyder：科学计算和数据分析领域常用的 Python IDE，集成了 IPython 控制台和多种数据分析工具。

4. Jupyter Notebook：交互式环境，允许开发者创建和共享文档，支持代码、文本和数据可视化。

5. Atom：由 GitHub 开发的另一个流行的代码编辑器，也支持 Python 开发。

6. Sublime Text：轻量级但功能丰富的代码编辑器，通过插件支持 Python 开发。

7. Eclipse + PyDev：Eclipse 是一个通用的开发平台，通过 PyDev 插件可以支持 Python 开发。

8. IDLE：Python 自带的集成开发环境，简单易用，适合初学者。

推荐一款 IDE 可能因人而异，但常见的推荐包括 PyCharm 和 VS Code。如果你喜欢强大的功能和集成开发环境，PyCharm 是一个很好的选择；如果你喜欢

基础语法

注释

注释是用于说明代码的文本，不会被解释器执行。注释可以提高代码的可读性，帮助他人（或将来的自己）理解代码的意图。

1. 单行注释 使用井号 (#) 来标记注释。井号后面的内容将被视为注释，直到行末。

   # 这是一个单行注释
   print("Hello, World!")  # 打印输出
   

2. 多行注释
   Python 没有专门的多行注释语法，但可以通过使用多个单行注释或者三重引号（''' 或 """）来实现。

   • 使用多个单行注释：

   # 这是一个多行注释
   # 它使用了多行的单行注释
   

   • 使用三重引号：

   """
   这是一个多行注释
   可以用于较长的说明
   """
   

使用适当的注释可以大大提高代码的可维护性和可读性。注释的最佳实践：

• 清晰简洁：注释应简洁明了，能够清楚地解释代码的目的。
• 避免过度注释：不需要对每一行代码都进行注释，尤其是那些显而易见的操作。
• 更新注释：确保注释与代码保持一致，修改代码时也要相应更新注释。

数据类型

在 Python 语言中，数据类型可以系统性地分为以下六大类别，每种类型都有其独特的特性和应用场景：

1. 数字型：包含整型(int)、浮点型(float)、布尔型(bool)和复数类型(complex)，是Python进行数值计算的基础
2. 字符串：str类型用于处理文本数据，支持丰富的字符串操作和方法
3. 序列类型：
   • 列表(list)：可变的有序集合
   • 元组(tuple)：不可变的有序集合
4. 集合类型：set和frozenset，提供高效的成员检测和集合运算
5. 映射类型：dict类型，基于键值对的数据结构
6. 二进制类型：bytes、bytearray等，用于处理二进制数据

数字型

Python的数字类型提供了完整的数值计算能力：

# 整型(任意精度)
integer = 42
# 浮点型(双精度)
floating = 3.14159
# 布尔型(True/False的子类)
boolean = True
# 复数
complex_num = 2 + 3j

# 类型转换示例
x = int("10")  # 字符串转整型
y = float(3)  # 整型转浮点

Note

Python 3中不再区分int和long类型，整型自动支持大整数运算

字符串

Python字符串是不可变的Unicode字符序列，支持多种创建方式：

# 基本创建方式
s1 = '单引号字符串'
s2 = "双引号字符串"
s3 = """多行
字符串"""

# 常用操作
name = "Python"
version = 3.8
formatted = f"{name} {version}"  # f-string格式化
concatenated = "Hello" + "World"  # 字符串连接

Note

重要特性：字符串不可变性意味着所有"修改"操作实际都返回新字符串对象

列表类型

列表是Python中最常用的可变序列类型：

# 创建列表
fruits = ['apple', 'banana', 'orange']
numbers = list(range(1, 6))

# 基本操作
fruits.append('pear')  # 添加元素
fruits.insert(1, 'kiwi')  # 插入元素
last = fruits.pop()  # 移除并返回最后一个元素

# 列表推导式
squares = [x ** 2 for x in range(10)]

Note

列表可以包含不同类型的元素，且支持嵌套结构

元组类型

元组是不可变序列，常用于保证数据完整性：

# 创建元组
coordinates = (10.0, 20.0)
single_element = (42,)  # 注意逗号

# 解包操作
x, y = coordinates

# 命名元组(更高级用法)
from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)

Note

不可变优势：适合作为字典键和使用在多线程环境中

集合类型

集合提供高效的无序唯一元素存储：

# 创建集合
unique_numbers = {1, 2, 3, 2, 1}  # 自动去重
empty_set = set()  # 不能用{}创建空集合

# 集合运算
a = {1, 2, 3}
b = {2, 3, 4}
union = a | b  # 并集
intersection = a & b  # 交集
difference = a - b  # 差集

Note

应用场景：快速成员检测、数据去重、关系运算

字典类型

字典是Python中的高效键值对映射：

# 创建字典
person = {'name': 'Alice', 'age': 25}
empty_dict = {}

# 常用操作
person['email'] = 'alice@example.com'  # 添加键值对
age = person.get('age', 0)  # 安全获取
keys = person.keys()  # 获取所有键

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

Note

键必须是不可变类型(字符串、数字、元组)，值可以是任意对象

运算符

在 Python 中，运算符包括了逻辑运算符和和算术运算符。它们可以也被称为算术运算和逻辑运算。

• 算术运算：用于执行数学计算，包括加、减、乘、除等。
• 逻辑运算：用于处理布尔逻辑，主要用于条件判断。

算术运算

算术运算用于进行数学计算，主要包括以下几种运算符：

算术运算	符号	示例	输出结果
加	+	1+2	3
减	-	3-1	2
乘	*	4*8	32
除	/	4/2	2
乘方	**	2**10	1024
模（余数）	%	4 % 3	1

Warning

1. 任意两个数字相除时，结果总是浮点数，即使这两个数是整数且能整除；
2. 任意运算中，只要有一个操作数是浮点数，结果总是浮点数。

>>> 4/2
2.0
>>> 1 + 2.0
3.0

逻辑运算

逻辑运算用于处理布尔值（True 和 False），主要包括以下运算符：

运算符	描述	示例
and	与：两个表达式都为 True 时结果为 True	a and b
or	或：至少一个表达式为 True 时结果为 True	a or b
not

选择结构

Python 的选择结构主要通过条件（if）语句实现。

if condition:
# 当 condition 为 True 时执行的代码

Note

1. Python 使用缩进来表示代码块，`if` 语句后面的代码必须缩进。
2. 可以使用任何返回布尔值的表达式作为 condition。
3. 条件可以包括数字、字符串、列表等，Python 会自动判断其真值。

if 语句是 Python 中用于条件判断的基本结构。它允许程序根据特定条件的真值来执行不同的代码块。 if 语句有四种常见的结构：

1. 只有一个 if 构成的选择结构。
2. if-else 组成选择结构。
3. if-elif-else 组成的复合选择结构，其中 elif 可以不限个数。复合结构下，else 可以根据情况省略。
4. 嵌套的 if 结构。

# if-else
x = -5
if x > 0:
    print("x 是正数")
else:
    print("x 不是正数")

# if-elif-else
if x > 0:
    print("x 是正数")
elif x < 0:
    print("x 是负数")
else:
    print("x 是零")

# 嵌套 if 语句
if x > 0:
    print("x 是正数")
    if x % 2 == 0:
        print("x 是偶数")
    else:
        print("x 是奇数")
else:
    print("x 不是正数")

if 可以结合使用逻辑运算符 and、or 和 not 来创建更复杂的条件：

age = 20
is_student = True

if age < 18 or is_student:
    print("享受学生优惠")
else:
    print("正常票价")

对于简单的条件，Python 提供了一种更简洁的写法，称为三元表达式（或条件表达式）：

x = 5
message = "正数" if x > 0 else "非正数"
print(message)  # 输出: 正数

if 还可以用于对列表进行判空（元素个数为 0）。

users = []
if users:
    print('The list of user is empty.')
else:
    print(users)

循环结构

在 Python 中，循环结构主要有两种：for 循环和 while 循环。

for 循环

for 循环用于遍历序列（如列表、元组、字典、字符串等）中的每个元素。其基本语法如下：

for item in iterable:
# 执行的代码块

以下是一个简单的示例：

# 遍历列表
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

# 使用 range() 函数
for i in range(5):  # 0 到 4
    print(i)

while 循环

while 循环在给定条件为真时重复执行代码块。其基本语法如下：

while condition:
# 执行的代码块

以下是一个简单的示例：

count = 0
while count < 5:
    print(count)
    count += 1  # 更新计数器以防止无限循环

嵌套循环

Python 还支持嵌套循环，即在一个循环内部再使用一个循环。

for i in range(3):
    for j in range(2):
        print(f'i={i}, j={j}')

控制循环

在使用 for 循环和 while 循环的时候，可以使用 break 和 continue 控制循环的流程：

• break: 用于终止循环。
• continue: 跳过当前迭代，继续下一个迭代。

以下是一个简单的示例：

# 使用 break
for i in range(10):
    if i == 5:
        break
    print(i)

# 使用 continue
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)  # 打印奇数

用户输入

在 Python 中，可以使用 input() 函数来获取用户输入。该函数会暂停程序的执行，等待用户输入内容，然后返回输入的字符串。

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

由于 input() 返回的是字符串类型，如果你需要获取数字（如整数或浮点数），需要进行类型转换。

# 获取用户输入的数字
age = input("请输入你的年龄: ")
age = int(age)  # 转换为整数
print(f"你{age}岁了!")

# 获取浮点数
height = input("请输入你的身高（米）: ")
height = float(height)  # 转换为浮点数
print(f"你的身高是{height}米.")

如果需要一次性获取多个值，可以用 split() 方法将输入的字符串分割成列表。

# 输入多个值
numbers = input("请输入几个数字，以空格分隔: ")
numbers_list = numbers.split()  # 将字符串分割为列表
numbers_list = [int(num) for num in numbers_list]  # 转换为整数
print(f"你输入的数字是: {numbers_list}")

获取用户输入时，最好进行错误处理，以防用户输入无效数据。

try:
    age = int(input("请输入你的年龄: "))
    print(f"你{age}岁了!")
except ValueError:
    print("请输入一个有效的数字!")

Warning

• input() 在 Python 3.x 中总是返回字符串，而在 Python 2.x 中，input() 会尝试执行输入的内容，因此在 Python 3.x 中使用时要特别注意。
• 如果不希望终端回显输入的内容，可以使用 getpass 模块。

import getpass

password = getpass.getpass("请输入密码: ")
print("密码已输入.")

类

在 Python 中，类是面向对象编程的基本构件，用于创建对象。类可以看作是一个蓝图，其中定义了对象的属性（数据）和方法（功能）。 通过类，可以创建多个对象，每个对象都可以拥有独立的状态和行为。 类是 Python 中组织代码、封装数据和行为的重要工具。通过类，可以实现更清晰、更结构化的程序设计。

定义类

使用 class 关键字来定义一个类。

class Dog:
    pass  # 空类示例

类名通常使用大写字母开头，采驼峰命名法定义类名。

构造方法

__init__ 是类的构造方法，用于初始化对象的属性。

class Dog:
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

__init__() 是类的构造方法，所有实例化对象时都会调用该方法。形参 self 必不可少，且必须位于所有参数前面。这是因为 Python 在实例化对象时，会自动传入 self 参数。self 参数是一个指向实例本身的引用，让实例可以访问到类中的属性和方法。

name 和 age 是类中的属性。属性表示的是类的状态或特征。在 Python 中，定义属性时，在可以属性名前添加下划线：

1. 单下划线 _ 前缀。表示该属性是“保护的”，是对开发者的一种约定，建议外部代码不要直接访问。通常用于类内部实现，表示这些属性不应被外部用户直接访问，但仍然可以通过对象访问。
2. 双下划线 __ 前缀。用于实现“私有”属性，通过名称重整（name mangling），使得属性名改变为 _ClassName__AttributeName 的形式，从而防止子类中出现同名属性或方法。当希望禁止子类访问父类的同名属性，或者想要提供一种更强的封装和隐藏机制时，可以使用双下划线。

方法

类可以包含方法，表示对象的行为或功能。

class Dog:
    def bark(self):
        return f"{self.name} says woof!"

在 Python 定义方法时，会在方法前添加单下划线 _ 或双下划线 __。它们的主要作用是表明这些方法是类内部实现的一部分，不应该被直接访问。两者的区别主要是：

1. 单下划线 _ 表示“保护”，是对开发者的约定，表明该属性或方法不应被外部代码直接访问。该定义没有强制性，需要访问仍然可以访问。
2. 表示“私有”，通过名称重整来避免子类中同名冲突，提供了一种更强的封装性。子类不能直接访问父类的同名方法或属性。

Note

下划线修饰属性和方法时，含义基本相同。

在 Python 中，魔法方法（也称为特殊方法或双下划线方法）是以双下划线开始和结束的方法。这些方法允许你自定义对象的行为，使你的类更加灵活和强大。常见的魔法方法见下表。

魔法方法	描述
__new__(cls, *args, **kwargs)	创建并返回一个新实例
__init__(self, *args, **kwargs)	初始化对象的属性
__str__(self)	定义 str() 的返回值，提供友好的字符串表示
__repr__(self)	定义 repr() 的返回值，用于调试
__eq__(self, other)	定义相等比较（==）
__ne__(self, other)	定义不相等比较（!=）
__lt__(self, other)	定义小于比较（<）
__le__(self, other)	定义小于等于比较（<=）
__gt__(self, other)	定义大于比较（>）
__ge__(self, other)	定义大于等于比较（>=）
__add__(self, other)	定义加法（+）
__sub__(self, other)	定义减法（-）
__mul__(self, other)	定义乘法（*）
__truediv__(self, other)	定义真除法（/）
__floordiv__(self, other)	定义地板除法（//）
__mod__(self, other)	定义取模（%）
__pow__(self, other)	定义幂运算（**）
__len__(self)	定义 len() 的返回值
__getitem__(self, key)	定义索引访问（例如，obj[key]）
__setitem__(self, key, value)	定义索引赋值（例如，obj[key] = value）
__delitem__(self, key)	定义删除索引（例如，del obj[key]）
__iter__(self)	返回迭代器对象
__next__(self)	定义迭代器的下一个值
__enter__(self)	定义进入上下文的行为
__exit__(self, exc_type, exc_value, traceback)	定义退出上下文的行为
__getattr__(self, name)	当访问不存在的属性时调用
__getattribute__(self, name)	访问属性时调用
__setattr__(self, name, value)	设置属性时调用
__delattr__(self, name)	删除属性时调用
__del__(self)	定义对象被销毁时的行为
__hash__(self)	定义对象的哈希值
__bool__(self)	定义对象在布尔上下文中的表现

封装继承和多态

封装

封装是隐藏对象的内部状态和实现细节，只允许通过特定方法访问。

class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance  # 私有属性

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount

    def get_balance(self):
        return self.__balance


# 使用 BankAccount 类
account = BankAccount()
account.deposit(100)
print(account.get_balance())  # 输出: 100
account.withdraw(50)
print(account.get_balance())  # 输出: 50

继承

Python 支持类的继承，子类可以继承父类的属性和方法。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass  # 抽象方法


class Dog(Animal):
    def speak(self):
        return f"{self.name} says woof!"


class Cat(Animal):
    def speak(self):
        return f"{self.name} says meow!"


# 创建 Dog 和 Cat 的实例
dog = Dog("Rex")
cat = Cat("Fluffy")

print(dog.speak())  # 输出: Rex says woof!
print(cat.speak())  # 输出: Fluffy says meow!

多态

多态允许不同类的对象以相同的方式调用同一个方法。

def animal_sound(animal):
    print(animal.speak())


# 使用多态
animal_sound(dog)  # 输出: Rex says woof!
animal_sound(cat)  # 输出: Fluffy says meow!

函数

函数是带名字的代码块，使用 def 关键字定义一个函数，使用圆括号定义函数接收的参数。

# 定义函数
def greet_user():
    print("Hello!")


# 调用函数
greet_user() 

形式参数

函数定义的参数称为形式参数（形参），调用函数传递的参数称为实际参数（实参）。在函数定义时，可以先定义形式参数。

def greet_user(name):
    print(f'Hello, {name}!')


greet_user('Li Hua')

根据参数的位置可以将实参分成：位置实参和关键字实参。位置实参要求实参与形参的顺序相同：

def greet_user(first_name, last_name):
    print(f"Your name is {first_name} {last_name}")


greet_user('San', 'Zhang')

关键字实参通过让参数名与值关联，所以可以让实参与形参的顺序不同：

def greet_user(first_name, last_name):
    print(f"Your name is {first_name} {last_name}")


greet_user(first_name='San', last_name='Zhang')
greet_user(last_name='Zhang', first_name='San')

参数默认值

在定义形参时，可以为形参设置一个默认值，调用时可以传可不传：

def greet_user(first_name, last_name, school='No.2 Middle School'):
    print(f"Your name is {first_name} {last_name} and your school is {school}")


greet_user('San', 'Zhang', 'No.1 Middle School')
greet_user('Si', 'Li')

引用传递

函数的形式参数为列表、字典等时，传递的方式为引用传递。

def modify(numbers):
    numbers.append(4)  # 在函数内部修改列表


numbers = [1, 2, 3]
modify(numbers)
print(numbers)  # 输出 [1, 2, 3, 4]

通过使用切片的方式，可以实现不改变实参的列表元素：

def modify(numbers[:

]):
numbers.append(4)  # 在函数内部修改列表

numbers = [1, 2, 3]
modify(numbers)
print(numbers)  # 输出 [1, 2, 3]

任意参数

无法确认参数个数时，可以使用任意参数。使用 * 表示元组，使用 ** 表示字典。

def print_number(*numbers):
    print(numbers)


print_number(1)
print_number(1, 2)
print_number(1, 2, 3)
print_number(1, 2, 3, 4)
print_number(1, 2, 3, 4, 5)


def print_name(**names):
    print(names)


print_name(first_name='San', last_name='Zhang')

Warning

元组中的元素不可修改。

函数引用

在一个文件中引入另外一个模块的函数，有三种导入方法：

1. 导入整个模块；
2. 导入模块中的所有函数和变量；
3. 导入模块中的某个函数或变量；

# 导入整个模块
import module_name

# 导入模块中的所有函数和变量
from module_name import *

# 导入模块中的某个函数或变量
from module_name import function_name, variable_name

第 1 种方式和第 2 种方式的区别在于：第 1 种方式在调用导入模块的函数时，需要使用 模块名.函数名 的方式调用函数。而第 2 种方式直接使用函数名调用。因此，第 1 种方式可以避免函数名重复定义，第 2 种则无法避免（污染了当前环境）。因此，推荐使用第 1 种方式导入函数。

导入后的函数或者模块，可以通过 as 关键字设置别名：

import module_name as a
from module_name import * as b

文件操作

打开文件使用 open() 函数，关闭文件使用 close() 函数，读文件使用 read()、 readline() 和 readlines() 函数，写文件使用 write() 函数或者 writelines()，自动关闭文件使用 with-as 语句。

# 只读模式打开文件
file = open('a.txt', 'r')
# 写模式打开文件（若文件不存在，则会自动创建）
file = open('a.txt', 'w')
# 追加模式打开文件（若文件不存在，则会自动创建）
file = open('a.txt', 'a')
# 读整个文件
content = file.read()
# 读一行
line = file.readline()
# 读取所有行并存储到列表中
lines = file.readlines()
# 写入字符串到文件
file.write('Hello, World!')
# 写入多行字符串到文件
lines = ['Line 1\n', 'Line 2\n', 'Line 3\n']
file.writelines(lines)
# 关闭文件
file.close()
# 自动关闭文件
# 在 with 代码块结束时，文件会自动关闭，无需手动调用 file.close()
with open('a.txt', 'r') as file
    print(file.read())

导入 json 模块后，可以处理 json 格式的文件。使用 json.dump() 保存一个 json 文件到本地磁盘，使用 json.load() 读取一个 json 文件。

import json

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

filename = 'numbers.json'
with open(filename, 'w') as wf:
    json.dump(numbers, wf)

with open(filename, 'r') as rf
    new_numbers = json.load(rf)
    print(new_numbers)

异常处理

在 Python 中，异常处理是管理程序运行过程中可能出现的错误的一种机制。通过异常处理，可以避免程序因错误而崩溃，并能够优雅地处理错误情况。Python 提供了 try、except、else 和 finally 语句来实现异常处理。

try:
    # 可能会引发异常的代码
    risky_code()
except SomeException:
    # 处理异常的代码
    handle_exception()
else:
    # 如果没有异常发生，执行这部分
    no_exception_code()
finally:
    # 无论是否发生异常，都会执行这部分
    cleanup_code()

其中：

1. try 块：放置可能引发异常的代码。如果代码没有异常，程序将继续执行 try 块后面的代码。
2. except 块：用于捕获和处理特定类型的异常。可以指定多个 except 块来处理不同类型的异常。
3. else 块：如果 try 块中的代码没有引发异常，将执行 else 块中的代码。这部分是可选的。
4. finally 块：无论是否发生异常，finally 块中的代码都会执行。常用于清理资源，如关闭文件或网络连接。这部分也是可选的。

Warning

可以使用通用的 except Exception 来捕获所有异常，但通常不推荐这样做，因为它可能掩盖其他潜在问题。

try:
    # 一些代码
except Exception as e:
    print(f"An error occurred: {e}")

除了使用 Python 内置的异常外，还可以根据情况在代码中自定义异常。

# 自定义一个 CustomError 类型的异常
class CustomError(Exception):
    pass


def some_function():
    raise CustomError("This is a custom error.")


try:
    some_function()
except CustomError as e:
    print(e)

单元测试

单元测试用于测试某个函数不存在问题。通过导入 unittest 模式，测试类继承 unittest.TestCase 来执行单元测试。

import unittest

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

class CalculatorTest(unittest.TestCase):  # 继承测试类
    def test_add(self):  # 测试方法
        self.assertEqual(add(1, 2), 3)

if __name__ == '__main__':
    unittest.main()

判断程序运行的结果是否与期待的结果相等，称之为断言。

方法	含义	示例	输出结果
assertEqual(a, b)	判断是否相等	assertEqual(1, 2)	False
assertNotEqual(a, b)	判断是否不相等	assertNotEqual(1, 2)	True
assertTrue(x)	判断是否为 True	assertTrue(1 == 2)	False
assertFalse(x)	判断是否为 False	assertFalse(1 == 2)	True
assertIn(item, list)	判断元素是否在列表中	assertIn(3, [1, 2, 3 , 4])	True
assertNotIn(item, list)	判断元素是否不在列表中	assertNotIn(3, [1, 2, 3, 4])	False

unittest 支持在每个测试方法执行前后执行一些准备和清理操作，可以使用 setUp 和 tearDown 方法。

class TestStringMethods(unittest.TestCase):

    def setUp(self):
        # 在每个测试方法执行前调用
        pass

    def tearDown(self):
        # 在每个测试方法执行后调用
        pass