Spring AI Alibaba

环境准备

1. ‌安装 Anaconda ‌：创建Python环境（推荐Python 3.11），激活环境后安装依赖（如torch、metrics等）。
2. ‌下载模型‌：通过pip install modelscope download --model Qwen/Qwen2.5-VL-7B-Instruct --local_dir /data2/users/yszhang/quickllm/qwen2.5-vl-instruct命令下载模型参数。

启动图形界面

运行llamafactory-cli webui启动Web界面（访问http://127.0.0.1:7860），通过以下步骤操作：

1. ‌选择语言‌：默认支持中文（zh）。
2. ‌模型选择‌：从Hugging Face或本地路径加载模型（如Qwen2.5-VL-7B-Instruct）。
3. ‌参数配置‌：支持微调、推理参数设置，支持多卡训练（需提前安装 DeepSpeed ）。

微调流程

1. ‌数据准备‌：需自行准备训练数据（文本/代码补全模板）。
2. ‌训练启动‌：通过Web界面选择训练方法（如全量调参、 LoRA 等），指定GPU数量及输出路径。
3. ‌结果验证‌：根据日志文件选择最优checkpoint进行推理测试。

注意事项

• 需确保服务器支持GPU加速，安装驱动及CUDA环境。 ‌
• 不同版本可能存在功能差异，建议参考官方GitHub更新日志。 ‌

Llama-Factory 内置的MMLU、 CMMLU 和 CEVAL 是针对大模型在不同场景下的评估工具，主要区别如下：

MMLU（多领域语言理解）

用于评估模型在多个学科领域的理解能力，包含数学、艺术、法律等67个主题的测试题，通过多项选择题形式考察模型对学科知识的掌握程度。

CMMLU（中文多选多学科理解）

专为中文设计，涵盖艺术、商业、文化等67个主题，侧重评估模型对中国文化、语言及跨学科推理能力的适应性。其题目设计更贴近中文语境，答案需针对中国背景。

CEVAL（ C-Eval ）

包含52个学科13948道题，通过不同难度等级（初级、中级、高级）评估模型在代码生成、数学推理等领域的专项能力。题型为填空题，需模型生成代码或数学解题步骤。

‌适用场景对比‌

• ‌MMLU‌：适合评估模型在多领域知识理解的泛化能力，类似 SQUAD 等通用语言理解测试。
• ‌CMMLU‌：侧重中文语境下的跨学科推理与知识应用，适合评估模型对中国文化、法律的适配性。
• ‌CEVAL‌：聚焦代码生成、数学推理等专项能力，通过填空题形式直接考察模型的编程与逻辑推导能力。

蒸馏的基本原理

蒸馏的基本思想是通过最小化一个教师模型（通常是原始大模型）和学生模型（较小或较简单模型）之间的差异来训练学生模型。这种差异通常是通过某种形式的损失函数来衡量的，例如最常见的有温度缩放（Temperature Scaling）方法。

温度缩放
温度缩放是蒸馏中最常用的方法之一。在这种方法中，教师模型的输出通过一个温度参数 $T$ 进行缩放，然后使用softmax函数的输出作为目标分布。学生模型的输出也使用相同的温度进行缩放，然后通过交叉熵损失函数与教师模型的输出进行比较。

数学表达式如下：

$$ P_{teacher}(y|x) = \frac{e^{logits_y / T}}{\sum_i e^{logits_i / T}} $$

其中 $logits$ 是教师模型的原始输出（通常是未经softmax处理的），$T$ 是温度参数，$y$ 是真实标签。

实现蒸馏的步骤
选择教师模型和学生模型：教师模型通常是预先训练好的复杂模型，而学生模型则是需要训练的较小模型。

训练教师模型：首先确保教师模型已经充分训练并达到预期的性能。

定义损失函数：使用交叉熵损失函数，并结合温度缩放策略。

训练学生模型：使用教师模型的输出作为目标，通过最小化损失函数来训练学生模型。

示例代码（使用PyTorch）
以下是一个简单的示例，展示如何使用PyTorch进行蒸馏：

import torch
import torch.nn as nn
import torch.nn.functional as F

假设 teacher_model 和 student_model 已经定义并初始化

teacher_model = ... # 已经训练好的大模型
student_model = ... # 小模型，结构简单，参数少

损失函数定义，使用交叉熵损失和温度缩放

def distillation_loss(outputs, labels, T):
outputs = F.log_softmax(outputs/T, dim=1)
labels = F.softmax(labels/T, dim=1)
return F.kl_div(outputs, labels, reduction='batchmean') * (T * T)

假设 data_loader 是已经定义好的数据加载器

for data, target in data_loader:
teacher_output = teacher_model(data)
student_output = student_model(data)
loss = distillation_loss(student_output, teacher_output, T=2.0) # T=2.0 是温度参数的一个例子
loss.backward()
optimizer.step() # 确保有一个优化器在运行中

注意事项

选择合适的温度参数 $T$ 对蒸馏的效果有显著影响。通常需要一些实验来确定最佳的温度值。

在实际应用中，可能还需要考虑其他因素，如数据增强、正则化等，以进一步提高蒸馏的效果。

确保教师模型和学生模型的输入输出维度匹配。

通过以上步骤和示例代码，你可以开始在自己的项目中应用蒸馏技术来优化和简化深度学习模型。

1. 选择合适的库

对于机器学习或深度学习项目，常用的库有：

• TensorFlow 和 Keras：由Google开发，非常适合构建深度学习模型。

• PyTorch：由Facebook开发，提供了灵活的张量操作和自动求导功能。

• Scikit-learn：适合传统的机器学习任务。

2. 数据准备

• 数据收集：收集或获取你的数据集。

• 数据清洗：处理缺失值、异常值等。

• 数据预处理：如归一化、标准化、编码等。

• 数据分割：通常分为训练集、验证集和测试集。

3. 模型设计与实现

根据任务选择合适的模型架构。例如，对于图像分类可以使用卷积神经网络（CNN），对于序列数据可以使用循环神经网络（RNN）或长短期记忆网络（LSTM）。

示例：使用TensorFlow和Keras构建一个简单的CNN模型

import tensorflow as tf
from tensorflow.keras import layers, models

# 创建模型
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))  # 假设是10类分类问题

# 编译模型
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

4. 训练模型

# 假设 X_train 和 y_train 是你的训练数据和标签
model.fit(X_train, y_train, epochs=10, validation_split=0.2)

5. 模型评估与调优

• 评估：使用测试集评估模型性能。

• 调优：根据性能反馈调整模型结构或参数。

• 超参数调优：使用如Grid Search、Random Search或Bayesian Optimization等技术来优化超参数。

6. 模型部署与使用

• 保存模型：使用model.save()保存模型。

• 加载模型：在其他应用中加载模型进行预测。

• 部署：将模型部署到生产环境，例如使用Flask或FastAPI创建API服务。

示例：使用Flask部署模型

from flask import Flask, request, jsonify
import tensorflow as tf

app = Flask(__name__)
model = tf.keras.models.load_model('path_to_your_model')  # 加载模型

@app.route('/predict', methods=['POST'])
def predict():
  data = request.get_json(force=True)  # 获取JSON格式的数据
  preds = model.predict(data['input'])  # 进行预测
  return jsonify({'prediction': preds.tolist()})  # 返回预测结果

if __name__ == '__main__':
  app.run(debug=True)

通过以上步骤，你可以在Python中开发一个复杂的大规模机器学习或深度学习模型程序。每个步骤都可能需要根据具体任务和数据进行相应的调整和优化。

• ✅基本数据类型全家福：
• int → 整数（42）
• bool → 布尔值（True/False）
• float → 浮点数（3.14）
• str → 字符串（"Hello"）
• list → 可变序列（[1,2]）
• tuple → 不可变序列（(1,2)）
• set → 无序不重复集合
• dict → 键值对字典
• complex → 复数（1+2j）
• 👉特殊成员：函数/模块/类型本身也是对象！
• 🔢不可不知的常量
• ✔️数学三杰：
• math.pi → 圆周率π
• math.e → 自然对数e
• math.inf → 无穷大∞
• ✔️布尔判官：
• True → 真值开关
• False → 假值开关
• ✔️空值代表：
• None → 表示空（类似null）
• 💡Tips：记得先import math才能调用哦！
• ⚙️运算符冷知识
• 🔀赋值技巧：
• a += 1 等价于 a = a + 1
• （右边算完赋值给左边！）
• 🧮算术运算符：
• // → 地板除（5//2=2）
• @ → 矩阵乘法（numpy常用）
• ** → 幂运算（2**3=8）
• % → 取余（-2%3=1）
• 💥隐藏知识点：fmod vs %
• math.fmod(-2,3) → -2
• -2%3 → 1
• 👉区别：负数取余时方向不同！
• ➖fmod向零取整，%向下取整
• 📝学习贴士：
• 1️⃣ type()函数可查变量类型
• 2️⃣ 浮点数比较用math.isclose()
• 3️⃣ 变量命名避开关键字
• 4️⃣ 逻辑运算符优先级：not>and>or
• 🎯新手常见误区：
• × 用is比较数值（应用==）
• × 把1.0当作整数判断
• × 忘记导入math直接调pi

1.1 文件打开与关闭

1.1.1 打开文件-open

# 打开文件（默认为只读模式）
file_path = 'example.txt'
with open(file_path, 'r') as file:
  # 执行文件操作，例如读取文件内容
  file_content = file.read()
  print(file_content)

# 文件在with块结束后会自动关闭，无需显式关闭文件

在上述示例中：

• 'example.txt' 是文件的路径和名称，你可以根据实际情况修改为你想要打开的文件。
• 'r' 表示只读模式。如果你想要写入文件，可以使用 'w' 模式，如果想要追加内容，可以使用 'a' 模式等。
• with open(...) as file : 是使用上下文管理器的方式，确保文件在使用后被正确关闭，即使在处理文件时发生异常也能保证关闭。

1.1.2 访问模式及说明

| | |
|

一、使用内置函数进行类型转换

Python提供了一系列的内置函数用于实现基本数据类型之间的转换。这些函数包括int()、float()、str()、list()、tuple()、set()等。

1. int()

int()函数用于将其他数据类型转换为整数类型。它可以将浮点数、字符串（如果字符串内容为有效的整数表示）转换为整数。例如：

print(int(3.14))  # 输出：3
print(int("42"))  # 输出：42

需要注意的是，如果字符串不能被解释为一个有效的整数，将会抛出ValueError。

2. float()

float()函数用于将其他数据类型转换为浮点数类型。它可以将整数、字符串（如果字符串内容为有效的浮点数表示）转换为浮点数。例如：

print(float(3))      # 输出：3.0
print(float("3.14")) # 输出：3.14

同样，如果字符串不能被解释为有效的浮点数，将会抛出ValueError。

3. str()

str()函数用于将对象转换为字符串表示。几乎所有对象都可以被转换为字符串，特别是那些实现了__str__()或__repr__()方法的对象。例如：

print(str(123))      # 输出："123"
print(str(3.14))     # 输出："3.14"
print(str([1, 2, 3]))# 输出："[1, 2, 3]"

详细描述：str()函数非常灵活，因为它不仅能将数值类型转换为字符串，还能将列表、元组、字典等数据结构转换为字符串。此外，自定义类对象也可以通过实现__str__()方法来定义自己的字符串表示。当调用str()函数时，Python会自动调用对象的__str__()方法，从而返回自定义的字符串表示。这在调试和输出信息时非常有用，可以让程序的输出更加直观和易于理解。

二、使用类型构造函数进行转换

Python中，类型本身也是构造函数，可以用于创建该类型的新实例。这种方法适用于list()、tuple()、set()等数据结构的转换。

1. list()

list()函数用于将可迭代对象（如字符串、元组、集合等）转换为列表。例如：

print(list("abc"))      # 输出：['a', 'b', 'c']
print(list((1, 2, 3)))  # 输出：[1, 2, 3]

2. tuple()

tuple()函数用于将可迭代对象转换为元组。例如：

print(tuple("abc"))      # 输出：('a', 'b', 'c')
print(tuple([1, 2, 3]))  # 输出：(1, 2, 3)

3. set()

set()函数用于将可迭代对象转换为集合。例如：

print(set("abc"))        # 输出：{'a', 'b', 'c'}
print(set([1, 2, 3, 2])) # 输出：{1, 2, 3}

三、显式类型转换与自定义对象的转换

在Python中，显式类型转换指的是通过用户定义的方法实现对象的自定义转换行为。对于自定义对象，可以通过实现一些特殊方法来支持类型转换。

1. 实现__int__(), __float__(), __str__()

在自定义类中，可以实现__int__()、__float__()和__str__()方法，来支持将对象转换为整数、浮点数和字符串。例如：

class MyNumber:
    def __init__(self, value):
        self.value = value
    def __int__(self):
        return int(self.value)
    def __float__(self):
        return float(self.value)
    def __str__(self):
        return str(self.value)
num = MyNumber(5.5)
print(int(num))   # 输出：5
print(float(num)) # 输出：5.5
print(str(num))   # 输出："5.5"

2. 使用自定义方法进行复杂转换

有时，转换规则可能比较复杂，不适合用内置的方法。这时，可以定义专门的方法来实现特定的转换逻辑。例如：

class Data:
    def __init__(self, data):
        self.data = data
    def to_dict(self):
        # 自定义逻辑将数据转换为字典
        return {str(i): item for i, item in enumerate(self.data)}
data = Data([10, 20, 30])
print(data.to_dict())  # 输出：{'0': 10, '1': 20, '2': 30}

四、注意事项与最佳实践

在进行类型转换时，需要注意以下几点：

1. 数据丢失风险：在某些情况下，类型转换可能导致数据丢失。例如，将浮点数转换为整数时，小数部分将会丢失。

2. 异常处理：在进行类型转换时，可能会遇到转换失败的情况（如字符串无法转换为整数）。应提前做好异常处理，如使用try-except结构来捕获转换异常。

3. 明确转换目的：在进行类型转换前，明确转换的目的和需求，选择合适的转换方法。

4. 自定义类型转换：对于复杂的数据结构和自定义对象，尽可能实现明确的转换方法，确保转换的可读性和可维护性。

通过合理使用Python中的类型转换机制，可以在程序中灵活地处理不同的数据类型和结构，提高代码的兼容性和可扩展性。

相关问答FAQs：

如何在Python中将字符串转换为整数？
在Python中，可以使用内置的int()函数将字符串转换为整数。只需将字符串作为参数传递给int()函数即可。例如，num = int("123")将字符串"123"转换为整数123。请注意，确保字符串内容是有效的数字，否则将引发ValueError异常。

Python中是否支持自定义对象的类型转换？
是的，Python支持自定义对象的类型转换。可以通过定义__str__()和__repr__()方法来实现对象与字符串之间的转换。此外，重载__int__()、__float__()等特殊方法可以实现对象与其他基本数据类型的转换。例如，定义一个类并在其中实现这些方法，就可以自定义对象的表示和转换逻辑。

在Python中如何处理类型转换时的异常？
在进行类型转换时，特别是在将字符串转换为数字时，可能会遇到异常。可以使用try和except语句来捕获这些异常。例如，在尝试将用户输入的字符串转换为整数时，可以使用以下代码：

try:
    num = int(user_input)
except ValueError:
    print("输入的不是一个有效的整数")

这种方式可以确保程序在遇到错误时不会崩溃，并能够给用户提供友好的提示。

然而，使用 eval() 函数需要谨慎，因为它可以执行任意的代码，可能导致安全风险和不受控制的行为。

1. eval() 函数的语法

eval() 函数的语法如下：

eval(expression, globals=None, locals=None)

参数：

expression 是一个字符串，表示要求值的表达式或代码。

globals 是一个可选的全局命名空间字典。

locals 是一个可选的局部命名空间字典。

下面一些示例代码，展示了 eval() 函数的使用方法和功能。

1.1 默认参数使用

1.1.1 求值表达式

result = eval("2 + 3")
print(result)  # 输出：5

上述示例中，将字符串 "2 + 3" 作为表达式传递给 eval() 函数，它会求值这个表达式并返回结果。

1.1.2 [字符串转换]为数据类型

num = eval("42")
print(type(num))  # 输出： <class 'int'>
 
string = eval("'Hello, World!'")
print(type(string))  # 输出： <class 'str'>

上述示例中，使用 eval() 将字符串转换为对应的数据类型，例如将字符串 "42" 转换为整数，将字符串 "'Hello, World!'" 转换为字符串。

1.1.3 执行代码块

code = '''
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")
'''

x = 8
eval(code)

上述示例中，将代码块作为字符串传递给 eval() 函数，然后在给定的上下文中执行这段代码。根据变量 x 的值，会打印不同的结果。

1.2  默认参数globals 和 locals 的使用

eval() 函数中的 globals 和 locals 参数用于指定代码执行时的全局和局部命名空间。这些参数允许你在 eval() 中使用特定的变量和函数。

1.2.1 使用全局命名空间

x = 5
result = eval("x + 2", globals())
print(result)  # 输出：7

上述示例中，我们使用 globals() 函数将当前的全局命名空间传递给 eval()。这样，eval() 中的代码可以访问全局变量 x。

1.2.2 使用局部命名空间

def add(a, b):
    return a + b
 
locals_dict = {'a': 2, 'b': 3}
result = eval("add(a, b)", globals(), locals_dict)
print(result)  # 输出：5

在这个例子中，我们使用 locals_dict 字典作为局部命名空间传递给 eval()。这样，eval() 中的代码可以访问局部变量 a 和 b，以及 add() 函数。

1.2.3 修改局部命名空间

x = 2
locals_dict = {'x': 5}
eval("x = x + 1", globals(), locals_dict)
print(locals_dict['x'])  # 输出：6

示例中，我们将 locals_dict 字典作为局部命名空间传递给 eval()。eval() 中的代码将修改局部变量 x 的值。通过在 eval() 之后检查 locals_dict['x']，我们可以看到变量 x 的值已经被修改为 6。

1.3 使用总结

需要注意的是，eval() 函数默认情况下使用调用 eval() 的上下文的命名空间。如果未提供 globals 和 locals 参数，eval() 将使用默认的命名空间。

使用 globals 和 locals 参数时，应该谨慎选择要传递的命名空间，并确保代码中可以访问所需的变量和函数。同时，需要注意在 eval() 中执行的代码对命名空间的修改是否会影响到后续代码的行为。

eval() 函数可以执行任意有效的 Python 代码，包括函数调用、循环和文件操作等。因此，在使用 eval() 函数时，应该确保字符串是可信的，并避免执行不安全的代码。

2. 异常处理

如果在 eval() 中的表达式或代码中存在语法错误或运行时错误，eval() 将引发相应的异常。因此，在使用 eval() 时，应该使用适当的异常处理机制来捕获和处理可能出现的异常。

3. eval() 的替代方法

在某些情况下，可以考虑使用更安全和受控制的替代方法来执行特定的任务。例如，如果需要执行简单的数学运算，可以使用 eval() 的更安全的替代方法 ast.literal_eval()。如果需要执行特定的函数调用，可以使用 getattr() 函数来获取对象的属性或方法，并进行调用。

4. 开发时注意事项

在实际编程中，应该谨慎使用 eval() 函数，并评估是否有其他更安全和可控制的替代方法可用。如果必须使用 eval()，则应该遵循以下最佳实践：

a.验证和过滤输入：确保将不受信任的输入数据进行验证和过滤，以防止注入恶意代码。

b.限制执行环境：限制 eval() 的执行环境，仅允许访问必要的变量和函数。

c.使用异常处理：使用适当的异常处理机制来捕获和处理可能的异常情况。

d.文档和注释：在代码中提供清晰的文档和注释，以说明为什么需要使用 eval()，并确保其他开发人员了解代码的含义和潜在的风险。

5. 总结

eval() 函数可以将字符串作为 Python [表达式求值]，将字符串转换为数据类型，执行代码块等。它在某些情况下可以方便地处理动态代码和计算，但需要谨慎使用以避免安全风险。

1. 顶级异常类

• BaseException：所有异常的基类。通常不直接捕获这个异常，因为它会捕获像 SystemExit、KeyboardInterrupt 等控制流异常。
• Exception：大多数内置异常的基类，除了一些系统退出和中断相关的异常。在编写异常处理代码时，通常捕获 Exception 及其子类。

2. 常见的具体异常类

2.1 语法错误相关

• SyntaxError：当 Python 解释器遇到不符合 Python 语法规则的代码时抛出。

# 错误示例：缺少冒号
if True
    print("True")

• IndentationError：是 SyntaxError 的子类，当代码的缩进不符合 Python 规则时抛出，例如混合使用制表符和空格进行缩进。

# 错误示例：缩进不一致
if True:
    print("True")
  print("This line has incorrect indentation")

2.2 名称错误相关

• NameError：当使用一个未定义的变量名时抛出。

# 错误示例：使用未定义的变量
print(undefined_variable)

2.3 类型错误相关

• TypeError：当操作或函数应用于不兼容类型的对象时抛出，例如对整数和字符串进行加法操作。

# 错误示例：整数和字符串相加
result = 1 + "2"

• ValueError：当函数接收到正确类型但值不合适的参数时抛出，例如将一个非数字字符串转换为整数。

# 错误示例：将非数字字符串转换为整数
num = int("abc")

2.4 索引和键错误相关

• IndexError：当尝试访问序列（如列表、元组）中不存在的索引时抛出。

# 错误示例：访问超出列表长度的索引
my_list = [1, 2, 3]
print(my_list[3])

• KeyError：当尝试访问字典中不存在的键时抛出。

# 错误示例：访问字典中不存在的键
my_dict = {'a': 1, 'b': 2}
print(my_dict['c'])

2.5 文件操作错误相关

• FileNotFoundError：当尝试打开一个不存在的文件时抛出。

# 错误示例：打开不存在的文件
with open('nonexistent_file.txt', 'r') as f:
    pass

• PermissionError：当尝试对文件或目录进行操作，但没有足够的权限时抛出。

2.6 算术错误相关

• ZeroDivisionError：当尝试用零作为除数进行除法运算时抛出。

# 错误示例：除以零
result = 1 / 0

• OverflowError：当算术运算结果太大而无法表示时抛出。

3. 异常处理

try-except 语句用于捕获和处理异常，能让你在出现异常时采取相应的措施，而不是让程序直接终止。

基本语法

try:
    # 可能会抛出异常的代码块
    # ...
except ExceptionType:
    # 当指定类型的异常发生时执行的代码块
    # ...

• try 块：包含可能会抛出异常的代码。Python 会尝试执行这个代码块中的所有语句。
• except 块：当 try 块中的代码抛出指定类型的异常时，程序流程会跳转到对应的 except 块中执行。ExceptionType 是要捕获的异常类型，如果不指定，会捕获所有继承自 Exception 类的异常。

示例

try:
    num = 1 / 0  # 这里会抛出 ZeroDivisionError 异常
except ZeroDivisionError:
    print("不能除以零！")

在这个例子中，try 块里的 1 / 0 会抛出 ZeroDivisionError 异常，由于 except 块指定了要捕获 ZeroDivisionError 异常，所以程序会执行 except 块中的代码，输出“不能除以零！”。

捕获多种异常

可以使用多个 except 块来捕获不同类型的异常。

try:
    num = int("abc")  # 这里会抛出 ValueError 异常
    result = 1 / num
except ValueError:
    print("输入的不是有效的数字！")
except ZeroDivisionError:
    print("不能除以零！")

在这个例子中，try 块里的 int("abc") 会抛出 ValueError 异常，程序会执行对应的 except ValueError 块中的代码，输出“输入的不是有效的数字！”。

捕获多个异常类型在一个 except 块中

可以在一个 except 块中捕获多种不同类型的异常。

try:
    num = int("abc")  # 可能抛出 ValueError
    result = 1 / num  # 可能抛出 ZeroDivisionError
except (ValueError, ZeroDivisionError):
    print("发生了值错误或除零错误！")

获取异常信息

可以通过 except 块中的异常对象来获取具体的异常信息。

try:
    num = int("abc")
except ValueError as e:
    print(f"发生了值错误: {e}")

在这个例子中，as e 将捕获到的 ValueError 异常对象赋值给变量 e，通过 e 可以获取异常的详细信息并打印出来。

else 子句

try-except 语句可以有一个可选的 else 子句，当 try 块中没有抛出任何异常时，会执行 else 块中的代码。

try:
    num = int("123")
except ValueError:
    print("输入的不是有效的数字！")
else:
    print(f"转换后的数字是: {num}")

finally 子句

try-except 语句还可以有一个可选的 finally 子句，无论 try 块中是否抛出异常，finally 块中的代码都会被执行。一般用于执行收尾工作比如关闭文件。

try:
    num = int("123")
except ValueError:
    print("输入的不是有效的数字！")
else:
    print(f"转换后的数字是: {num}")
finally:
    print("无论是否发生异常，这里的代码都会执行。")

嵌套 try-except

try-except 语句可以嵌套使用，即在 try 块或 except 块中可以再包含另一个 try-except 语句。

try:
    try:
        num = int("abc")
    except ValueError:
        print("内部 try 块中发生了值错误！")
except:
    print("外部 try 块捕获到异常！")

raise from

是一种异常链机制，用于在抛出新异常时保留原始异常的信息，这有助于调试，让开发者可以更清晰地了解异常发生的完整过程。

1. 语法

   try:
       # 可能引发异常的代码
       ...
   except SomeException as original_exception:
       # 处理原始异常，然后抛出新的异常，并关联原始异常
       raise NewException("新异常的描述信息") from original_exception

   在上述语法中，SomeException 是原始异常类型，original_exception 是捕获到的原始异常对象。NewException 是要抛出的新异常类型，通过 raise ... from ... 语句将新异常与原始异常关联起来。

2. 使用场景

• 封装异常：当你在编写一个库或者模块时，可能不希望将底层的具体异常暴露给调用者，而是抛出一个更高级别的、更具业务含义的异常。使用 raise from 可以在抛出新异常的同时保留底层异常的信息，方便后续调试。
• 异常转换：将一种类型的异常转换为另一种类型的异常，同时保留原始异常的上下文。

3. 举个例子
   想象你在玩一个游戏关卡，每关结束都有个报告。在 Python 里，代码运行时也会遇到各种“状况”（异常）。

   正常情况下，一个异常抛出就完事儿了，你只知道这一个问题。但有时候，一个异常是由另一个异常引发的，就像第二关的失败是因为第一关遗留了个小失误。

   raise from 就是用来记录这种关联的。当你用 raise from 抛出新异常时，它会把之前那个异常（原始异常）的“小报告”也带上。这样，开发者查看错误信息时，就能清楚知道是哪个“小失误”引发了后面的问题，就像能看到游戏关卡间的连锁反应，更方便找出代码里的毛病。

   比如：

   try:
       num = int('abc')  # 这里抛出 ValueError
   except ValueError as e:
       raise TypeError('新的类型错误') from e

   这里先有个 ValueError，然后用 raise from 抛出 TypeError 时带上了前面 ValueError 的信息，方便排查错误。

assert

assert 语句是一种调试辅助工具，用于在代码中检查某个条件是否为真。如果条件为真，程序会继续正常执行；如果条件为假，assert 语句会抛出一个 AssertionError 异常，从而帮助快速定位程序中的问题。

1. 语法
   assert 语句的基本语法如下：

assert condition, message

• condition：这是一个布尔表达式，也就是一个最终会计算出 True 或者 False 的表达式。assert 会对这个表达式进行求值。
• message：这是一个可选的参数，是一个字符串。当 condition 为 False 时，message 会作为 AssertionError 异常的错误信息被抛出。如果不提供 message，则抛出的 AssertionError 异常不会附带额外信息。

2. 示例
   简单的 assert 语句

   x = 5
   assert x > 10, "x 应该大于 10"

   在这个例子中，x 的值为 5，条件 x > 10 的计算结果为 False，因此 assert 语句会抛出一个 AssertionError 异常，并且异常信息为 "x 应该大于 10"。

   不提供错误信息的 assert 语句

   y = -1
   assert y >= 0

   这里条件 y >= 0 为 False，assert 会抛出 AssertionError 异常，但由于没有提供额外的错误信息，所以异常中不会附带具体的提示内容。

3. 使用场景

• 调试代码：开发过程中，可以使用 assert 语句来验证程序中的一些假设是否成立。例如在调用一个函数之前，你可能期望某个变量具有特定的值或范围，这时就可以使用 assert 进行检查。

  def divide(a, b):
      assert b != 0, "除数不能为零"
      return a / b

result = divide(10, 0) # 会触发 AssertionError

• 验证数据的有效性：当你从外部获取数据（如文件、用户输入等）时，可以使用 assert 来确保数据符合预期的格式或范围。

  data = [1, 2, 3, 4, 5]
  assert all(isinstance(i, int) for i in data), "数据中应全为整数"

注意：

• assert 可以被禁用：在 Python 中，当你以优化模式（使用 -O 或 -OO 选项运行 Python 解释器）运行代码时，所有的 assert 语句都会被忽略，不会进行条件检查。因此，assert 不应该用于执行必要的程序逻辑或数据验证，而主要用于调试目的。
• 性能影响：虽然 assert 语句在正常情况下执行速度很快，但在复杂的程序中，如果有大量的 assert 语句，可能会对性能产生一定的影响，因此在生产环境中应该谨慎使用。

• 定义数据的class：修改数据中的某一个字段，操作json或者直接针对class的成员变量进行修改。
• 不定义数据的class： 直接操作json(dict)，来构造或者修改数据。
  两种方式各有优缺点, 对于业务上有明确业务含义的数据，比如请求数据，建议使用第一种方式，对数据进行建模和定义； 而临时的数据构造，可以使用第二种方式，不需要额外定义一些结构，成本会低一些。在使用于第一种方法时，就会涉及到python中json数据与类对象的相互转化的。

此篇文章，会通过4种方式来展示json数据与python的类对象相互转化：

• python的原生方法
• jsonpickle
• cattrs和attrs库
• pydantic库
  以下的例子，都使用同一个class，并且使用了嵌套的json，算是一个稍微复杂的场景。

class Address():
    def __init__(self, street, number):
        self.street = street
        self.number = number
 
 
class User():
    def __init__(self, name, address):
        self.name = name
        self.address = Address()

一、python的原生方法
json to python class的参考：https://stackoverflow.com/a/28352366

python class to json的参考: https://stackoverflow.com/a/10252138

以下为代码示例:

import json
from json import JSONEncoder
 
class Address():
    def __init__(self, street, number):
        self.street = street
        self.number = number
 
class User():
    def __init__(self, name, address):
        self.name = name
        self.address = Address(**address)  
 
class MyEncoder(JSONEncoder):
    def default(self, o):
        return o.__dict__
 
if __name__ == '__main__':
    js = '''{"name":"Cristian", "address":{"street":"Sesame","number":122}}'''
    j = json.loads(js)
    print(j)
    u = User(**j)
    print(json.dumps(u, cls = MyEncoder))
    print(json.dumps(u.__dict__))

执行代码后，输出

{'name': 'Cristian', 'address': {'street': 'Sesame', 'number': 122}}
{"name": "Cristian", "address": {"street": "Sesame", "number": 122}}
Traceback (most recent call last):
***********
    raise TypeError(f'Object of type {o.__class__.__name__} ‘  
TypeError: Object of type Address is not JSON serializable

json转class object时，使用u = User(**j); class object转成json时，对于一级的json，直接使用u.dict就可以转成json，而对于嵌套的json，必须使用自定义的JSONEncoder才能转成功。

在以上的转化中，使用了两个python的特性，简单解释一下:

双星号() : 在函数参数中使用时，用于函数参数的解包，使用双星号()来解包一个字典的键值对到一个函数的关键字参数中。

def greet(name, age):
    print(f"Hello, my name is {name} and I am {age} years old.")
person = {'name': 'Alice', 'age': 30}
greet(**person) # 等价于 greet(name='Alice', age=30)

dict属性: dict属性是一个内置属性，包含了对象的属性及其值，以字典的形式存储。上面的例子中，使用dict属性，无法将address的值打印出来，就是因为值为Address对象，而不是一个字符串。
优点：

不需要引入其他的三方库
缺点：

一级的json数据没有什么问题，多级的json数据，to_json转化时，支持的不好，需要自己定义一个JSONEncoder才能转json成功, 如果更复杂的json，可能会失败。
二、jsonpickle库
jsonpickle在github上的介绍如下:

"Python library for serializing any arbitrary object graph into JSON. It can take almost any Python object and turn the object into JSON. Additionally, it can reconstitute the object back into Python.”

这段话，就说明了这是一个专注于class object -> json的库，而json->object的功能则只支持调用jsonpickle得到的json，再转回class object.

以下为代码示例:

import json
import jsonpickle
class Address():
    def __init__(self, street, number):
        self.street = street
        self.number = number
class User():
    def __init__(self, name, address):
        self.name = name
        self.address = Address(**address)
 
if __name__ == '__main__':
    js = '''{"name":"Cristian", "address":{"street":"Sesame","number":122}}'''
    j = json.loads(js)
    # jsonpickle中没有一个类似jsonpickle.decode(j, class = User)的方法，所以只能拿第一种方法初始化class
    u = User(**j)
    print(jsonpickle.encode(u, unpicklable=False))
    jp = jsonpickle.encode(u)
    print(jp)
    u2 = jsonpickle.decode(jp)
    print(u2.__class__)

执行后的输出为：

{"name": "Cristian", "address": {"street": "Sesame", "number": 122}}
{"py/object": "__main__.User", "name": "Cristian", "address": {"py/object": "__main__.Address", "street": "Sesame", "number": 122}}
<class '__main__.User'>

一些说明：

1. jsonpickle中没有一个类似jsonpickle.decode(j, class = User)的方法，所以只能拿第一种方法初始化class

转成json时, 调用jsonpickle.encode方法，传入参数unpicklable=False时，返回值不包含把json数据转回python object的信息，得到一个通用的json字符串

3. 转成json时, 调用jsonpickle.encode方法，默认unpicklable=True时，返回值中包含python object的信息，比如对象的类，输出中的"py/object": "main.User"就是这些信息

json转成python object时， 必须使用unpicklable=True时的json数据，jsonpickle在json转object时的局限性就在于此。

优点:

object -> json很强大，可以直接使用
缺点:

json转object时， 比较鸡肋，基本不能直接使用
三、cattrs和attrs库
attrs库: https://github.com/python-attrs/attrs。 attrs可以简化类的定义的管理，使用后这些类将自动获得一些有用的特性，如初始化方法（init）、repr方法、eq和hash等。实际使用的话，最基础的只需要知道attr.s和attr.ib两个方法即可。

cattrs库: https://github.com/python-attrs/cattrs。cattrs（即“conversion attrs”）是一个与attrs紧密集成的库，它提供了对象到字典（或其他数据结构）的序列化和从字典（或其他数据结构）到对象的反序列化功能。

以下为代码:

import json
import attr
import cattrs
 
@attr.s
class Address:
    street = attr.ib(type = str)
    number = attr.ib(type = int)
 
@attr.s
class User:
    name = attr.ib(type = str)
    address = attr.ib(type=Address) # adrress 为Addres类型
 
if __name__ == "__main__":
    js = '''{"name":"Cristian", "address":{"street":"Sesame","number":122}}'''
    j = json.loads(js)
    u = cattrs.structure(j, User)
    print(u, u.__class__)
    print(cattrs.unstructure(u))

执行后，输出:

User(name='Cristian', address=Address(street='Sesame', number=122), <class '__main__.User'>)
{'name': 'Cristian', 'address': {'street': 'Sesame', 'number': 122}}

一些说明:

attr.s是一个装饰器，用来标记类为attrs类。
attr.ib是一个用于声明属性的工厂函数, 比如attr.ib(type=str)表示一个类型为str的属性。在类定义中，使用attr.s和attr.ib基本就够了，在attr.ib方法中，还有很多参数，比如默认值、validator等，可以用于检查成员是不是满足定义的属性。
cattrs.structure和cattrs.unstructure用来将attrs类和json dict之间的相互转化，含义非常的直观。
优点:

使用cattrs和attrs结合使用，在与json的转化中，非常简单和强大，而且结构化的数据定义非常直观。
四、pydantic库
Pydantic库: https://github.com/pydantic/pydantic。数据验证和解析的Python库，提供类型注解、数据验证和模型转换功能。使用Pydantic可以定义模型类，验证输入数据并转换为字典或JSON。

直接上代码:

import json
from pydantic import BaseModel, Field
 
class Address(BaseModel):
    street: str   #pydantic使用类型注解, 来确保使用正确的类型提示来定义字段
    number: int
 
class User(BaseModel):
    name: str
    address: Address
 
if __name__ == "__main__":
    js = '''{"name":"Cristian", "address":{"street":"Sesame","number":122}}'''
    j = json.loads(js)
    u = User.parse_obj(j)
    print(u, u.__class__)
    print(u.json())

执行代码后，输出:

name='Cristian' address=Address(street='Sesame', number=122) <class '__main__.User'>
{"name": "Cristian", "address": {"street": "Sesame", "number": 122}}

一些说明:

• 通过继承pydantic的BaseModel来定义类，类型注解来定义字段的类型，创建符合需求的数据模型(这里也能看出数据模型是pydantic的核心)。

• 继承BaseModel，直接使用parse_obj方法就可以将json数据转为class object, 直接使用json()方法就可以转为json数据。
  优点:

• 在与json的转化中，非常简单和强大，直接调用结构体的方法就可，而且结构化的数据定义非常直观

总结：

• 针对python中类对象和json的相关转化问题， 本文介绍了4种方式，涉及了三个非常强大的python库jsonpickle、attrs和cattrs、pydantic，但是这些库的功能并未涉及太深。在工作中，遇到实际的问题时，可以根据这几种方法，灵活选取。

再回到结构化测试数据的构造，当需要对数据进行建模时，也就是赋予数据业务含义，pydantic应该是首选，目前来看，pydantic的生态非常活跃，各种基于pydantic的工具也非常多，建议尝试。

1. 基本语法

pass 不执行任何操作，直接跳过。例如：

if True:
    pass  # 什么都不做

2. 常见用法

(1) 作为占位符

当你写代码时，某些逻辑还未完成，可以使用 pass 作为占位符，确保程序不会因缺少代码块而报错：

def my_function():
    pass  # 将来实现这个函数

(2) 空循环

需要一个循环，但暂时不需要任何操作时：

for i in range:
    pass  # 循环什么也不做

(3) 空类定义

在定义一个类时，暂时还没有具体实现：

class MyClass:
    pass  # 占位，稍后[添加属性]和方法

(4) 异常处理占位

在处理异常时，暂时不做任何处理：

try:
    x = 10 / 0
except ZeroDivisionError:
    pass  # 暂时忽略除以零的错误

3. 为什么不用注释代替？

• 语法规则：在需要语句的地方必须有实际代码，而注释不会被解释器识别为语句。
• 代码可运行：pass 确保程序不会因缺少代码块而出错。

• 获得最大值：max()

  max(list)

• 获得最小值：min()

  min(list)

• 删除：del()

  例：定义一个list型数据，data = [1,2,3,4,5,6]

1.del(data):删除整个list。

2.del(data[i]):删除data中索引为i个数据

3.del(data[i:j]):删除data中第i个数据到第j个数据之前（不含j）的数据

• 获得长度：len()

  len(list)

• 获得总和：sum()

  sum(list)

用于任何数据类型

• **原样输出：print **

• 单行注释：

  • #注释内容 快捷键： ctrl+/

• 多行注释：

  • ""“注释内容”"" 也可以用单引号 ‘’‘注释内容’’'

• print(type(a))输出a的类型

• 输入函数

  • **a=input(“提示内容”) 赋给a值 是字符串 **
  • 用强制转换将a变成其他类型 如：int(a) 变成整型

• 倒序：

  a=[3,1,2,5,4]
  a.sort(reverse=True)
  print(a)  倒序

数据类型介绍

• 字符串：str

  %s 字符串型

• 数字类型：整型 int 浮点型 float

  %d 整型
  %f  浮点型

• 布尔类型：1=true 0=false

• 列表：list =[1,2,3]

• 元祖：tuple= (1,2)

• 字典：dict = {“name”:“123”,“age”:18}

• 集合：set = {1,2,3,4}

if语句

if 条件一:
   print()
elif 条件二：
  print()
else :
  print()

字符串操作：my="hello world hello python"

• 切片

  name="abcdef"
  输出下标为0  print(name[0])

切片： 范围是左闭右开！！！

• print(name[0:3])   结果：abc
• print(name[0:5:2] 结果：ace
• print(name[0👎2] 结果：ace
• print(name[5:0:-2] 结果：fdb
• print(name[5:0:-1] 结果:fedcb
• print(name[:3] 结果：abc

• find():检测字符串里是否包含你要查询的字符串

  print(my.find("python"))
  如果存在返回开始的索引值（也就是下标）
  不存在返回值为-1

• index():检测你设定的字符串长度里是否存在你要查询的字符串

  print(my.index("py",0,25))
  如果存在返回开始的索引值，否则报错，index里的第一个数字参数是起始，后一个是终止的索引值-1

• count:查询出现的次数

  print(my.count("l"))
  结果为5

• replace() 替换

  my_str.replace("l","r",2)  将l替换为r 两次

• split() 切片

  以str为分隔符切片mystr,如果maxsplit有指定值，则仅分割maxsplit个字符串
  格式：my_str.split(str=" ",2)
  my_str.split(" ")  以空格为切片条件
  结果为：['hello','world','hello','python']为列表结构
  str="qaqwrwrwee"
  print(str.split("w",2))
  结果为：['qaq','r','rwee'] 2表示切两次  以w为切点  结果没有切点

• startswith()

  检查字符串是否以( )开头 是返回True 不是返回False
  my_str.startswith("hello") 结果为：True

• endswith() 查询是否以什么什么结尾

  print(my.endswith("hello"))

• upper()：转换my中的小写字母为大写(要有个变量接收，原字符串不改变)

  res=my.upper()
  print(res)

• lower():转换my中的大写字符为小写(要有个变量接收，原字符串不改变)

  res=my.lower()
  print(res)

• title():把字符串的每个单词首字母大写(要有个变量接收，原字符串不改变)

  res=my.title()
  print(res)

• capitalize():把字符串的第一个字符大写(要有个变量接收，原字符串不改变)

  res=my.capitalize()
  print(res)

• splitlines():按照行分隔，返回一个包含各行作为元素的列表

  my_name="hello\nworld"
  print(my_name) 
   结果为：
  hello
  world
  print(my_name.spiltlines())
  结果为：
  ["hello","world"]

• isalpha():如果my所有字符都是字母 则返回True,否则返回False

  print(my.isalpha())
  结果为：True

• isdigit()：如果my只包含数字则返回True 否则返回False

  print(my.isdigit())
  结果为：False

• isalnum():如果my所有字符都是字母或数字则返回True,否则返回False

  print(my.isalnum())
  结果为True

• isspace():如果my中只包含空格，则返回True,否则返回False

  print(my.isspace())
  结果为：False

• rfind():从右往左找你要查找的字符串 找到后返回下标值

  a=rfind('.')  用来取文件的后缀名

• join:用来将列表里的元素连接变为字符串

  a=[1,2,3,4,'3']
  b=','.join([str(x) for x in a])
  print(b)

结果为：1,2,3,4,3

列表里的元素每个必须都为str

列表：

• 增加（append,extend,insert）

  • append:

    A=[1,2,3]
    A.append("4")
    结果为：A=[1,2,3,"4"]

  • extend:

    a=[1,2]  b=[3,4]
    a.extend(b)
    结果为 a=[1,2,3,4]
    a.append(b)
    结果为 a=[1,2,[3,4]]

  • insert:

    a=[0,1,2]
    a.insert(1,3)
    结果为 a=[0,3,1,2]

• 修改元素：

  a=[1,2,3]
  a[0]=3
  结果为：a=[3,2,3]

• 查找元素：

  • in判断存在

    name="123456789"
    find="123"
    if find in name:
       print("存在")
    else:
      print("不存在")

  • not in判断不存在

  • index和count和在字符串里的应用一样

删除元素：list=[1,2,3]

• del list[1]

• list.pop()删除最后一个元素

• list.remove(1)

排序

• list.sort() 从小到大排序

• list.sort(reverse=Ture)从大到小排序

• list.reverse()反转

列表的嵌套

list=[1,[2,3],4]
list[1].insert(1,5)结果为list[1,[2,5,3],4]

字典：

• 字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值

  info={"name":'师玲珑',"age":18}
  print(info["name"])  结果为：师玲珑

• 修改数据：

  info["age"]=20

• 删除数据：

  del info["age"]

info.clear()删除所有数据

• 查找数据：

  ###如果info中不存在'age'这个键，我就让他返回默认值18
  age=info.get('age',18)
  print(age)

• 更改键名

  思路：先删除原键值对，保存值，然后以新键插入字典

格式：dict[newkey] = dict.pop(key)

d = {'a':1, 'aa':11}  
d['b'] = d.pop('a')  
d['bb'] = d.pop('aa')  
print(d)  
[#输出：] {'b': 1, 'bb': 11}

• len()测量字典中，键值对的个数

• **print(info.keys()) 返回一个包含字典所有的key列表 **

  结果为：info_keys(['name','age','sex'])

• print(info.values()) 返回一个包含字典所有的value列表

  结果为：info_values([18,20,'女'])

• **print(info.items()) 返回一个包含字典所有的键值对列表 **

  结果为：info_values([('name','age','sex'),(18,20,'女')])

• 例子：

  遍历字典的key   210 480  690
  for key in info.keys():
        print(key)

  遍历字典的values
  for value in info.values():
      print(value)

  遍历字典的items
  for item in info.items():
    print(item)
  或者
  for key,value in info.items()
      print(key,value)

  如何实现带下标的遍历
  chars=[1,2,3,4]
  for i,chr in enumerate(chars):
      print(i,chr)
  结果为：
  0 1
  1 2
  2 3
  3 4

Python 拥有多种内置[数据类型]，这些类型满足了各种编程需求，从简单的数据存储到复杂的数据结构表示。

1. 数值类型（Numeric Types）

整数（int）：整数在 Python 中可以表示任意大小的整数值，不受特定字节数的限制。例如，x = 10就定义了一个简单的整数变量。整数可用于计数、索引等多种场景。

浮点数（float）：用于表示带有小数点的数字，采用 IEEE 754 双精度浮点数格式。如y = 3.14。浮点数在科学计算、金融计算等需要处理小数的场景中非常有用。

复数（complex）：以a + bj的形式表示，其中a为实部，b为虚部，j表示虚数单位。例如，z = 2 + 3j。复数在数学和工程领域的特定计算中发挥作用。

2. 序列类型（Sequence Types）

列表（list）：列表是一种可变的有序序列，可以包含不同类型的元素。例如，my_list = [1, 'hello', True]。通过索引可以访问列表中的元素，并且可以对列表进行修改、添加或删除元素等操作。

元组（tuple）：元组是不可变的有序序列，与列表类似，但一旦创建就不能修改。如my_tuple = (1, 'world', False)。元组常用于表示固定结构的数据，如函数返回多个值时。

字符串（string）：字符串是由字符组成的不可变序列。在 Python 中，字符串可以使用单引号、双引号或三引号（用于多行字符串）来表示。例如，s = "Python is great"。字符串支持多种操作，如切片、连接、查找等。

3. 映射类型（Mapping Types）

字典（dictionary）：字典是一种无序的键 - 值对[数据结构]，其中键必须是唯一的。例如，my_dict = {'name': 'John', 'age': 25}。通过键可以快速查找对应的值，常用于存储和查询相关联的数据。

4. 集合类型（Set Types）

集合（set）：集合是无序的、不包含重复元素的数据结构。例如，my_set = {1, 2, 3}。集合支持交集、并集、差集等操作，可用于数据去重、元素关系判断等场景。

5. 布尔类型（Boolean Type）

布尔类型只有两个值：True和False。它在条件判断、逻辑运算中起着关键作用。例如，x = 5; y = 10; result = x < y，这里result的值为True。

二、常用内置常数（Built - in Constants）

Python 提供了一些内置常数，这些常数在编程过程中具有特殊的意义和用途。

None：表示空值或者缺失值。在函数没有明确返回值时，默认返回None。例如，一个函数只是执行一些操作而不需要返回特定结果时，可以使用None。

True和False：这是布尔类型的两个值，在逻辑判断中使用。例如，在if语句中判断条件的真假。

Ellipsis（...）：这个常数在特定的语法结构中有特殊用途，比如在定义多维数组时可以作为占位符。

三、常用内置运算符（Built - in Operators）

1. 算术运算符

加法（+）：用于数值相加，也可用于字符串连接和列表、元组等序列的连接。例如，2 + 3得到5，"hello" + "world"得到"helloworld"。

减法（-）：用于数值相减。如5 - 2得到3。

乘法（*）：对于数值是乘法运算，对于字符串和序列可以实现重复操作。例如，3 * 4得到12，"a" * 3得到"aaa"。

除法（/）：执行浮点数除法，结果总是浮点数。例如，5 / 2得到2.5。

2. 比较运算符

等于（==）：判断两个值是否相等。例如，2 == 2返回True，"hello" == "world"返回False。

不等于（!=）：判断两个值是否不相等。

大于（>）、小于（<）、大于等于（>=）、小于等于（<=）：用于比较数值的大小关系，也可以用于比较字符串按照字典序的大小关系。

3. 逻辑运算符

与（and）：当两个操作数都为True时，结果为True；否则为False。例如，True and False得到False。

或（or）：只要有一个操作数为True，结果就为True。例如，True or False得到True。

非（not）：对操作数取反，not True得到False，not False得到True。

四、整除（Integer Division (//)）

整除运算符//用于计算两个数相除并向下取整得到整数结果。例如，7 // 3得到2，-7 // 3得到-3。整除在处理需要得到整数部分结果的场景中非常有用，比如计算将一定数量的物品平均分配到若干个容器中时，每个容器能得到的物品数量。与普通除法（/）不同，//操作更关注整数部分的结果，并且在处理负数时遵循向下取整的规则。

五、模运算或余数运算符（%）

模运算（%）用于计算两个数相除的余数。例如，7 % 3得到1，10 % 2得到0。在很多实际应用中都非常有用，比如判断一个数是否能被另一个数整除（余数为 0 时表示能整除），或者在循环队列、哈希表等数据结构中确定索引位置等场景。例如，在一个长度为n的循环队列中，如果当前位置为pos，要向前移动m个位置，可以通过(pos + m) % n来计算新的位置。

六、类型影响语义（Types Affect Semantics）

在 Python 中，数据类型对操作的语义有着重要的影响。

数值类型：不同的数值类型之间进行操作时，可能会发生类型转换。例如，整数和浮点数进行算术运算时，整数会自动转换为浮点数，然后进行计算。这确保了计算结果的准确性和一致性。

序列类型：对于列表、元组等序列类型，虽然它们有一些相似的操作（如索引、切片），但由于列表是可变的而元组是不可变的，在对它们进行修改操作时语义完全不同。对列表可以使用诸如append、pop等方法来改变列表的内容，但这些操作在元组上是不允许的。

布尔类型与其他类型：布尔类型在逻辑运算中的语义是明确的，但当与其他类型进行操作时，也会遵循一定的规则。例如，在条件判断中，很多数据类型都可以被转换为布尔值，非零数值、非空字符串、非空列表等都被视为True，而0、""、[]等被视为False。

七、运算符优先级（Operator Order）

Python 中的运算符有明确的优先级顺序。当一个表达式中包含多个不同类型的运算符时，按照优先级顺序进行计算。

括号优先级最高：可以使用括号来改变运算顺序，括号内的表达式先进行计算。例如，(2 + 3) * 4，先计算2 + 3得到5，然后再乘以4得到20。

算术运算符优先级：先乘除后加减。例如，2 + 3 * 4，先计算3 * 4 = 12，然后再加上2得到14。其中，幂运算（**）优先级高于乘除运算。

比较运算符优先级低于算术运算符：例如，2 + 3 > 4，先计算2 + 3 = 5，然后再比较5 > 4得到True。

逻辑运算符优先级：not的优先级最高，然后是and，最后是or。例如，True or False and not True，先计算not True得到False，然后False and False得到False，最后True or False得到True。

八、短路求值（Short - Circuit Evaluation）

短路求值是逻辑运算符and和or的一个重要特性。

and的短路求值：当使用and连接两个表达式时，如果第一个表达式为False，则不会再计算第二个表达式，因为整个表达式必然为False。例如，False and some_function()，这里some_function()不会被调用。

or的短路求值：当使用or连接两个表达式时，如果第一个表达式为True，则不会再计算第二个表达式，因为整个表达式已经为True。例如，True or some_function()，some_function()不会被调用。这种特性在编写条件判断和优化代码性能时非常有用，可以避免不必要的计算。

Python 的数据类型和操作是其编程的基础，深入理解这些概念对于编写高效、准确的 Python 程序至关重要。

一. 集合的[基本操作]

1. 创建集合

使用大括号 {} 来定义集合：

my_set = {1, 2, 3, 4, 5}
print(my_set)  # 输出: {1, 2, 3, 4, 5}

使用 set() 函数 来创建集合，尤其当需要从其他数据类型（如列表或元组）转换时：

my_list = [1, 2, 2, 3]
my_set = set(my_list)
print(my_set)  # 输出: {1, 2, 3}（去掉重复元素）

2. 添加[集合元素]

使用 add() 向集合添加单个元素：

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}

3. 删除集合元素

使用 remove() 删除指定元素。如果元素不存在，会引发 KeyError 错误：

my_set = {1, 2, 3, 4}
my_set.remove(3)
print(my_set)  # 输出: {1, 2, 4}

使用 discard() 删除指定元素。如果元素不存在，不会引发错误：

my_set = {1, 2, 3, 4}
my_set.discard(5)  # 即使 5 不在集合中，也不会报错
print(my_set)  # 输出: {1, 2, 3, 4}

使用 pop() 从集合中随机删除并返回一个元素（集合是无序的，所以删除的元素是随机的）：

my_set = {1, 2, 3, 4}
element = my_set.pop()
print(element)  # 输出删除的随机元素
print(my_set)  # 输出剩余的集合

4. [清空集合]

使用 clear() 清空集合：

my_set = {1, 2, 3, 4}
my_set.clear()
print(my_set)  # 输出: set()

二. 集合的数学运算

集合支持多种数学运算，像是并集、交集、差集和对称差集。

1. 并集

两个集合的并集包含所有元素（不重复）。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1 | set2  # 使用 | 运算符
print(union_set)  # 输出: {1, 2, 3, 4, 5}

2. 交集

两个集合的交集包含共同的元素。

intersection_set = set1 & set2  # 使用 & 运算符
print(intersection_set)  # 输出: {3}

3. 差集

集合 A 的差集是 A 中有而 B 中没有的元素。

difference_set = set1 - set2  # 使用 - 运算符
print(difference_set)  # 输出: {1, 2}

4. 对称差集

两个集合的对称差集是两个集合中不重复的元素。

symmetric_difference_set = set1 ^ set2  # 使用 ^ 运算符
print(symmetric_difference_set)  # 输出: {1, 2, 4, 5}

三. 集合的常用方法

len()：返回集合中元素的数量。

print(len(my_set))  # 输出: 4

in：检查元素是否在集合中。

print(3 in my_set)  # 输出: Trueprint(5 in my_set)  # 输出: False

copy()：返回集合的一个副本。

my_set_copy = my_set.copy()
print(my_set_copy)  # 输出: {1, 2, 3, 4}

四. 集合的使用场景

1. 去重

利用集合自动去除重复元素。

my_list = [1, 2, 2, 3, 3, 4]
unique_elements = set(my_list)
print(unique_elements)  # 输出: {1, 2, 3, 4}

2. 集合运算

集合的并集、交集、差集等运算非常适合处理数学问题或者数据集合的合并与筛选。

3. 成员检测

通过集合进行快速的成员检测，因其采用哈希表结构，查找速度非常快。

my_set = {1, 2, 3, 4}
if 3 in my_set:
    print("3 is in the set.")

**总结：**Python 中的集合是一个非常强大且灵活的数据结构，适用于很多场景，尤其是在需要处理独特元素、进行集合运算（如交集、并集、差集等）时非常有用。其无序、唯一、支持数学运算的特性，使得集合成为高效的数据处理工具。

1、适用场景

• 少量字符串拼接：当需要拼接的字符串数量较少时，使用加号运算符是最简单直观的方法，代码简洁易读。

 string1 = "Hello"
 string2 = "World"
 combined_string = string1 + ", " + string2 + "!"
 print(combined_string)  # 输出: Hello, World!
 ​

• 动态字符串生成：在需要根据变量动态生成字符串时，加号运算符也非常方便。

 name = "Tom"
 greeting = "Hello, " + name + "!"
 print(greeting)  # 输出: Hello, Tom!
 ​

• 拼接不同类型数据：加号运算符可以将不同类型的数据转换后的字符串拼接成一个字符串，包括文本、数字、变量等。

 name = "张三"
 age = 18
 ​
 print("我叫" + name + "，" + "今年" + str(age) + "岁。")
 # 输出：我叫张三，今年18岁。
 ​

2、优点

• 语法简洁直观：加号运算符是最基本的字符串拼接方法之一，语法简单易懂，易于理解和使用。

• 灵活性高：加号运算符可以将任意类型的字符串连接在一起，包括文本字符串、数字字符串、变量等。

• 适用性强：加号运算符可以在Python的各个版本中使用，并且适用于多种操作系统和平台。

3、缺点

• 代码不够简洁：在大量拼接字符串的情况下，使用长的加号拼接语句会使代码变得不够简洁。

• 性能低：在大量拼接字符串的情况下，加号运算符可能会导致性能问题。因为每次使用加号拼接字符串都需要创建一个新的字符串对象，这会消耗大量内存。

• 不能直接拼接数字：加号运算符不能直接将数字和字符串连接在一起。

 age = 18 print("I'm " + age + ".") ​

Python解释器会抛出 TypeError: can only concatenate str (not "int") to str 错误。

二、使用%[操作符]

1、适用场景

• 简单格式化需求：对于少量字符串的拼接，使用 % 操作符可能看起来更简洁，尤其是在不需要频繁拼接的情况下。

 name = "张三"
 age = 18
 ​
 message = "大家好，我是%s，我今年%d岁。" % (name, age)
 print(message)  # 输出：大家好，我是张三，我今年18岁。
 ​

• 旧代码兼容性：在Python 2到Python 3的迁移过程中，一些旧代码可能仍在使用 % 操作符进行字符串格式化，保持这种一致性可能有助于维护旧代码。

2、优点

• 语法简洁直观：对于简单的字符串格式化需求，%操作符的语法相对简单，易于理解和使用。

• 功能强大：%操作符支持多种占位符（如%s、%d、%f等），可以满足基本的格式化需求。

• 继承自C语言：%操作符的格式化方式继承自C语言，因此在很多编程语言中都有类似的实现，便于熟悉C语言的开发者快速上手。

3、缺点

• 可读性差：当需要拼接多个变量时，%操作符的语法可能会变得复杂，降低代码的可读性。

• 功能有限：相比于str.format()和f-string，%操作符的功能较为有限，不支持一些高级的格式化选项。

• 效率较低：在拼接大量字符串时，%操作符的效率较低，尤其是在需要频繁拼接的情况下。

三、使用format()方法

1、适用场景

• 复杂格式化需求：当需要对字符串进行复杂的格式化操作时，如指定数字的小数位数、对齐方式等，format()方法提供了强大的功能支持。

 name = "张三"
 age = 18
 ​
 message = "大家好，我是{}，我今年{}岁。".format(name, age)
 print(message)  # 输出：大家好，我是张三，我今年18岁。
 ​

• 多变量拼接：在需要拼接多个变量且这些变量可能来自不同的数据结构（如字典、列表等）时，format()方法可以通过索引或关键字参数灵活地插入变量。

• 跨版本兼容性：format()方法在Python 2.7及更高版本中都可用，因此适用于需要兼容旧版本Python的项目。

• 动态内容生成：在需要根据用户输入或其他动态内容生成字符串时，format()方法可以方便地插入变量。

2、优点

• 灵活性高：支持位置参数、关键字参数等多种方式，可以根据需要灵活地插入变量。

• 功能丰富：提供了多种格式化选项，如对齐方式、填充字符、数字格式化等。

• 代码清晰：通过占位符和参数分离的方式，使得代码更易于阅读和维护。

3、缺点

• 语法相对复杂：相比于f-string，format()方法的语法稍显冗长。

• 性能稍差：在处理大量字符串拼接时，format()方法的性能不如f-string高效。

• 调试难度：当[格式化字符串]较为复杂时，可能会增加调试的难度。

四、使用F-strings（格式化字符串）

1、适用场景

F-strings 是 Python 3.6 引入的一种字符串格式化方式，它通过在字符串前加上 f 或 F 前缀，并在大括号 {} 中包含要插入的表达式，使得字符串拼接变得更加直观和易于理解。

以下是 F-strings 的适用场景：

• 简单的字符串拼接：适用于需要将变量或表达式嵌入到字符串中的简单场景。

 name = "张三"
 age = 18
 ​
 message = f"大家好，我是{name}，我今年{age}岁。"
 print(message)  # 输出：大家好，我是张三，我今年18岁。
 ​

• 复杂的表达式：F-strings 支持直接在字符串中嵌入复杂的表达式，包括函数调用和数学运算。

 def power(x):
     return x * x
 ​
 ​
 x = 4
 result = f'{x} * {x} = {power(x)}'
 print(result)  # 输出: 4 * 4 = 16
 ​

• 多行字符串：F-strings 也可以用于多行字符串，只需在字符串前加上 f 或 F 前缀。

 name = "张三"
 age = 18
 ​
 message = f"""
 大家好，我是{name}。
 我今年{age}岁。
 """
 print(message)
 ​​

• 性能要求高的场景：F-strings 在性能上优于其他字符串格式化方法，特别是在处理大量字符串拼接时表现更优。例如：

 names = ["Alice", "Bob", "Cindy"]
 greeting = f"Names: {', '.join(names)}"
 print(greeting)  # 输出: Names: Alice, Bob, Cindy
 ​

• 需要格式化输出的场景：F-strings 支持格式化指定符，可以对表达式进行格式化输出。例如：

 number = 1234567.89
 formatted_number = f"{number:,.2f}"
 print(formatted_number)  # 输出: 1,234,567.89
 ​

2、优点

• 语法简洁直观：F-strings 允许直接在字符串中嵌入表达式，无需使用字符串拼接或格式化函数，使代码更加简洁明了。

• 可读性：通过在字符串中嵌入变量名，F-strings 消除了字符串拼接的必要性，使代码更加清晰易读。

• 可维护性：F-strings 减少了拼接字符串时可能出现的错误，如忘记添加分隔符或使用错误的格式化占位符，从而提高了代码的可维护性。

• 更高的性能：避免了多次字符串拼接带来的性能损失，提高了代码的执行效率。

• 支持内置函数和方法：F-strings 支持在大括号中嵌入复杂的表达式，包括函数调用和数学运算。

3、缺点

• 版本限制：F-strings 仅适用于 Python 3.6 及以上版本，对于旧版本的 Python 需要使用其他字符串格式化方法。

• 表达式依赖性：F-strings 中的表达式依赖于后续代码逻辑，如果表达式不正确可能会导致错误。

• 代码可读性问题：在处理大量字符串拼接时，F-strings 可能会降低代码的可读性，特别是在嵌入复杂的表达式时。

• 不能使用行内注释：F-strings 中不能直接使用行内注释，这可能会限制某些调试场景下的使用。

字符串拼接是指将多个字符串组合成一个单一的字符串。Python 提供了多种方式来实现字符串拼接：

这是最简单的拼接方式，可以直接将两个或多个字符串连接在一起。

 
a = "Hello"
b = "World"
c = a + " " + b
print(c)  # 输出: Hello World

Python 的格式化字符串提供了更灵活的方式来拼接字符串。

 
name = "Alice"
age = 30
message = f"My name is {name} and I am {age} years old."
print(message)  # 输出: My name is Alice and I am 30 years old.

• 使用加号（+）运算符
• 使用格式化字符串

二、字符串分割

字符串分割是将一个字符串按照指定的分隔符拆分成多个子字符串的过程。Python 中的 split() 方法可以实现这一功能。

例如，我们可以用空格作为分隔符来分割字符串：

 
text = "Python is fun"
words = text.split()
print(words)  # 输出: ['Python', 'is', 'fun']

还可以指定其他分隔符：

 
csv_data = "apple,banana,cherry"
fruits = csv_data.split(",")
print(fruits)  # 输出: ['apple', 'banana', 'cherry']

三、字符串查找

字符串查找是检查某个子字符串是否存在于另一个字符串中的操作。Python 提供了多种方法来进行字符串查找，包括 find() 和 in 关键字。

使用 find() 方法可以返回子字符串第一次出现的位置：

 
text = "Python programming is fun"
position = text.find("programming")
print(position)  # 输出: 7

使用 in 关键字可以判断子字符串是否存在：

 
if "fun" in text:
    print("Found the word 'fun'")
else:
    print("Word not found")

四、字符串替换

字符串替换是将字符串中的某些部分替换为其他内容的操作。Python 的 replace() 方法可以完成这项任务。

例如，将字符串中的特定单词替换为新的单词：

 
original_text = "I like apples"
new_text = original_text.replace("apples", "oranges")
print(new_text)  # 输出: I like oranges

此外，replace() 方法还支持替换次数的限制：

 
text = "one two one three one"
new_text = text.replace("one", "ONE", 2)
print(new_text)  # 输出: ONE two ONE three one

总结

Python 提供了强大的字符串操作工具，使得开发者能够轻松地处理各种文本数据。无论是拼接、分割、查找还是替换，Python 都提供了简单直观的方法来满足需求。掌握这些基本操作对于任何 Python 开发者来说都是非常重要的基础技能。

1.1 大模型的定义

大模型，顾名思义，是指拥有大规模参数和复杂结构的机器学习模型。与传统的小模型相比，大模型通常包含数亿甚至数千亿个参数，这些参数是模型学习过程中需要调整的变量。大模型的核心目标是通过海量数据的训练，捕捉数据中的复杂规律，从而实现更高的性能和更广泛的应用。

举个例子：
想象一下，传统的小模型就像是一个小学生，只能解决简单的加减乘除问题。而大模型则像是一个博士生，能够解决复杂的数学问题，甚至能够写出论文、创作诗歌、编写代码。

1.2 大模型与普通模型的区别

普通模型通常针对特定任务设计，例如识别猫和狗的分类模型，或者预测房价的回归模型。而大模型则具有更强的通用性，能够处理多种任务，例如GPT（Generative Pre-trained Transformer）不仅可以生成文本，还可以翻译、回答问题、写代码等。

举个例子：
普通模型就像是一把螺丝刀，只能用来拧螺丝。而大模型则像是一个多功能工具箱，既可以拧螺丝，也可以剪电线、钉钉子，甚至还能进行一些创意性的工作。

1.3 大模型的核心技术

大模型的成功离不开几项核心技术：

• 深度学习：大模型基于深度学习框架，通过多层神经网络从数据中提取特征。
• Transformer架构：这是大模型的核心结构，通过自注意力机制（Self-Attention）捕捉数据中的长距离依赖关系。
• 预训练与微调：大模型通常先在大量通用数据上进行预训练，然后在特定任务上进行微调，从而提高性能。

举个例子：
Transformer架构就像是一个超级大脑，能够同时关注输入数据中的多个部分。例如，在翻译句子时，它能够同时理解句子的开头和结尾，从而生成更准确的翻译结果。

JSON(JavaScript Object Notation)是一种轻量级的[数据交换格式]，Python的json模块提供了[JSON数据]的编码和解码功能。该模块可以将Python对象转换为JSON字符串（序列化），也可以将JSON字符串转换为Python对象（反序列化）。

核心功能

• json.dumps(): 将Python对象编码为JSON字符串
• json.loads(): 将JSON字符串解码为Python对象
• json.dump(): 将Python对象编码并写入文件
• json.load(): 从文件读取并解码JSON数据

二、基本使用方法

1. 序列化（Python对象 → JSON字符串）

import json
data = {  
"name": "张三",  
"age": 30,  
"married": True,  
"children": ["小明", "小红"],  
"pets": None  
}

json_str = json.dumps(data, ensure_ascii=False, indent=4)  
print(json_str)

输出：

{
    "name": "张三",
    "age": 30,
    "married": true,
    "children": ["小明", "小红"],
    "pets": null
}

参数说明：

• ensure_ascii=False: 允许非ASCII字符（如中文）直接输出
• indent=4: 美化输出，使用4个空格缩进

2. 反序列化（JSON字符串 → Python对象）

json_data = '{"name": "李四", "age": 25, "city": "北京"}'
python_obj = json.loads(json_data)

print(python_obj["name"]) # 输出: 李四  
print(type(python_obj)) # 输出: <class 'dict'>

3. 文件读写操作

写入JSON文件：

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

读取JSON文件：

with open('data.json', 'r', encoding='utf-8') as f:
    loaded_data = json.load(f)

三、高级用法

1. 处理复杂对象

默认情况下，json模块只能处理基本数据类型。要序列化复杂对象，需要自定义编码器：

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
	        
	def user_encoder(obj):  
	if isinstance(obj, User):  
	return {'name': obj.name, 'age': obj.age}  
	raise TypeError(f'Object of type {obj.**class**.**name**} is not JSON serializable')
	
	user = User("王五", 28)  
	user_json = json.dumps(user, default=user_encoder)

2. 自定义解码器

def user_decoder(dct):
    if 'name' in dct and 'age' in dct:
        return User(dct['name'], dct['age'])
    return dct
    
user_obj = json.loads(user_json, object_hook=user_decoder)  
print(type(user_obj)) # 输出: <class '**main**.User'>

3. 性能优化

对于大型JSON数据处理：

• 使用json.JSONEncoder和json.JSONDecoder类提高性能
• 考虑使用ujson或orjson等第三方库（非标准库）

四、实际应用场景

1. Web API开发

# Flask示例
from flask import Flask, jsonify, request
import json

app = Flask(**name**)

@app.route('/api/data', methods=['POST'])  
def receive_data():  
data = request.get_json() # 自动使用json模块解析请求体

处理数据

return jsonify({"status": "success"})

2. 配置文件管理

# 读取配置
with open('config.json') as f:
    config = json.load(f)

修改并保存配置

config['timeout'] = 30  
with open('config.json', 'w') as f:  
json.dump(config, f, indent=2)

3. 数据交换与存储

# 将Pandas DataFrame转为JSON
import pandas as pd
df = pd.DataFrame({'A': [1, 2], 'B': ['x', 'y']})
json_str = df.to_json(orient='records')

从JSON恢复DataFrame

new_df = pd.read_json(json_str)

五、常见问题与解决方案

1. 中文乱码问题

   • 确保使用ensure_ascii=False
   • 文件操作时指定编码为utf-8

2. 日期时间对象的处理

   from datetime import datetime
   def datetime_encoder(obj):  
   	if isinstance(obj, datetime):  
   		return obj.isoformat()  
   	raise TypeError("Type not serializable")
   
   data = {'time': datetime.now()}  
   json.dumps(data, default=datetime_encoder)

AI写代码- 循环引用检测

- 默认情况下json不处理循环引用
- 需要自行解决循环引用问题或使用第三方库

六、最佳实践

1. 始终处理异常：

   try:
       data = json.loads(json_str)
   except json.JSONDecodeError as e:
       print(f"Invalid JSON: {e}")

2. 对于敏感数据，考虑使用json.dumps()的separators参数压缩JSON大小：

   json.dumps(data, separators=(',', ':'))

3. 大型文件处理时，考虑使用ijson库进行流式解析

七、总结

Python的json模块是处理JSON数据的利器，掌握它可以：

• 轻松实现前后端数据交互
• 高效管理配置文件
• 处理各种数据交换场景

• 导入 Pandas 时，通常给其一个别名“pd”，即 import pandas as pd。
• 作为标签库，Pandas 对象在 NumPy 数组基础上给予其行列标签。可以说，列表之于字典，就如 NumPy 之于 Pandas。
• Pandas 中，所有数组特性仍在，Pandas 的数据以 NumPy 数组的方式存储。

一维对象的创建

1. 字典创建法
   NumPy 中，可以通过 np.array()函数，将 Python 列表转化为 NumPy 数组；同样，Pandas 中，可以通过 pd.Series()函数，将 Python 字典转化为 Series 对象。

import pandas as pd
# 创建字典
dict_v = { 'a':0, 'b':0.25, 'c':0.5, 'd':0.75, 'e':1 }
# 用字典创建对象
sr = pd.Series( dict_v )
sr                      #OUT:a    0.00
                        #    b    0.25
                        #    c    0.50
                        #    d    0.75
                        #    e    1.00
                        #    dtype: float64

2. 数组创建法
   最直接的创建方法即直接给 pd.Series()函数参数，其需要两个参数。第一个参数是值 values（列表、数组、张量均可），第二个参数是键 index（索引）。

import pandas as pd
# 先定义键与值
v = [0, 0.25, 0.5, 0.75, 1]
k = ['a', 'b', 'c', 'd', 'e']
 # 用列表创建对象
sr = pd.Series( v, index=k )
sr                      #OUT:a    0.00
                        #    b    0.25
                        #    c    0.50
                        #    d    0.75
                        #    e    1.00
                        #    dtype: float64

其中，参数 index 可以省略，省略后索引即从 0 开始的顺序数字。

一维对象的属性

Series 对象有两个属性：values 与 index。

import numpy as np
import pandas as pd
# 用数组创建 sr
v = np.array( [ 53, 64, 72, 82 ] )
k = ['1 号', '2 号', '3 号', '4 号']
sr = pd.Series( v, index=k )
sr                      #OUT:1 号    53
                        #    2 号    64
                        #    3 号    72
                        #    4 号    82
                        #    dtype: int32
# 查看 values 属性
sr.values               #OUT:array([53, 64, 72, 82])
# 查看 index 属性
sr.index               #OUT:Index(['1 号', '2 号', '3 号', '4 号'], dtype='object')

事实上，无论是用列表、数组还是张量来创建对象，最终 values 均为数组。虽然 Pandas 对象的第一个参数 values 可以传入列表、数组与张量，但传进去后默认的存储方式是 NumPy 数组。这一点更加提醒我们，Pandas 是建立在 NumPy 基础上的库，没有 NumPy 数组库就没有 Pandas 数据处理库。当想要 Pandas 退化为 NumPy 时，查看其 values 属性即可。

二维对象的创建

二维对象将面向矩阵，其不仅有行标签 index，还有列标签 columns。

1. 字典创建法
   用字典法创建二维对象时，必须基于多个 Series 对象，每一个 Series 就是一列数据，相当于对一列一列的数据作拼接。

• 创建 Series 对象时，字典的键是 index，其延展方向是竖直方向；
• 创建 DataFrame 对象时，字典的键是 columns，其延展方向是水平方向。

import pandas as pd
# 创建 sr1：各个病人的年龄
v1 = [ 53, 64, 72, 82 ]
i = [ '1 号', '2 号', '3 号', '4 号' ]
sr1 = pd.Series( v1, index=i )
sr1                     #OUT:1 号    53
                        #    2 号    64
                        #    3 号    72
                        #    4 号    82
                        #    dtype: int32
 # 创建 sr2：各个病人的性别
v2 = [ '女', '男', '男', '女' ]
i = [ '1 号', '2 号', '3 号', '4 号' ]
sr2 = pd.Series( v2, index=i )
sr2                     #OUT:1 号    女
                        #    2 号    男
                        #    3 号    男
                        #    4 号    女
                        #    dtype: object
# 创建 df 对象
df = pd.DataFrame( { '年龄':sr1, '性别':sr2 } )
df                      #OUT:	   年龄  性别
                        #    1 号	53	  女
                        #    2 号	64	  男
                        #    3 号	72	  男
                        #    4 号	82	  女

如果 sr1 和 sr2 的 index 不完全一致，那么二维对象的 index 会取 sr1 与 sr2的所有 index，相应的，该对象就会产生一定数量的缺失值（NaN）。
2. 数组创建法
最直接的创建方法即直接给 pd.DataFrame 函数参数，其需要三个参数。第一个参数是值 values（数组），第二个参数是行标签 index，第三个参数是列标签columns。其中，index 和 columns 参数可以省略，省略后即从 0 开始的顺序数字。

import numpy as np
import pandas as pd
# 设定键值
v = np.array( [ [53, '女'], [64, '男'], [72, '男'], [82, '女'] ] )
i = [ '1 号', '2 号', '3 号', '4 号' ]
c = [ '年龄', '性别' ]
# 数组创建法
df = pd.DataFrame( v, index=i, columns=c )
df                      #OUT:	   年龄  性别
                        #    1 号	53	  女
                        #    2 号	64	  男
                        #    3 号	72	  男
                        #    4 号	82	  女

上述 NumPy 数组居然又含数字又含字符串，上一篇博文中明明讲过数组只能容纳一种变量类型。这里的原理是，数组默默把数字转为了字符串，于是 v 就是一个字符串型数组。

二维对象的属性

DataFrame 对象有三个属性：values、index 与 columns。

import pandas as pd
# 设定键值
v = [ [53, '女'], [64, '男'], [72, '男'], [82, '女'] ]
i = [ '1 号', '2 号', '3 号', '4 号' ]
c = [ '年龄', '性别' ]
# 数组创建法
df = pd.DataFrame( v, index=i, columns=c )
df                      #OUT:	   年龄  性别
                        #    1 号	53	  女
                        #    2 号	64	  男
                        #    3 号	72	  男
                        #    4 号	82	  女
# 查看 values 属性 # 查看 index 属性
df.index                #OUT:array([[53, '女'],
                        #           [64, '男'],
                        #           [72, '男'],
                        #           [82, '女']], dtype=object)
# 查看 index 属性
df.index                #OUT:Index(['1 号', '2 号', '3 号', '4 号'], dtype='object')
# 查看 columns 属性
df.columns              #OUT:Index(['年龄', '性别'], dtype='object')

当想要 Pandas 退化为 NumPy 时，查看其 values 属性即可。

# 提取完整的数组
arr = df.values
print(arr)                #OUT:[['53' '女']
                          #     ['64' '男']
                          #     ['72' '男']
                          #     ['82' '女']]
# 提取第[0]列，并转化为一个整数型数组
arr = arr[:,0].astype(int)
print(arr)                #OUT:[53 64 72 82]

由于数组只能容纳一种变量类型，因此需要 .astype(int) 的操作。但对象不用，对象每一列的存储方式是单独的，这就很好的兼容了大数据的特性。

对象的索引

在学习 Pandas 的索引之前，需要知道

• Pandas 的索引分为显式索引与隐式索引。显式索引是使用 Pandas 对象提供的索引，而隐式索引是使用数组本身自带的从 0 开始的索引。
• 现假设某演示代码中的索引是整数，这个时候显式索引和隐式索引可能会出乱子。于是，Pandas 作者发明了索引器 loc（显式）与 iloc（隐式），手动告诉程序自己这句话是显式索引还是隐式索引。

一维对象的索引

1. 访问元素

import pandas as pd
# 创建 sr
v = [ 53, 64, 72, 82 ]
k = ['1 号', '2 号', '3 号', '4 号']
sr = pd.Series( v, index=k )
sr                        #OUT:1 号    53
                          #    2 号    64
                          #    3 号    72
                          #    4 号    82
                          #    dtype: int64
# 访问元素
sr.loc[ '3 号' ]          #OUT:72    显示索引
sr.iloc[ 2 ]              #OUT:72    隐式索引
# 花式索引
sr.loc[ [ '1 号', '3 号' ] ]  #OUT:1 号    53    显示索引
                             #    3 号    72
                             #    dtype: int64
sr.iloc[ [ 0, 2 ] ]          #OUT:1 号    53    隐式索引
                             #    3 号    72
                             #    dtype: int64
# 修改元素
sr.loc[ '3 号' ] = 100
sr                           #OUT:1 号     53    显示索引
                             #    2 号     64
                             #    3 号    100
                             #    4 号     82
                             #    dtype: int64
# 修改元素
sr.iloc[ 2 ] = 100
sr                           #OUT:1 号     53    隐式索引
                             #    2 号     64
                             #    3 号    100
                             #    4 号     82
                             #    dtype: int64

2. 访问切片
   使用显式索引时，‘1 号’:‘3 号’ 可以涵盖最后一个’3 号’，但隐式与之前一样。

import pandas as pd
# 创建 sr
v = [ 53, 64, 72, 82 ]
k = ['1 号', '2 号', '3 号', '4 号']
sr = pd.Series( v, index=k )
sr                        #OUT:1 号    53
                          #    2 号    64
                          #    3 号    72
                          #    4 号    82
                          #    dtype: int64
# 访问切片
sr.loc[ '1 号':'3 号' ]   #OUT: 1 号    53    显示索引
                          #    2 号    64
                          #    3 号    72
                          #    dtype: int64
sr.iloc[ 0:3 ]            #OUT:1 号    53    隐式索引
                          #    2 号    64
                          #    3 号    72
                          #    dtype: int64
 # 切片仅是视图
cut = sr.loc[ '1 号':'3 号' ]
cut.loc['1 号'] = 100
sr                        #OUT: 1 号    53    显示索引
                          #    2 号    64
                          #    3 号    72
                          #    dtype: int64
cut = sr.iloc[ 0:3 ]
cut.iloc[0] = 100
sr                        #OUT:1 号    53    隐式索引
                          #    2 号    64
                          #    3 号    72
                          #    dtype: int64
# 对象赋值仅是绑定
cut = sr
cut.loc['3 号'] = 200
sr                        #OUT:1 号    100    显示索引
                          #    2 号     64
                          #    3 号    200
                          #    4 号     82
                          #    dtype: int64
cut = sr
cut.iloc[2] = 200
sr                        #OUT:1 号    100    隐式索引
                          #    2 号     64
                          #    3 号    200
                          #    4 号     82
                          #    dtype: int64

若想创建新变量，与 NumPy 一样，使用.copy()方法即可。如果去掉 .loc 和 .iloc ，此时与 NumPy 中的索引语法完全一致。

二维对象的索引

在二维对象中，索引器不能去掉，否则会报错，因此必须适应索引器的存在。

1. 访问元素：

import pandas as pd
 # 字典创建法
i = [ '1 号', '2 号', '3 号', '4 号' ]
v1 = [ 53, 64, 72, 82 ]
v2 = [ '女', '男', '男', '女' ]
sr1 = pd.Series( v1, index=i )
sr2 = pd.Series( v2, index=i )
df = pd.DataFrame( { '年龄':sr1, '性别':sr2 } )
df                        #OUT:
                          #        年龄  性别
                          #    1 号	53	  女
                          #    2 号	64    男
                          #    3 号	72	  男
                          #    4 号	82	  女
# 访问元素
df.loc[ '1 号', '年龄' ]   #OUT:53
df.iloc[ 0, 0 ]           #OUT:53
# 花式索引
df.loc[ ['1 号', '3 号'] , ['性别','年龄'] ]   #OUT:	性别    年龄
                                          #    1 号  女	    53
                                          #    3 号	 男	    72
df.iloc[ [0,2], [1,0] ]                      #OUT:	性别    年龄
                                          #    1 号  女	    53
                                          #    3 号	 男	    72
# 修改元素
df.loc[ '3 号', '年龄' ] = 100
df                        #OUT:
                          #        年龄  性别
                          #    1 号	53	  女
                          #    2 号	64    男
                          #    3 号	100	  男
                          #    4 号	82	  女
df.iloc[ 2, 0 ] = 100
df                        #OUT:
                          #        年龄  性别
                          #    1 号	53	  女
                          #    2 号	64    男
                          #    3 号	100	  男
                          #    4 号	82	  女

在 NumPy 数组中，花式索引输出的是一个向量。但在 Pandas 对象中，考虑到其行列标签的信息不能丢失，所以输出一个向量就不行了。
2. 访问切片

import pandas as pd
 # 数组创建法
v = [ [53, '女'], [64, '男'], [72, '男'], [82, '女'] ]
i = [ '1 号', '2 号', '3 号', '4 号' ]
c = [ '年龄', '性别' ]
df = pd.DataFrame( v, index=i, columns=c )
df                        #OUT:
                          #        年龄  性别
                          #    1 号	53	  女
                          #    2 号	64    男
                          #    3 号	72	  男
                          #    4 号	82	  女
# 切片
df.loc[ '1 号':'3 号' , '年龄' ]  #OUT:  1 号  53
                                 #      2 号  64
                                 #      3 号  72
                                 #      Name: 年龄, dtype: int64
df.iloc[ 0:3 , 0 ]               #OUT:  1 号  53
                                 #      2 号  64
                                 #      3 号  72
                                 #      Name: 年龄, dtype: int64
# 提取二维对象的行  
df.loc[ '3 号' , : ] [#OUT](app://obsidian.md/index.html#OUT): 年龄 72  
# 性别 男  
# Name: 3 号, dtype: object  
df.iloc[ 2 , : ] [#OUT](app://obsidian.md/index.html#OUT): 年龄 72  
# 性别 男  
# Name: 3 号, dtype: object  
# 提取矩阵对象的列  
df.loc[ : , '年龄' ] [#OUT](app://obsidian.md/index.html#OUT): 1 号 53  
# 2 号 64  
# 3 号 72  
# 4 号 82  
# Name: 年龄, dtype: int64  
df.iloc[ : , 0 ] [#OUT](app://obsidian.md/index.html#OUT): 1 号 53  
# 2 号 64  
# 3 号 72  
# 4 号 82  
# Name: 年龄, dtype: int64

在显示索引中，提取矩阵的行或列还有一种简便写法，即

• 提取二维对象的行：df.loc[ ‘3 号’]（原理是省略后面的冒号，隐式也可以）
• 提取二维对象的列：df [‘年龄’ ]（原理是列标签本身就是二维对象的键）

对象的变形

对象的转置

有时候提供的大数据很畸形，行是特征，列是个体，这必须要先进行转置。

import pandas as pd
# 创建畸形 df
v = [ [53, 64, 72, 82], [ '女', '男', '男', '女' ] ]
i = [ '年龄', '性别' ]
c = [ '1 号', '2 号', '3 号', '4 号' ]
df = pd.DataFrame( v, index=i, columns=c )
df                    #OUT:	1 号	2 号	3 号	4 号
                      #年龄  53      64      72      82
                      #性别  女      男       男      女
# 转置
df = df.T
df                    #OUT:
                      #          年龄   性别
                      #1 号       53	女
                      #2 号	      64	男
                      #3 号	      72	男
                      #4 号	      82	女

对象的翻转

# 左右翻转
df = df.iloc[ : , : : -1 ]
df                    #OUT:
                      #       性别   年龄   
                      #1 号    女     53	
                      #2 号	   男     64	
                      #3 号	   男     72	
                      #4 号	   女     82	
 # 上下翻转
df = df.iloc[ : : -1 , : ]
df                    #OUT:
                      #       性别   年龄   
                      #4 号	   女     82
                      #3 号	   男     72
                      #2 号	   男     64
                      #1 号    女     53

对象的重塑

考虑到对象是含有行列标签的，.reshape()已不再适用，因此对象的重塑没有那么灵活。但可以做到将 sr 并入 df，也可以将 df 割出 sr。

import pandas as pd
# 数组法创建 sr
i = [ '1 号', '2 号', '3 号', '4 号' ]
v1 = [ 10, 20, 30, 40 ]
v2 = [ '女', '男', '男', '女' ]
v3 = [ 1, 2, 3, 4 ]
sr1 = pd.Series( v1, index=i )
sr2 = pd.Series( v2, index=i )
sr3 = pd.Series( v3, index=i )
sr1, sr2, sr3        #OUT:(1 号 10 1 号 女 1 号 1
                     #OUT:2 号 20 2 号 男 2 号 2
                     #OUT:3 号 30 3 号 男 3 号 3
                     #OUT:4 号 40 4 号 女 4 号 4
                     #OUT:dtype: int64, dtype: object, dtype: int64)
# 字典法创建 df
df = pd.DataFrame( { '年龄':sr1, '性别':sr2 } )
df                    #OUT:
                            年龄     性别
                      #1 号	10       女
                      #2 号 20       男
                      #3 号 30       男
                      #4 号 40       女
# 把 sr 并入 df 中
df['牌照'] = sr3
df                    #OUT:	年龄   性别   牌照
                      #1 号  10    女      1
                      #2 号  20    男      2
                      #3 号  30    男      3
                      #4 号  40    女      4
# 把 df['年龄']分离成 sr4
sr4 = df['年龄']
sr4                    #OUT:1 号    10
                      #2 号    20
                      #3 号    30
                      #4 号    40
                      #Name: 年龄, dtype: int64