python数据容器常见方法速查深度学习包(PyTorch/TensorFlow/ Diffusers等）速查

本文链接：https://blog.youkuaiyun.com/weixin_42323588/article/details/132752816

本文详细介绍了Python中列表、字符串、字典和元组的基本操作方法，包括列表的append、extend、insert等，字符串的capitalize、upper、lower等，以及字典的常用操作。此外，还涵盖了文件操作、深度学习框架如TensorFlow、Keras和PyTorch的基础知识。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在 Python 中，列表（List）是一种有序、可变的数据类型，用于存储多个元素。下面是一些常见的列表方法，并给出了具体示例：

#append(element): 在列表末尾添加一个元素。
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 4]

#extend(iterable): 将可迭代对象中的元素逐个添加到列表末尾。
my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list)  # 输出：[1, 2, 3, 4, 5]

#insert(index, element): 在指定位置插入一个元素。
my_list = [1, 2, 3]
my_list.insert(1, 10)
print(my_list)  # 输出：[1, 10, 2, 3]

#remove(element): 删除列表中第一个匹配到的指定元素。
my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # 输出：[1, 3, 2]

#pop(index): 删除并返回指定位置上的元素。如果不指定索引，默认删除最后一个元素。
my_list = [1, 2, 3]
element = my_list.pop(1)
print(element)  # 输出：2
print(my_list)  # 输出：[1, 3]

#index(element): 返回指定元素第一次出现时的索引。
my_list = [1, 2, 3, 2]
index = my_list.index(2)
print(index)  # 输出：1

#count(element): 返回指定元素在列表中出现的次数。
my_list = [1, 2, 3, 2]
count = my_list.count(2)
print(count)  # 输出：2

#sort(): 对列表进行原地排序（升序）。
my_list = [3, 1, 4, 2]
my_list.sort()
print(my_list)  # 输出：[1, 2, 3, 4]

#reverse(): 将列表中的元素反转。
my_list = [1, 2, 3]
my_list.reverse()
print(my_list)  # 输出：[3, 2, 1]

在 Python 中，字符串string是一种不可变的序列类型，用于存储文本数据。Python 提供了许多内置方法来处理和操作字符串，以下是一些常见的字符串方法：

1. capitalize() 方法

该方法返回字符串的副本，并将第一个字符大写，将其余字符小写。

str1 = "this is a string."
print(str1.capitalize())  # 输出：This is a string.

2. upper() 和 lower() 方法

upper() 方法返回字符串的副本，并将所有字母转换为大写，而 lower() 方法返回字符串的副本，并将所有字母转换为小写。

str1 = "this is a string."
print(str1.upper())  # 输出：THIS IS A STRING.
print(str1.lower())  # 输出：this is a string.

3. strip() 方法

strip() 方法返回字符串的副本，并删除开头和结尾的空格（或其他指定字符）。

str1 = "    this is a string.    "
print(str1.strip())  # 输出：this is a string.

4. split() 方法

split() 方法用于将字符串分割成子字符串，并返回一个列表。可以指定分隔符，如果不指定，默认以空格为分隔符。

str1 = "this is a string."
print(str1.split())  # 输出：['this', 'is', 'a', 'string.']

5. find() 和 index() 方法

find() 方法和 index() 方法都用于查找字符串中某个子字符串的位置，如果找到返回子字符串的索引，否则返回 -1（find() 方法）或抛出 ValueError 异常（index() 方法）。两者的区别在于，find() 方法未找到子字符串时返回 -1 而不是引发异常。


str1 = "this is a string."
print(str1.find("is"))  # 输出：2
print(str1.index("is"))  # 输出：2

6. replace() 方法

replace() 方法用于将字符串中的某个子字符串替换为指定的新字符串，并返回替换后的字符串的副本。

str1 = "this is a string."
print(str1.replace("is", "at"))  # 输出：

Python 中字典（Dictionary）是一种无序、可变的数据类型，用于存储键-值对。下面是一些常用的字典方法，并给出了具体示例：

clear(): 清空字典中的所有键值对。

my_dict = {'name': 'Alice', 'age': 25}
my_dict.clear()
print(my_dict)  # 输出：{}

copy(): 创建一个字典的浅拷贝副本。

my_dict = {'name': 'Alice', 'age': 25}
new_dict = my_dict.copy()
print(new_dict)  # 输出：{'name': 'Alice', 'age': 25}

get(key, default): 返回指定键的值。如果键不存在，则返回默认值（可选）。

my_dict = {'name': 'Alice', 'age': 25}
name = my_dict.get('name')
print(name)  # 输出：Alice

city = my_dict.get('city', 'Unknown')
print(city)  # 输出：Unknown

items(): 返回一个包含所有键值对的元组列表。

my_dict = {'name': 'Alice', 'age': 25}
items = my_dict.items()
print(items)  # 输出：dict_items([('name', 'Alice'), ('age', 25)])

keys(): 返回一个包含所有键的列表。

my_dict = {'name': 'Alice', 'age': 25}
keys = my_dict.keys()
print(keys)  # 输出：dict_keys(['name', 'age'])

values(): 返回一个包含所有值的列表。

my_dict = {'name': 'Alice', 'age': 25}
values = my_dict.values()
print(values)  # 输出：dict_values(['Alice', 25])

pop(key, default): 删除指定键并返回对应的值。如果键不存在，则返回默认值（可选）。

my_dict = {'name': 'Alice', 'age': 25}
age = my_dict.pop('age')
print(age)  # 输出：25
print(my_dict)  # 输出：{'name': 'Alice'}

update(dict2): 将另一个字典的键值对更新到当前字典中。

my_dict = {'name': 'Alice', 'age': 25}
additional_info = {'city': 'New York', 'gender': 'female'}
my_dict.update(additional_info)
print(my_dict)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New Yor

在 Python 中，元组（Tuple）是一种有序、不可变的数据类型，用于存储多个元素。由于元组是不可变的，因此它没有像列表那样的方法来修改元素。但是元组有一些常见的方法可以使用，以下是其中一些方法的具体示例：

index(element): 返回指定元素第一次出现时的索引。

my_tuple = (1, 2, 3, 2)
index = my_tuple.index(2)
print(index)  # 输出：1


count(element): 返回指定元素在元组中出现的次数。

my_tuple = (1, 2, 3, 2)
count = my_tuple.count(2)
print(count)  # 输出：2

这些是元组的常见方法，由于元组是不可变的，所以没有像列表那样的添加、删除、排序等修改方法。如果需要对元组进行修改操作，可以将元组转换为列表进行修改，然后再转换回元组。例如：
my_tuple = (1, 2, 3)
my_list = list(my_tuple)  # 转换为列表
my_list.append(4)  # 在列表中添加元素
my_tuple = tuple(my_list)  # 将列表转换回元组
print(my_tuple)  # 输出：(1, 2, 3, 4)

常见的 Python 文件操作方法。下面是一些常用的文件操作方法示例：

打开文件：

file = open("file.txt", "r")  # 以只读模式打开文件
读取文件内容：

content = file.read()  # 读取整个文件内容


逐行读取文件内容：

file = open("file.txt", "r")
for line in file:
    print(line)  # 逐行打印文件内容

readline(size=-1)：逐行读取文件内容

file = open("file.txt", "r")
line = file.readline()  # 读取第一行内容，返回一个字符串
print(line)

file.close()

readlines()：读取文件所有行，并返回一个列表

file = open("file.txt", "r")
lines = file.readlines()  # 读取所有行内容，并返回一个列表
print(lines)

file.close()readline(size=-1)：逐行读取文件内容
python
file = open("file.txt", "r")
line = file.readline()  # 读取第一行内容
print(line)

file.close()

readlines()：读取文件所有行，并返回一个列表

file = open("file.txt", "r")
lines = file.readlines()  # 读取所有行内容，并返回一个列表
print(lines)

file.close()

写入文件内容（覆盖原内容）：

file = open("file.txt", "w")  # 以写入模式打开文件
file.write("Hello, World!")  # 写入内容

file.close()
写入文件内容（追加到原内容末尾）：
file = open("file.txt", "a")  # 以追加模式打开文件
file.write("Hello again!")  # 写入内容
file.close()
判断文件是否存在：
import os
if os.path.exists("file.txt"):
    print("文件存在")
else:
    print("文件不存在")
删除文件：
python
import os
os.remove("file.txt")


tell() 和 seek(offset, whence=0)：移动文件指针

file = open("file.txt", "r")
position = file.tell()  # 返回当前文件指针位置
print(position)

file.seek(0)  # 将文件指针移动到文件开头

file.close()

writelines(lines)：将一个字符串列表写入文件

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]

file = open("file.txt", "a")
file.writelines(lines)  # 将字符串列表写入文件

file.close()

flush()：刷新文件缓冲区

file = open("file.txt", "a")
file.write("Hello, World!")

file.flush()  # 刷新文件缓冲区，将内容写入文件

file.close()

truncate(size=None)：将文件截断到指定大小

file = open("file.txt", "r+")
file.truncate(10)  # 截断文件到10个字节大小

file.close()

Python中有许多常见的用于深度学习的包和框架。以下是一些常见的深度学习Python包：

TensorFlow：由Google开发的广泛使用的深度学习框架，支持构建和训练各种深度学习模型。

tensorflow：TensorFlow的主要包，提供了构建和执行计算图的功能，以及各种核心API和工具。

tensorflow.keras：Keras是一个高级神经网络API，tensorflow.keras提供了TensorFlow的Keras接口，用于快速构建和训练神经网络模型。

tensorflow.data：用于在TensorFlow中加载和预处理数据的包，包括数据集对象、数据转换函数和输入流水线等。

tensorflow.image：用于图像处理和增强的包，包括图像加载、调整大小、裁剪、翻转、旋转、亮度调整和色彩空间转换等功能。

tensorflow.text：用于自然语言处理（NLP）任务的包，包括文本向量化、文本解码、标记化和构建文本处理流水线等。
          tensorflow.text 是 TensorFlow 提供的用于自然语言处理（NLP）任务的包，它提供了一些用于文本处理和分析的方法。以下是 tensorflow.text 中的一些常见方法：

tf.strings：提供了字符串操作的方法，如拆分、连接、长度计算、匹配模式等。

例如，tf.strings.length(text) 可以计算文本字符串的字符长度。
tf.text：提供了一些文本处理的方法，如标记化、编码、解码、词袋模型等。

例如，tf.text.UnicodeCharTokenizer().tokenize(text) 可以将文本字符串拆分为字符级别的标记。
tf.text.case_fold_utf8：将文本字符串转换为小写形式，用于大小写不敏感的文本处理。
    
tf.text.wordshape：提供了一些方法用于推断文本中词语的形态特征，如是否全大写、首字母大写等。

tf.text.normalize_utf8：用于规范化文本字符串，例如去除重音符号、标点符号等。

tf.text.tokenizers：提供了一些标记化方法，如空格分割、基于空格的标记化等。

例如，tf.text.WhitespaceTokenizer().tokenize(text) 可将文本字符串按照空格进行切分。

tensorflow.contrib：包含一些实验性或不稳定的功能，提供了额外的扩展和实用工具，但在最新版本的TensorFlow中可能已被移除。

tensorflow.keras.applications：提供了一些常见的预训练模型（如VGG16、ResNet、Inception等）的接口，可用于快速加载和使用这些模型。

tensorflow.keras.layers：包含各种常见的神经网络层（如全连接层、卷积层、循环层等），可以用于构建自定义的深度学习模型。

import tensorflow as tf
import tensorflow_text as text

# 示例文本
text_string = "This is an example sentence."

# 标记化
tokenizer = text.WhitespaceTokenizer()
tokens = tokenizer.tokenize(text_string)
print(tokens)  # 输出: [b'This', b'is', b'an', b'example', b'sentence.']

# 转换为小写形式
lowercase_tokens = tf.strings.lower(tokens)
print(lowercase_tokens)  # 输出: [b'this', b'is', b'an', b'example', b'sentence.']

# 计算字符长度
lengths = tf.strings.length(tokens)
print(lengths)  # 输出: [4, 2, 2, 7, 9]

Keras：一个高级神经网络API，可作为TensorFlow、Theano或Microsoft Cognitive Toolkit的前端，用于快速构建和训练神经网络。

PyTorch：一个基于Torch的Python深度学习框架，提供动态计算图和自动求导功能，并支持张量计算和构建神经网络。

torch.nn：PyTorch的神经网络模块，提供了用于构建神经网络层和模型的工具和函数。

torch.optim：PyTorch的优化器模块，提供了各种梯度下降优化算法，例如SGD、Adam等。

torch.utils.data：PyTorch的数据处理模块，提供了用于加载和处理数据集的工具和函数。

torchvision：PyTorch的图像处理模块，提供了各种图像处理和增强方法，例如数据增强、预处理等。

"""
以下是一个使用PyTorch的示例代码，它构建了一个简单的神经网络模型，并使用SGD优化器来训练模型。示例中使用了PyTorch内置的模块和方法：
"""
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

# 定义模型类
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = torch.flatten(x, start_dim=1)
        x = self.fc1(x)
        x = nn.functional.relu(x)
        x = self.fc2(x)
        return x

# 加载MNIST数据集
train_dataset = torchvision.datasets.MNIST(
    root='data', train=True, download=True,
    transform=torchvision.transforms.ToTensor())
train_loader = DataLoader(train_dataset, batch_size=32)

# 定义模型、损失函数和优化器
model = SimpleNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# 训练模型
for epoch in range(10):
    for i, (inputs, targets) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
        
        if i % 100 == 0:
            print(f"Epoch {epoch}, Step {i}: Loss = {loss.item():.4f}")

MXNet：一个灵活的深度学习框架，支持动态和静态计算图，以及多种编程语言接口（包括Python）。
Caffe：一个用于开发卷积神经网络的快速、轻量级的框架，适用于计算机视觉任务。
Theano：一个优化数值计算的Python库，特别适合通过定义数学表达式来构建和训练神经网络。
Scikit-learn：一个用于数据挖掘和数据分析的Python库，提供了许多用于机器学习和深度学习的工具和算法。
CNTK：微软认知工具包（Microsoft Cognitive Toolkit），是一个灵活的、高性能的深度学习库，支持多种编程语言接口。
Chainer：一个直观且灵活的深度学习框架，支持动态计算图，并提供快速原型开发和实验的能力。

diffusers是Hugging Face推出的一个diffusion库，它提供了简单方便的diffusion推理训练pipe，同时拥有一个模型和数据社区，代码可以像torchhub一样直接从指定的仓库去调用别人上传的数据集和pretrain checkpoint。

"""
from_pretrained是指从特定仓库加载别人预训练好的模型。其中model_id可以是本地的路径，如果本地没找到对应的文件，则会自动去Hugging Face的Community中去自动下载
"""

from diffusers import StableDiffusionPipeline
 
model_id = "runwayml/stable-diffusion-v1-5"
stable_diffusion_txt2img = StableDiffusionPipeline.from_pretrained(model_id)