7  Python 语言入门

下面提供一个 Python 入门教程,从基础概念讲起,再介绍最佳实践,最后展示 Python 在数据科学和人工智能领域的两个应用示例。每个部分都有完整的代码示例,每行代码均附有详细中文注释,并对代码运行结果进行了解释。

7.1 Python 基础概念

Python 是一门简单易学、功能强大的解释型编程语言,适合初学者。下面将介绍 Python 的基础语法、变量、数据类型、控制结构、函数和数据结构等内容。

7.1.1 变量和数据类型

下面的示例展示了如何定义变量以及 Python 的基本数据类型(整数、浮点数、字符串、布尔值)。

# 定义一个整数变量
a = 10              # a 是一个整数,值为 10

# 定义一个浮点数变量
b = 3.14            # b 是一个浮点数,值为 3.14

# 定义一个字符串变量
c = "Hello, Python!"  # c 是一个字符串,值为 "Hello, Python!"

# 定义一个布尔变量
d = True            # d 是一个布尔变量,值为 True

# 输出各变量的值和数据类型
print("a =", a, "类型:", type(a))   # 打印 a 的值和类型:<class 'int'>
print("b =", b, "类型:", type(b))   # 打印 b 的值和类型:<class 'float'>
print("c =", c, "类型:", type(c))   # 打印 c 的值和类型:<class 'str'>
print("d =", d, "类型:", type(d))   # 打印 d 的值和类型:<class 'bool'>
a = 10 类型: <class 'int'>
b = 3.14 类型: <class 'float'>
c = Hello, Python! 类型: <class 'str'>
d = True 类型: <class 'bool'>

代码说明:

  • 第1行到第4行:分别定义了整数、浮点数、字符串和布尔值变量。
  • 第7行到第10行:使用 print() 函数输出每个变量的值和类型。

7.1.2 控制结构 —— 条件语句和循环

7.1.2.1 条件语句示例

下面的代码判断一个数字是正数、负数还是零。

num = 5  # 定义变量 num,赋值为 5

if num > 0:                  # 如果 num 大于 0,进入此代码块
    print(num, "是正数")      # 打印 num 是正数
elif num < 0:                # 否则,如果 num 小于 0,进入此代码块
    print(num, "是负数")      # 打印 num 是负数
else:                        # 否则(即 num 等于 0)进入此代码块
    print(num, "是零")        # 打印 num 是零
5 是正数

代码说明:

  • 第1行:定义变量 num,值为 5。
  • 第3行:判断 num 是否大于 0。
  • 第4行:如果条件成立,则输出 “5 是正数”。
  • 第5-7行:使用 elifelse 处理其他情况。

7.1.2.2 for 循环示例

使用 for 循环遍历一个列表。

fruits = ["苹果", "香蕉", "橘子"]  # 定义一个包含水果名称的列表

for fruit in fruits:              # 遍历列表中的每个元素
    print("我喜欢吃", fruit)      # 打印每个水果的名称
我喜欢吃 苹果
我喜欢吃 香蕉
我喜欢吃 橘子

代码说明:

  • 第1行:定义列表 fruits,包含三个字符串。
  • 第3行:使用 for 循环遍历列表中每个元素,变量 fruit 依次取每个水果名称。
  • 第4行:打印“我喜欢吃”以及当前遍历到的水果名称。

7.1.2.3 while 循环示例

下面代码使用 while 循环计算 1 到 5 的累加和。

total = 0  # 定义变量 total,用于存储累加和,初始值为 0
i = 1      # 定义计数器 i,初始值为 1

while i <= 5:         # 当 i 小于等于 5 时,进入循环
    total += i        # 将 i 加到 total 上,相当于 total = total + i
    i += 1            # 将 i 的值增加 1

print("1到5的和为", total)  # 循环结束后,打印累加和
1到5的和为 15

代码说明:

  • 第1-2行:初始化累加和变量 total 和计数器 i
  • 第4行:设置循环条件,确保循环在 i<=5 时执行。
  • 第5行:将当前的 i 累加到 total 中。
  • 第6行:i 自增 1。
  • 第8行:循环结束后打印结果。

7.1.3 函数与模块

7.1.3.1 自定义函数示例

下面的代码定义一个求两个数和的函数,并调用该函数。

def add_numbers(x, y):
    # 定义函数 add_numbers,接受两个参数 x 和 y
    result = x + y    # 计算 x 与 y 的和,将结果存储在变量 result 中
    return result     # 返回计算结果

# 调用函数,将返回值赋给变量 sum_result
sum_result = add_numbers(3, 7)
print("3和7的和为", sum_result)  # 打印函数返回的结果
3和7的和为 10

代码说明:

  • 第1行:使用 def 定义函数 add_numbers,接收两个参数 xy
  • 第3行:计算传入参数的和,并赋值给 result
  • 第4行:返回计算结果。
  • 第7行:调用函数,并将返回结果存储到 sum_result
  • 第8行:打印出计算结果。

7.1.3.2 导入模块示例

下面示例展示如何使用 Python 标准库中的 math 模块来计算平方根。

import math  # 导入 math 模块,包含数学计算函数

sqrt_val = math.sqrt(16)  # 调用 math 模块中的 sqrt 函数计算 16 的平方根
print("16的平方根为", sqrt_val)  # 打印计算结果
16的平方根为 4.0

代码说明:

  • 第1行:导入 math 模块。
  • 第3行:使用 math.sqrt 计算 16 的平方根,并赋值给 sqrt_val
  • 第4行:打印平方根的值。

7.1.4 数据结构

7.1.4.1 列表(List)

# 列表:有序且可变的集合
numbers = [1, 2, 3, 4, 5]  # 定义一个包含数字的列表
numbers.append(6)         # 在列表末尾添加数字 6
print("列表内容为:", numbers)  # 打印列表当前的内容
列表内容为: [1, 2, 3, 4, 5, 6]

代码说明:

  • 第1行:定义一个包含 1 到 5 的列表。
  • 第2行:使用 append 方法向列表中添加数字 6。
  • 第3行:打印更新后的列表。

7.1.4.2 字典(Dictionary)

# 字典:无序的键值对集合
person = {"name": "张三", "age": 25}  # 定义一个字典,包含姓名和年龄信息
person["gender"] = "男"             # 添加一个新的键值对,表示性别为 "男"
print("字典内容为:", person)         # 打印字典的内容
字典内容为: {'name': '张三', 'age': 25, 'gender': '男'}

代码说明:

  • 第1行:定义一个包含姓名和年龄的字典。
  • 第2行:向字典中添加新的键 "gender",值为 "男"
  • 第3行:打印整个字典。

Python 主要的数据结构包括以下几类:

7.1.4.3 元组(Tuple)

  • 不可变、可存储不同类型的数据
  • 支持索引、切片、遍历等操作
tup = (1, "hello", 3.14)
print(tup[1])  # hello
hello

7.1.4.4 集合(Set)

  • 无序、不重复的元素集合
  • 支持集合运算(交集、并集、差集)
s = {1, 2, 3, 3, 5}
s.add(4)
print(s)  # {1, 2, 3, 4}
{1, 2, 3, 4, 5}

7.1.4.5 NumPy 数组

NumPy 的 ndarray 是一种高效的多维数组数据结构,适用于大规模数值计算。

import numpy as np

# 创建 NumPy 数组
arr = np.array([1, 2, 3, 4])
print(arr)  # [1 2 3 4]

# 创建二维数组(矩阵)
matrix = np.array([[1, 2], [3, 4]])
print(matrix)
# [[1 2]
#  [3 4]]

# 生成 3×3 的全 0 矩阵
zero_matrix = np.zeros((3, 3))
print(zero_matrix)

# 生成 3×3 的随机数矩阵
random_matrix = np.random.rand(3, 3)
print(random_matrix)

# 矩阵运算
arr2 = np.array([5, 6, 7, 8])
print(arr + arr2)  # [ 6  8 10 12]
print(arr * 2)  # [ 2  4  6  8]
[1 2 3 4]
[[1 2]
 [3 4]]
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
[[0.81258928 0.30607058 0.1707208 ]
 [0.74368608 0.91946392 0.30441661]
 [0.6076623  0.36749073 0.7451878 ]]
[ 6  8 10 12]
[2 4 6 8]

7.1.4.6 DataFrame

类似数据库表或 Excel 表格,行列都有索引。

import pandas as pd

# 创建 DataFrame
data = {
    "Name": ["Alice", "Bob", "Charlie"],
    "Age": [25, 30, 35],
    "City": ["New York", "San Francisco", "Los Angeles"]
}
df = pd.DataFrame(data)
print(df)

# 访问列
print(df["Age"])

# 访问行
print(df.loc[1])  # 按行索引访问
print(df.iloc[1])  # 按行位置访问
      Name  Age           City
0    Alice   25       New York
1      Bob   30  San Francisco
2  Charlie   35    Los Angeles
0    25
1    30
2    35
Name: Age, dtype: int64
Name              Bob
Age                30
City    San Francisco
Name: 1, dtype: object
Name              Bob
Age                30
City    San Francisco
Name: 1, dtype: object

7.1.4.7 PyTorch / TensorFlow 张量

用于深度学习中的高效数值计算。

import torch
tensor = torch.tensor([[1, 2], [3, 4]])
print(tensor)
tensor([[1, 2],
        [3, 4]])
Tip

为什么张量可以进行高效的数值运算?

张量(Tensor)能进行高效数值运算的原因主要包括以下几个方面:

1. 基于优化的底层实现

  • NumPy 依赖 BLAS/LAPACK:传统的 NumPy 运算主要依赖 BLAS(Basic Linear Algebra Subprograms)和 LAPACK(Linear Algebra PACKage)等底层优化库。
  • PyTorch / TensorFlow 采用高性能计算库:PyTorch 使用 ATen + cuDNN,TensorFlow 使用 XLA(Accelerated Linear Algebra),都针对张量运算进行了优化。

2. GPU 并行加速

  • 张量原生支持 GPU 计算:相比 NumPy 主要在 CPU 上运行,PyTorch 和 TensorFlow 允许张量在 GPU 上进行并行计算。

  • 多核并行计算:GPU 具有成千上万个计算核心,适合矩阵运算和深度学习任务。

  • 示例(在 GPU 上计算张量)

    import torch
    
    # 在 CPU 上创建张量
    a = torch.randn(1000, 1000)
    
    # 将张量移动到 GPU 并进行计算
    a_gpu = a.to("cuda")
    b_gpu = torch.matmul(a_gpu, a_gpu)
    print(b_gpu.device)  # cuda:0

3. 支持自动求导

  • PyTorch 和 TensorFlow 都支持自动微分,使得梯度计算更加高效。

  • 基于计算图(Computational Graph),减少重复计算,提高梯度计算效率。

  • 示例(PyTorch 自动求导)

    x = torch.tensor(2.0, requires_grad=True)
    y = x ** 2
    y.backward()  # 计算 dy/dx
    print(x.grad)  # 4.0

4. 高效的内存管理

  • 避免数据拷贝:PyTorch 和 TensorFlow 在 CPU 和 GPU 之间进行数据传输时,减少不必要的拷贝操作。
  • 内存池优化:PyTorch 采用 缓存机制,避免频繁的内存分配和释放,提高效率。

5. 矢量化计算

  • 支持广播机制(Broadcasting):允许不同形状的张量进行运算,而不需要手动扩展维度。

  • 示例(广播计算)

    import numpy as np
    a = np.array([[1, 2, 3]])
    b = np.array([[1], [2], [3]])
    print(a + b)  
    # [[2 3 4]
    #  [3 4 5]
    #  [4 5 6]]

6. 支持分布式计算

  • PyTorch 和 TensorFlow 支持 多 GPU 并行计算(Data Parallelism)多节点分布式训练
  • 适用于大规模深度学习训练,如 GPT、BERT 训练。

总结

张量的高效性主要来源于:

  1. 底层库优化(BLAS、cuDNN、XLA)
  2. GPU 并行计算
  3. 自动求导
  4. 高效的内存管理
  5. 矢量化计算
  6. 分布式计算支持

这使得张量成为深度学习、科学计算等高性能计算任务的理想数据结构。

7.2 Python 编码最佳实践

为了编写高质量、易维护的代码,建议遵循以下几点最佳实践:

  • 遵循 PEP8 规范
    • 使用 4 个空格缩进
    • 变量和函数命名应清晰、具有描述性
    • 每行代码不宜过长(一般限制在 79 字符以内)
  • 添加适当的注释
    • 对关键逻辑添加注释,方便自己和他人理解代码
  • 异常处理
    • 使用 try...except 来捕获潜在错误,避免程序崩溃

下面是一个使用异常处理的示例:

try:
    result = 10 / 0      # 尝试进行除法运算,分母为 0 可能导致异常
except ZeroDivisionError as e:  # 捕获除零错误,将异常信息存入变量 e
    print("错误:除数不能为零!", e)  # 打印错误提示及异常详情
错误:除数不能为零! division by zero

代码说明:

  • 第1行:尝试将 10 除以 0,此操作会引发 ZeroDivisionError 异常。
  • 第2行:捕获 ZeroDivisionError 异常,并将异常对象赋值给 e
  • 第3行:打印错误提示信息及异常详情。

7.3 Python 在数据科学领域的应用

Python 在数据科学中有着广泛的应用,主要依赖于如下几个库:

  • NumPy:高效的数值计算
  • Pandas:数据处理与分析
  • Matplotlib:数据可视化

下面的示例将展示如何利用这些库进行数据处理和绘图。

# 导入必要的库
import numpy as np             # 导入 NumPy 库,简写为 np,用于高效的数值计算
import pandas as pd            # 导入 Pandas 库,简写为 pd,用于数据处理
import matplotlib.pyplot as plt  # 导入 Matplotlib 的 pyplot 模块,简写为 plt,用于绘图
  • NumPy 部分:创建了一个一维数组,并对每个元素进行平方计算。
# -------------------------------
# 1. 使用 NumPy 进行数组操作
# -------------------------------
array = np.array([1, 2, 3, 4, 5])  # 创建一个包含数字 1 到 5 的 NumPy 数组
array_squared = array ** 2         # 对数组中的每个元素进行平方操作
print("原始数组:", array)           # 输出原始数组
print("数组每个元素的平方:", array_squared)  # 输出平方后的数组
原始数组: [1 2 3 4 5]
数组每个元素的平方: [ 1  4  9 16 25]
  • Pandas 部分:将一个包含姓名、年龄和分数的字典转换为 DataFrame,并计算年龄平均值。
# -------------------------------
# 2. 使用 Pandas 进行数据处理
# -------------------------------
# 定义一个字典,包含姓名、年龄和分数等信息
data = {
    "Name": ["Alice", "Bob", "Charlie", "David"],
    "Age": [25, 30, 35, 40],
    "Score": [85, 90, 95, 80]
}

df = pd.DataFrame(data)  # 将字典转换为 Pandas DataFrame 数据结构
print("数据框内容:\n", df)  # 打印数据框内容

# 计算年龄的平均值
average_age = df["Age"].mean()  # 计算 DataFrame 中“Age”这一列的平均值
print("平均年龄为:", average_age)  # 打印平均年龄
数据框内容:
       Name  Age  Score
0    Alice   25     85
1      Bob   30     90
2  Charlie   35     95
3    David   40     80
平均年龄为: 32.5
  • Matplotlib 部分:绘制一个简单的柱状图,展示每个学生的分数。
# -------------------------------
# 3. 使用 Matplotlib 进行数据可视化
# -------------------------------
plt.figure(figsize=(8, 4))  # 设置图形尺寸为 8x4 英寸
plt.bar(df["Name"], df["Score"], color='skyblue')  # 绘制柱状图:x 轴为姓名,y 轴为分数,柱状图颜色为天蓝色
plt.xlabel("Name")          # 设置 x 轴标签
plt.ylabel("Score")          # 设置 y 轴标签
plt.title("Student Score Bar Chart")   # 设置图形标题
plt.show()                 # 显示绘制的图形

7.4 Python 在人工智能领域的应用

在人工智能领域,Python 拥有大量成熟的机器学习和深度学习库,如 scikit-learn、TensorFlow、PyTorch 等。下面将通过一个使用 scikit-learn 构建逻辑回归模型的示例,展示如何进行基本的机器学习任务。

7.4.1 示例:使用鸢尾花数据集构建逻辑回归分类器

# 导入必要的库和模块
from sklearn.datasets import load_iris          # 导入鸢尾花数据集
from sklearn.model_selection import train_test_split  # 导入数据分割函数,用于将数据划分为训练集和测试集
from sklearn.linear_model import LogisticRegression   # 导入逻辑回归模型
from sklearn.metrics import accuracy_score        # 导入准确率评估函数

# 加载鸢尾花数据集
iris = load_iris()         # 加载数据集,返回一个包含数据和目标的字典对象
X = iris.data              # 提取特征数据(花萼长度、花萼宽度、花瓣长度和花瓣宽度)
y = iris.target            # 提取目标数据,表示鸢尾花的类别

# 划分数据集为训练集和测试集,测试集占总数据的 30%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# random_state 参数保证每次分割结果一致

# 初始化逻辑回归模型
model = LogisticRegression(max_iter=200)  # 创建逻辑回归模型实例,设置最大迭代次数为 200

# 在训练集上训练模型
model.fit(X_train, y_train)  # 使用训练数据拟合模型

# 使用训练好的模型对测试集进行预测
y_pred = model.predict(X_test)  # 对测试集数据进行预测

# 计算预测准确率
accuracy = accuracy_score(y_test, y_pred)  # 将预测结果与真实标签比较,计算准确率
print("鸢尾花数据集逻辑回归模型的准确率为:", accuracy)  # 打印预测准确率
鸢尾花数据集逻辑回归模型的准确率为: 1.0

代码说明:

  • 第1-4行:导入 scikit-learn 中所需的模块,包括数据集、数据分割、模型和评估指标。
  • 第7-8行:加载鸢尾花数据集,并将特征数据和目标数据分别赋值给 Xy
  • 第11行:使用 train_test_split 将数据随机分为训练集(70%)和测试集(30%),random_state 保证结果可复现。
  • 第14行:初始化逻辑回归模型,并设置最大迭代次数,以确保算法收敛。
  • 第17行:在训练集上训练模型。
  • 第20行:利用训练好的模型对测试集进行预测。
  • 第23行:计算并打印模型在测试集上的准确率。

运行结果说明:

运行此代码后,控制台会输出类似如下的结果(准确率可能因数据分割而略有不同):

鸢尾花数据集逻辑回归模型的准确率为: 0.9777777777777777

表示该逻辑回归模型在测试集上的分类准确率大约为 97.78%。

7.5 总结

本教程从 Python 的基础语法、数据结构、控制流程和函数模块等基本概念入手,讲解了如何编写清晰、规范的代码,并重点展示了 Python 在数据科学(通过 NumPy、Pandas、Matplotlib)和人工智能(使用 scikit-learn 进行逻辑回归分类)中的应用实例。希望这份教程能帮助你打下坚实的 Python 编程基础,并启发你在数据分析和机器学习领域继续探索!

你可以将每个代码块在自己的 Python 环境中运行(如 Jupyter Notebook 或 IDE)来观察详细的输出效果和图形展示,从而更好地理解代码运行的过程。