AI开发的Python基础

Python在AI领域占据主导地位不是偶然的。它的简洁语法、丰富的库生态和强大的数据处理能力使其成为AI开发的理想选择。

为什么Python适合AI开发？

核心优势

简洁易读: 代码接近自然语言
丰富的库: NumPy、Pandas、TensorFlow、PyTorch
社区支持: 大量教程和开源项目
跨平台: 在任何操作系统上运行

AI开发中的Python生态

# AI开发的核心库
import numpy as np           # 数值计算
import pandas as pd          # 数据处理
import matplotlib.pyplot as plt  # 数据可视化
import sklearn               # 机器学习
import tensorflow as tf      # 深度学习

NumPy：数值计算基础

NumPy是AI开发的基石，提供高效的数组操作。

数组创建和操作

import numpy as np

# 创建数组
arr = np.array([1, 2, 3, 4, 5])
matrix = np.array([[1, 2, 3], [4, 5, 6]])

# 特殊数组
zeros = np.zeros((3, 3))      # 全零数组
ones = np.ones((2, 4))        # 全一数组
identity = np.eye(3)          # 单位矩阵
random = np.random.rand(3, 3) # 随机数组

print(f"数组形状: {matrix.shape}")  # (2, 3)
print(f"数组维度: {matrix.ndim}")   # 2
print(f"元素总数: {matrix.size}")   # 6

数组运算

# 向量化运算 - 比循环快得多
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])

# 元素级运算
print(a + b)      # [6, 8, 10, 12]
print(a * b)      # [5, 12, 21, 32]
print(a ** 2)     # [1, 4, 9, 16]

# 矩阵运算
matrix_a = np.array([[1, 2], [3, 4]])
matrix_b = np.array([[5, 6], [7, 8]])

# 矩阵乘法
result = np.dot(matrix_a, matrix_b)
# 或使用 @ 运算符
result = matrix_a @ matrix_b
print(result)

数组索引和切片

# 一维数组
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

print(arr[0])       # 0
print(arr[-1])      # 9
print(arr[2:5])     # [2, 3, 4]
print(arr[::2])     # [0, 2, 4, 6, 8] - 每隔一个

# 二维数组
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

print(matrix[0, 0])     # 1
print(matrix[1, :])     # [4, 5, 6] - 第二行
print(matrix[:, 1])     # [2, 5, 8] - 第二列
print(matrix[0:2, 1:3]) # [[2, 3], [5, 6]]

# 布尔索引 - AI中常用于数据过滤
arr = np.array([1, 2, 3, 4, 5])
mask = arr > 3
print(arr[mask])  # [4, 5]

广播机制

# 广播让不同形状的数组可以运算
a = np.array([[1, 2, 3], [4, 5, 6]])  # (2, 3)
b = np.array([10, 20, 30])             # (3,)

# b会自动广播到每一行
result = a + b
print(result)
# [[11, 22, 33],
#  [14, 25, 36]]

# 实际应用：归一化
data = np.array([[1, 2], [3, 4], [5, 6]])
mean = data.mean(axis=0)  # 每列的均值
std = data.std(axis=0)    # 每列的标准差
normalized = (data - mean) / std

Pandas：数据处理利器

Pandas让数据清洗和分析变得简单。

DataFrame基础

import pandas as pd

# 创建DataFrame
data = {
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'age': [25, 30, 35, 28],
    'score': [85, 92, 78, 88]
}
df = pd.DataFrame(data)

print(df.head())      # 查看前几行
print(df.info())      # 数据信息
print(df.describe())  # 统计摘要

# 选择数据
print(df['name'])           # 选择列
print(df[['name', 'age']])  # 选择多列
print(df[df['age'] > 28])   # 条件筛选

数据清洗

# 处理缺失值
df = pd.DataFrame({
    'A': [1, 2, None, 4],
    'B': [5, None, 7, 8],
    'C': [9, 10, 11, 12]
})

# 检查缺失值
print(df.isnull().sum())

# 填充缺失值
df_filled = df.fillna(0)              # 用0填充
df_filled = df.fillna(df.mean())      # 用均值填充

# 删除缺失值
df_dropped = df.dropna()              # 删除含缺失值的行
df_dropped = df.dropna(axis=1)        # 删除含缺失值的列

数据转换

# 读取CSV文件
df = pd.read_csv('data.csv')

# 数据分组和聚合
grouped = df.groupby('category')['value'].mean()

# 数据透视
pivot = df.pivot_table(
    values='sales',
    index='date',
    columns='product',
    aggfunc='sum'
)

# 应用函数
df['normalized'] = df['value'].apply(lambda x: (x - x.mean()) / x.std())

# 合并数据
df1 = pd.DataFrame({'key': ['A', 'B'], 'value1': [1, 2]})
df2 = pd.DataFrame({'key': ['A', 'B'], 'value2': [3, 4]})
merged = pd.merge(df1, df2, on='key')

面向对象编程

AI项目中常用类来组织代码。

class NeuralNetwork:
    """简单的神经网络类"""

    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.weights = self._initialize_weights()

    def _initialize_weights(self):
        """初始化权重"""
        return {
            'W1': np.random.randn(self.input_size, self.hidden_size),
            'W2': np.random.randn(self.hidden_size, self.output_size)
        }

    def forward(self, X):
        """前向传播"""
        self.hidden = np.dot(X, self.weights['W1'])
        self.hidden = self._relu(self.hidden)
        output = np.dot(self.hidden, self.weights['W2'])
        return output

    def _relu(self, x):
        """ReLU激活函数"""
        return np.maximum(0, x)

    def train(self, X, y, epochs=100, lr=0.01):
        """训练模型"""
        for epoch in range(epochs):
            # 前向传播
            predictions = self.forward(X)

            # 计算损失
            loss = np.mean((predictions - y) ** 2)

            if epoch % 10 == 0:
                print(f"Epoch {epoch}, Loss: {loss:.4f}")

# 使用
model = NeuralNetwork(input_size=10, hidden_size=20, output_size=1)

函数式编程技巧

列表推导式

# 传统方式
squares = []
for i in range(10):
    squares.append(i ** 2)

# 列表推导式 - 更简洁
squares = [i ** 2 for i in range(10)]

# 带条件的推导式
even_squares = [i ** 2 for i in range(10) if i % 2 == 0]

# 嵌套推导式
matrix = [[i * j for j in range(3)] for i in range(3)]

Lambda函数和高阶函数

# Lambda函数
square = lambda x: x ** 2
print(square(5))  # 25

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

# filter - 过滤元素
evens = list(filter(lambda x: x % 2 == 0, numbers))

# reduce - 累积计算
from functools import reduce
sum_all = reduce(lambda x, y: x + y, numbers)

# 实际应用：数据预处理
data = [1, 2, 3, 4, 5]
processed = list(map(lambda x: (x - 3) / 2, data))

文件操作和数据持久化

# 读写文本文件
with open('data.txt', 'r') as f:
    content = f.read()

with open('output.txt', 'w') as f:
    f.write('Hello, AI!')

# JSON处理
import json

data = {'model': 'neural_network', 'accuracy': 0.95}

# 保存JSON
with open('model_info.json', 'w') as f:
    json.dump(data, f, indent=2)

# 读取JSON
with open('model_info.json', 'r') as f:
    loaded_data = json.load(f)

# Pickle - 保存Python对象
import pickle

model = {'weights': np.random.rand(10, 10)}

with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

with open('model.pkl', 'rb') as f:
    loaded_model = pickle.load(f)

实战：数据预处理管道

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler

class DataPreprocessor:
    """数据预处理管道"""

    def __init__(self):
        self.scaler = StandardScaler()
        self.feature_names = None

    def fit_transform(self, df):
        """拟合并转换数据"""
        # 保存特征名
        self.feature_names = df.columns.tolist()

        # 处理缺失值
        df = df.fillna(df.mean())

        # 标准化
        scaled_data = self.scaler.fit_transform(df)

        return pd.DataFrame(scaled_data, columns=self.feature_names)

    def transform(self, df):
        """转换新数据"""
        df = df.fillna(df.mean())
        scaled_data = self.scaler.transform(df)
        return pd.DataFrame(scaled_data, columns=self.feature_names)

# 使用
preprocessor = DataPreprocessor()
train_data = pd.DataFrame(np.random.rand(100, 5))
processed_train = preprocessor.fit_transform(train_data)

test_data = pd.DataFrame(np.random.rand(20, 5))
processed_test = preprocessor.transform(test_data)

性能优化技巧

向量化 vs 循环

import time

# 慢速：使用循环
def slow_sum(arr):
    result = 0
    for x in arr:
        result += x ** 2
    return result

# 快速：向量化
def fast_sum(arr):
    return np.sum(arr ** 2)

# 测试
arr = np.random.rand(1000000)

start = time.time()
slow_result = slow_sum(arr)
print(f"循环耗时: {time.time() - start:.4f}秒")

start = time.time()
fast_result = fast_sum(arr)
print(f"向量化耗时: {time.time() - start:.4f}秒")

内存优化

# 使用生成器节省内存
def data_generator(n):
    """生成器 - 按需生成数据"""
    for i in range(n):
        yield i ** 2

# 不会一次性加载所有数据到内存
for value in data_generator(1000000):
    process(value)

# 使用itertools处理大数据
from itertools import islice

# 只处理前1000个
for value in islice(data_generator(1000000), 1000):
    process(value)

调试技巧

# 使用断言
def divide(a, b):
    assert b != 0, "除数不能为0"
    return a / b

# 使用logging
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def train_model(data):
    logger.info("开始训练模型")
    logger.debug(f"数据形状: {data.shape}")
    # 训练代码
    logger.info("训练完成")

# 使用pdb调试器
import pdb

def complex_function(x):
    result = x * 2
    pdb.set_trace()  # 设置断点
    result = result + 10
    return result

最佳实践

代码组织

# 好的代码结构
project/
├── data/
│   ├── raw/
│   └── processed/
├── models/
│   ├── __init__.py
│   └── neural_network.py
├── utils/
│   ├── __init__.py
│   └── preprocessing.py
├── train.py
└── predict.py

类型提示

from typing import List, Tuple, Optional

def process_data(
    data: np.ndarray,
    labels: Optional[np.ndarray] = None
) -> Tuple[np.ndarray, np.ndarray]:
    """
    处理数据

    Args:
        data: 输入数据
        labels: 可选的标签

    Returns:
        处理后的数据和标签
    """
    processed_data = data / 255.0
    processed_labels = labels if labels is not None else np.zeros(len(data))
    return processed_data, processed_labels

总结

掌握这些Python基础知识，你就具备了进行AI开发的核心技能。记住：

NumPy用于高效数值计算
Pandas用于数据处理和分析
面向对象组织复杂项目
向量化优于循环
使用类型提示和文档字符串

继续实践，这些技能会成为你的第二天性！

AI开发的Python基础

分享这篇文章