最近又经常用到python了，所以这里也总结一下python的使用的过程和简要的语法。

1 python语法简介

1.1 基础语法

python缩进就是断行

数据类型：
- 列表（List）：列表是Python中的基础数据结构之一，它是一个有序的元素集合，可以随时添加或删除其中的元素。
- 元组（Tuple）：元组与列表类似，也是一个有序的元素集合，但是元组是不可变的，一旦创建就不能修改其中的元素。
- 字典（Dictionary）：字典是一种键值对（Key-Value Pair）形式的数据结构，它由键（Key）和对应的值（Value）组成，可以通过键来访问对应的值。
- 集合（Set）：集合是一种无序的元素集合，其中的元素不重复且没有顺序要求。集合支持添加、删除、交集、并集等操作。

例如：

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_dict = {'name': 'Alice', 'age': 25}
my_set = {1, 2, 3, 4, 5}

1.1.1 主函数

一般情况下使用如下格式：

1 2	if __name__ == '__main__': # 主函数 print("hello world")

代码作用为，当运行当前文件，也就是说当前文件为主函数（文件）时运行以下代码，也就是主函数，如果该文件只是其他文件调用，那么就不运行以下代码了。所以一般的库函数是不需要主函数的。

1.1.2 循环

常用的循环while、for循环都有。

while循环

很简单，伪代码如下：

1 2	while 条件: 循环

例子如下：

x = 0
while x < 5:
    print(x)
    x += 1

for循环

比如这时有一个数据结构，比如列表：

1
2
3

nums = [1,2,3,4,5]
for num in nums:
    print(num)

此时就会遍历nums中的每一个元素。

1.1.3 函数

slice 切片

切片的基本概念是：从开始位置开始，按照给定的步长遍历序列，提取或跳过元素。你可以使用正步长（默认）来提取元素，也可以使用负步长（从后向前）来跳过元素。

list[start:end:step]:
- list为列表
- start：开始的序号，可以为负数，负数意义为倒序的位置，可以省略
- end：结束的序号，也可以为负数，也可以省略
- step：切片的步长，可以为负数，这样就是倒序切片，大小为采样的间隔

list = [1, 2, 3, 4, 5]  
list = list[::-1]  
print(list)  # 输出：[5, 4, 3, 2, 1]

list = list[2:5:1]
print(list)  # 输出：[3, 2, 1]

list = [1, 2, 3, 4, 5]  
list = list[-2::1]
print(list)  # 输出：[4,5]

1.1.4 类

类的定义

class MyClass:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
    def say_hello(self):  
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

使用时：

1 2	me = MyClass("Alice", 25) me.say_hello() # 输出: Hello, my name is Alice and I am 25 years old.

总之跟

self函数

有点类似于C++中类的this指针，也就是指向自己的指针。定义类内数据时，都会用到self。

1.1.5 引用import

1.1.6 `init.py`文件

1.2 内置函数

1.2.1 getattr()函数

在Python中，getattr()是一个内置函数，用于获取对象的属性值。它的语法如下：
getattr(object, name[, default])

比如:
例1:获取单个属性值

class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
  
p = Person('Alice', 25)  
print(getattr(p, 'name'))  # 输出: Alice  
print(getattr(p, 'age'))  # 输出: 25

例2：获取多个属性值

class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
        self.city = 'New York'  
  
p = Person('Alice', 25)  
print(getattr(p, ('name', 'age')))  # 输出: ('Alice', 25)

例3：获取不存在的属性时返回默认值

class Person:  
    def __init__(self, name, age):  
        self.name = name  
        self.age = age  
        self.city = 'New York'  
  
p = Person('Alice', 25)  
print(getattr(p, 'address', 'N/A'))  # 输出: N/A，因为不存在address属性

1.2.2 print函数

print函数用于打印字符串到终端中，一般用于记录日志，那么一般在用刀print的时候，我们想要统一输出的格式，这时也会经常用到在format()方法，它是将指定的值按照指定的格式插入到字符串中。类似于C++中的格式化输出printf()函数用法。

首先format用法一般string.format(value1, value2, ..., valueN)，在string中也要有占位符{},括号中也可以有格式化控制的语句，

一般来说，'example{[:[width][type]]}'.format()

符号	含义
s	对字符串类型格式化
d	十进制整数
c	将十进制整数自动转换成对应的 Unicode 字符
e or E	转换成科学计数法后，再格式化输出
g or G	自动在 e 和 f（或 E 和 F）中切换
b	将十进制数自动转换成二进制表示，再格式化输出
o	将十进制数自动转换成八进制表示，再格式化输出
x or X	将十进制数自动转换成十六进制表示，再格式化输出
f or F	转换为浮点数（默认小数点后保留 6 位），再格式化输出
%	显示百分比（默认显示小数点后 6 位）

比如

1
2
3

nums = [[2592,2834],[0.304625,0.312436],[0.771011,0.782213]]
# {:06d}为6位整数，{:.4f}为保留四位小数
print('iter{:06d}-{:.4f}-{:.4f}.pkl'.format(nums[0][0],nums[1][0],nums[2][0]))

输出的内容如下：
iter002592-0.3046-0.7710.pkl

2 python运行和调试

运行
- 使用vscode，在扩展中安装python扩展，然后点击运行就可以在终端上看到结果
- 终端直接运行，在命令行输入 python demo.py
调试
- 根据数据中的日志进行调整
- vscode进行断点调试

3 调库大法好

3.1 argparse库

python自带的库，用于处理命令行，在很多时候，我们运行py程序时，都需要用到命令行参数，通过使用parse_args()函数，可以使我们的Python程序具有灵活性和可扩展性，因为我们可以在命令行中提供自定义的参数值来控制程序的执行。

示例：

import argparse  
  
# 创建解析器对象  
parser = argparse.ArgumentParser(description="这是一个示例程序")  
  
# 添加命令行选项  
parser.add_argument("-a", "--arg1", help="参数1")  
parser.add_argument("-b", "--arg2", help="参数2")  
  
# 解析命令行参数  
args = parser.parse_args()  
  
# 使用获取的参数值执行程序逻辑  
if args.arg1:  
    print("参数1的值是:", args.arg1)  
if args.arg2:  
    print("参数2的值是:", args.arg2)

在上面的示例中，我们使用argparse模块创建了一个解析器对象，并添加了两个命令行选项–arg1和–arg2。然后，我们调用parse_args()函数解析命令行参数，并将结果存储在args变量中。最后，我们使用获取的参数值执行程序逻辑，打印出参数的值。

调用的时候，我们一般在终端调用，比如这个文件为argparseExp.py，则命令如下：

1	python argparseExp.py --arg1 exp1 --arg2 exp2

3.2 easydict库

EasyDict是一个Python库，它提供了一个简单的方式来创建和操作字典。EasyDict的主要特点是它允许你使用点符号（.）来访问字典中的键值对，而不是使用方括号（[]）。
以下是在Python中使用EasyDict库的方法：
首先，你需要安装EasyDict库。你可以使用pip来安装：
pip install EasyDict
安装完成后，你就可以在Python代码中使用EasyDict了。下面是一个简单的例子：

from easydict import EasyDict as edict 
  
# 创建一个字典  
my_dict = edict()  
my_dict.name = "John"  
my_dict.age = 30  
my_dict.city = "New York"  
  
# 访问和修改字典中的值  
print(my_dict.name)  # 输出: John  
print(my_dict.age)  # 输出: 30  
my_dict.city = "Los Angeles"  
print(my_dict.city)  # 输出: Los Angeles  
  
# 使用get方法访问字典中的值，如果键不存在，则返回None或指定的默认值  
print(my_dict.get("job"))  # 输出: None  
print(my_dict.get("job", "unemployed"))  # 输出: unemployed
此外，EasyDict还支持嵌套字典。你可以像下面这样创建一个嵌套字典：
python
复制代码
from easydict import EasyDict as edict  
  
# 创建一个嵌套字典  
my_dict = edict()  
my_dict.profile = edict()  
my_dict.profile.name = "John"  
my_dict.profile.age = 30  
my_dict.profile.city = "New York"  
  
# 访问嵌套字典中的值  
print(my_dict.profile.name)  # 输出: John  
print(my_dict.profile.age)  # 输出: 30

以上就是EasyDict库的基本使用方法。它提供了一种简洁的方式来创建和操作字典，特别是对于那些需要频繁使用字典的Python开发者来说。

3.3 yaml库

Python中的PyYAML库可以让你方便地处理YAML格式的数据。YAML是一种常用的配置文件格式，它以简洁的语法表达复杂的结构。

安装完成后，你可以在Python代码中使用PyYAML库来读取和写入YAML数据。下面是一个简单的例子：

读取YAML文件

import yaml  
# 打开YAML文件并读取数据  
with open('example.yaml', 'r') as file:  
    data = yaml.safe_load(file)  
# 输出读取到的数据  
print(data)

在上面的代码中，我们使用yaml.safe_load()函数从文件中读取YAML数据，并将其存储在变量data中。

写入YAML文件
python
复制代码

import yaml  
  
# 创建一个字典  
data = {'name': 'John', 'age': 30, 'city': 'New York'}  
  
# 将数据写入YAML文件  
with open('example.yaml', 'w') as file:  
    yaml.dump(data, file)

在上面的代码中，我们使用yaml.dump()函数将字典data写入到文件中。默认情况下，yaml.dump()会输出美观的YAML格式。你也可以通过设置参数来控制输出的格式。例如，你可以设置indent=4来使输出更容易阅读。

使用标签
YAML还支持使用标签来指定数据类型。你可以使用!符号加上类型名称作为标签。例如，你可以使用!int来指定一个整数类型的数据。

import yaml  
  
# 创建一个字典，其中包含一个带有标签的整数  
data = {'age': {'!int': 30}}  
  
# 将数据写入YAML文件  
with open('example.yaml', 'w') as file:  
    yaml.dump(data, file)

在上面的代码中，我们使用!int标签来指定字典中的age键的值是一个整数。当我们读取这个YAML文件时，PyYAML会自动将带有标签的值转换为相应的Python类型。例如，带有!int标签的值将被转换为整数类型。

3.4 json库

Python中的json库是一个用于处理JSON数据的标准库。使用json库，你可以轻松地将Python对象转换为JSON格式，以及将JSON数据转换为Python对象。

下面是json库的基本使用方法：

将Python对象转换为JSON字符串

使用json.dumps()函数，将Python对象转换为JSON格式的字符串。

import json

# Python对象
data = {
    'name': 'John',
    'age': 30,
    'city': 'New York'
}

# 转换为JSON字符串
json_data = json.dumps(data)
print(json_data)

输出：

1	{"name": "John", "age": 30, "city": "New York"}

将JSON字符串转换为Python对象

使用json.loads()函数，将JSON格式的字符串转换为Python对象。

import json

# JSON字符串
json_data = '{"name": "John", "age": 30, "city": "New York"}'

# 转换为Python对象
data = json.loads(json_data)
print(data)

输出：

1	{'name': 'John', 'age': 30, 'city': 'New York'}

读写JSON文件

写入JSON文件

使用json.dump()函数，将Python对象写入到JSON文件。

import json

data = {
    'name': 'John',
    'age': 30,
    'city': 'New York'
}

with open('data.json', 'w') as file:
    json.dump(data, file)

上述代码将data对象写入到名为data.json的文件中。

读取JSON文件

使用json.load()函数，从JSON文件中读取数据并转换为Python对象。

import json

with open('data.json', 'r') as file:
    data = json.load(file)
    print(data)

上述代码将从名为data.json的文件中读取数据，并转换为Python对象。

3.5 numpy

一般import numpy as np

NumPy是一个强大的Python库，主要用于进行大规模多维数组和矩阵的数值计算。以下是一些常用的NumPy函数及其使用方法：

创建数组（Array Creation）:
- numpy.array(): 这个函数用于将列表、元组或标量转换为NumPy数组。
  1
  2
  python`import numpy as np
  arr = np.array([1, 2, 3, 4, 5])`
切片（Slicing）:
- [:]: 用于获取数组的子集。
  1
  python`arr[1:3] # [2, 3]`
数学运算（Mathematical Operations）:
- numpy.sum(): 计算数组中所有元素的和。
- numpy.mean(): 计算数组的平均值。
矩阵运算（Matrix Operations）:
- numpy.dot(): 计算两个数组的点积。
索引和切片（Indexing and Slicing）:
- 使用负索引从后向前选择元素。例如：arr[-1] 将返回最后一个元素。
排序和搜索（Sorting and Searching）:
- numpy.sort(): 对数组进行排序。
- numpy.where(): 返回满足给定条件的元素的索引。
文件操作（File Operations）:
- numpy.load(): 从文件中加载NumPy数组。
- numpy.save(): 将NumPy数组保存到文件。例如：np.save('my_array.npy', arr)。
统计和统计函数（Statistics and Statistical Functions）:
- numpy.mean(): 计算数组的平均值。
- numpy.std(): 计算数组的标准偏差。
线性代数（Linear Algebra）: NumPy库提供了许多线性代数函数，如矩阵乘法、逆矩阵、特征值等。例如：np.dot(A, B) 执行矩阵乘法，np.linalg.inv(A) 返回矩阵A的逆矩阵。
随机数生成（Random Number Generation）: NumPy库提供了许多用于生成随机数的函数，如 numpy.random.rand()，numpy.random.randn() 等。例如：np.random.rand(3, 4) 将生成一个3x4的随机数组。

3.6 pandas

pandas库是Python中常用的数据处理库，其中包含了许多有用的函数和方法。以下是一些pandas库中常用的函数及其使用方法举例：

pandas.Series：创建一个一维数组，可以包含不同类型的数据。

import pandas as pd

# 创建一个Series对象
s = pd.Series([1, 2, 3, 4, 5])
print(s)

pandas.DataFrame：创建一个二维表格，可以包含行和列数据。

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
print(df)

pandas.read_csv：从CSV文件中读取数据并返回一个DataFrame对象。

import pandas as pd

# 从CSV文件中读取数据
df = pd.read_csv('data.csv')
print(df)

pandas.DataFrame.head：返回DataFrame的前n行数据。

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
print(df.head(3))  # 返回前3行数据

pandas.DataFrame.tail：返回DataFrame的最后n行数据。

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
print(df.tail(3))  # 返回最后3行数据

pandas.DataFrame.index：返回DataFrame的索引。

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
print(df.index)  # 返回索引值

3.7 h5py

h5py是一个Python库，它提供了与HDF5文件格式的接口。HDF5是一种存储大量数据的文件格式，包括矩阵数据，统计数据等。在科学计算和数据分析中常常使用到。

以下是h5py库中的一些常用函数及其使用方法：

h5py.h5o.open(): 这个函数用于打开HDF5对象。它需要两个参数：一个是文件句柄，另一个是要打开的对象的名称。返回值是一个新的句柄，用于后续操作。

1
2
3

import h5py
f = h5py.File('mytestfile.hdf5', 'r')
dset = f['mydataset']

h5py.h5d.create(): 这个函数用于创建一个新的数据集。它需要两个参数：一个是文件句柄，另一个是数据集的名称。返回值是一个新的数据集句柄，用于后续操作。

1
2
3

import h5py
f = h5py.File('mytestfile.hdf5', 'w')
dset = h5py.h5d.create(f, 'mydataset', h5py.h5t.STD_I32BE, (100,))

h5py.h5d.write(): 这个函数用于将数据写入数据集。它需要四个参数：一个是数据集的句柄，另一个是要写入的数据，第三个是数据的缓冲区，第四个是数据的长度。

import h5py
f = h5py.File('mytestfile.hdf5', 'w')
dset = h5py.h5d.create(f, 'mydataset', h5py.h5t.STD_I32BE, (100,))
data = [i for i in range(100)]
dset.write(data, data)

h5py.h5d.read(): 这个函数用于从数据集中读取数据。它需要两个参数：一个是数据集的句柄，另一个是数据的缓冲区。返回值是读取的数据。

import h5py
f = h5py.File('mytestfile.hdf5', 'r')
dset = f['mydataset']
data = np.zeros((100,), dtype=np.int32)
dset.read(data)

以上就是h5py库中的一些常用函数的使用方法，当然还有许多其他函数，具体使用方法可以查阅官方文档或相关教程。

3.8 torch

PyTorch库是一个广泛使用的深度学习框架，它提供了许多功能强大的函数和方法来支持模型训练和推理。以下是一些常用的PyTorch库使用方法，以及示例说明：

导入PyTorch库

1	import torch

创建张量（Tensor）

1	x = torch.tensor([1, 2, 3]) # 创建一个包含元素1、2、3的张量

定义模型

model = torch.nn.Sequential(
    torch.nn.Linear(in_features=64, out_features=128),
    torch.nn.ReLU(),
    torch.nn.Linear(in_features=128, out_features=10)
)

定义损失函数和优化器

1 2	criterion = torch.nn.CrossEntropyLoss() # 定义损失函数为交叉熵损失 optimizer = torch.optim.SGD(model.parameters(), lr=0.01) # 定义优化器为随机梯度下降，学习率为0.01

训练模型

for epoch in range(num_epochs):
    for inputs, labels in dataloader:
        optimizer.zero_grad()  # 清空梯度缓存
        outputs = model(inputs)  # 前向传播
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播，计算梯度
        optimizer.step()  # 更新权重，执行梯度下降

模型推理（预测）

1 2	with torch.no_grad(): # 关闭梯度计算，加速推理过程 outputs = model(inputs) # 前向传播，得到预测结果

保存和加载模型

1 2	torch.save(model.state_dict(), 'model_weights.pth') # 保存模型权重到文件 model_loaded = torch.load('model_weights.pth') # 从文件加载模型权重到模型对象中

3.9 torchtext

Torchtext是一个用于文本处理的库，它可以帮助我们更有效地处理文本数据，支持深度学习模型训练等。以下是一些Torchtext库中的常用使用方法：

建立语料库（Dataset）

使用Torchtext可以方便地建立语料库，只需要提供数据路径、格式、Field等信息即可。例如：

from torchtext.data import TabularDataset

# 定义数据路径和格式
path = 'data.csv'
format = 'csv'

# 定义Field信息
fields = [('text', torchtext.data.Field(batch_first=True, pad_token=0, unk_token=1))]

# 建立语料库
dataset = TabularDataset(path, format=format, fields=fields)

建立索引库（Index）

使用Torchtext可以方便地建立索引库，包括词2指数和指数2词的映射。例如：

from torchtext.vocab import GloVe

# 加载预训练的词向量（以GloVe为例）
glove = GloVe(name='6B', dim=100)

# 建立词2指数映射（返回一个包含所有词向量的张量）
index2word = glove.build_vocab()

# 建立指数2词映射（返回一个包含所有指数的张量）
word2index = {v: i for i, v in enumerate(index2word)}

数据预处理（Field）

使用Torchtext可以方便地进行文本数据预处理，例如分词、转换为小写、补全字符等。例如：

from torchtext.data import Field

# 定义分词方法和其他配置信息
field = Field(tokenize='spacy', tokenizer_language='en_core_web_sm', lower=True, pad_token=0, unk_token=1, include_lengths=True)

3.10 math

Python的math库中有很多函数，可以帮助我们在数学计算中更加便捷。以下是math库中的一些常用函数及使用方法：

math.ceil(x)：返回大于或等于x的最小整数。例如，math.ceil(10.2)的结果是11。
math.floor(x)：返回小于或等于x的最大整数。例如，math.floor(10.2)的结果是10。
math.sqrt(x)：返回x的平方根。例如，math.sqrt(16)的结果是4。
math.sin(x)、math.cos(x)、math.tan(x)：分别返回x的正弦值、余弦值和正切值。例如，math.sin(math.pi/2)的结果是1.0，math.cos(0)的结果是1.0，math.tan(math.pi/4)的结果是1.0。
math.exp(x)：返回e的x次幂。例如，math.exp(1)的结果是2.718281828459045。
math.log(x)：返回x的自然对数。例如，math.log(10)的结果是2.302585092994046。
math.pi：返回圆周率π的值。例如，math.pi的结果是3.141592653589793。
math.isclose(a, b, rel_tol=1e-09, abs_tol=0.0)：比较两个值是否相等，如果相等返回True，否则返回False。其中，rel_tol是相对容差，abs_tol是绝对容差。例如，math.isclose(math.pi, math.pi10000*(1/5))的结果是True。

以上只是math库中的一些常用函数和使用方法，math库还提供了其他更多功能强大的函数供我们使用。

3.11 tqdm

Tqdm是一个快速，可扩展的Python进度条，可以在Python长循环中添加一个进度提示信息，用户只需要封装任意的迭代器tqdm(iterator)。使用pip就可以安装。使用tqdm的前提是from tqdm import tqdm。

以下是一些tqdm库的常用使用方法和示例：

基本用法：只需要封装任意的迭代器tqdm(iterator)。

from tqdm import tqdm
import time

for i in tqdm(range(100)):
    time.sleep(0.01)  # 模拟一个耗时操作

在这个例子中，我们使用tqdm封装了range对象，在每次循环时，都会显示一个进度条，实时显示当前循环的进度。

自定义进度条的显示：可以通过设置参数来定制进度条的显示。

from tqdm import tqdm
import time

for i in tqdm(range(100), desc="处理进度", ncols=100):  # 添加描述和进度条宽度
    time.sleep(0.01)  # 模拟一个耗时操作

在这个例子中，我们添加了进度条的描述和宽度。

使用tqdm处理文件读取：可以在文件读取操作中使用tqdm。

from tqdm import tqdm
import glob

# 获取所有.txt文件
for filename in tqdm(glob.glob('*.txt')):
    with open(filename, 'r') as f:
        data = f.read()  # 读取文件内容

在这个例子中，我们使用tqdm处理了文件读取操作。对于每个找到的.txt文件，都会在进度条中显示其处理的进度。

3.12 glob

glob是Python标准库中的一个模块，用于处理文件和目录的通配符匹配。以下是glob库的一些常用使用方法和示例：

glob.glob(pattern): 返回一个列表，包含所有符合特定模式的文件路径名。可以使用一些特殊字符来实现通配符匹配，例如：*代表匹配任意长度的任意字符，?代表匹配任意单个字符，[char]或[!char]代表匹配括号中任意一个或不在括号中的字符。

示例：

import glob

# 查找当前目录下所有以 .txt 结尾的文件
text_files = glob.glob('*.txt')
print(text_files)

glob.iglob(pattern): 返回一个生成器对象，可以使用for循环逐一获取符合特定模式的文件路径名。

示例：

import glob

# 使用生成器逐一获取当前目录下所有以 .txt 结尾的文件名
for filename in glob.iglob('*.txt'):
    print(filename)

使用特殊字符进行模式匹配：glob模块支持使用特殊字符进行模式匹配，例如：*代表匹配任意长度的任意字符，?代表匹配任意单个字符，[char]或[!char]代表匹配括号中任意一个或不在括号中的字符。

示例：

import glob

# 查找当前目录下所有以 a 或者 b 开头，且以 .txt 结尾的文件
ab_files = glob.glob('[ab]*.txt')
print(ab_files)

3.13 logging

logging库是Python的标准库之一，用于记录日志信息。它提供了多种功能，如设置日志级别、添加日志格式、创建日志文件等。以下是一些logging库的常用使用方法和示例：

导入logging模块

1	import logging

设置日志级别和日志格式

1 2	logging.basicConfig(filename='example.log', level=logging.DEBUG, format='%(asctime)s %(levelname)s %(message)s')

这里设置了日志级别为DEBUG，将日志信息输出到example.log文件中，并指定了日志的格式。

创建logger对象

1	logger = logging.getLogger('example_logger')

这里创建了一个名为”example_logger”的logger对象。

设置logger对象的日志级别

1	logger.setLevel(logging.DEBUG)

这里设置了logger对象的日志级别为DEBUG。

添加handler对象，用于将日志信息输出到指定目的地

1	handler = logging.FileHandler('example_handler.log')

这里创建了一个FileHandler对象，将日志信息输出到example_handler.log文件中。

设置handler对象的日志格式

1 2	formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s') handler.setFormatter(formatter)

这里创建了一个Formatter对象，并设置handler对象的日志格式为该Formatter对象。

将handler对象添加到logger对象中

1	logger.addHandler(handler)

这里将handler对象添加到logger对象中，使得logger对象可以将日志信息输出到example_handler.log文件中。

记录日志信息

logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

这里使用logger对象记录了不同级别的日志信息。根据日志级别，日志信息将按照设置的顺序输出到example.log文件中。同时，example_handler.log文件中也将记录这些日志信息。

3.14 time

Python的time库提供了各种与时间相关的功能，包括获取当前时间、计算时间差、处理时区等。以下是一些time库中常用的使用方法和示例：

time.time(): 返回自1970年1月1日以来的秒数。这是一个浮点数，可以用于表示特定的时间点。

示例：

import time

current_time = time.time()
print(current_time)  # 输出类似 1615833877.989923 的浮点数

time.sleep(seconds): 使程序暂停指定的秒数。

示例：

import time

print("开始休眠")
time.sleep(5)  # 程序将暂停5秒
print("休眠结束")

time.localtime(seconds): 将给定的秒数转换为本地时间。返回一个包含年、月、日、时、分、秒和微秒的time.struct_time对象。

示例：

import time

current_local_time = time.localtime()
print(current_local_time)  # 输出类似 (2023, 3, 15, 16, 28, 37, 46, 3079, 2) 的元组

time.mktime(time_tuple): 反过来看，可以将一个time.struct_time对象转换回秒数。

示例：

import time

current_local_time = time.localtime()
seconds = time.mktime(current_local_time)
print(seconds)  # 输出类似 1647275817.0 的浮点数

time.strftime(format, time_tuple): 根据给定的格式字符串和时间元组，生成一个字符串表示特定日期和时间的日期时间。

示例：

import time

current_local_time = time.localtime()
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", current_local_time)
print(formatted_time)  # 输出类似 '2023-03-15 16:28:37' 的字符串

感谢看到这里，在记录中收获成长，道阻且长

“灵能相谈所”

python使用总结

1 python语法简介

1.1 基础语法

1.1.1 主函数

1.1.2 循环

1.1.3 函数

1.1.4 类

1.1.5 引用import

1.1.6 `init.py`文件

1.2 内置函数

1.2.1 getattr()函数

1.2.2 print函数

2 python运行和调试

3 调库大法好

3.1 argparse库

3.2 easydict库

3.3 yaml库

3.4 json库

3.5 numpy

3.6 pandas

3.7 h5py

3.8 torch

3.9 torchtext

3.10 math

3.11 tqdm

3.12 glob

3.13 logging

3.14 time

1 python语法简介

1.1 基础语法

1.1.1 主函数

1.1.2 循环

1.1.3 函数

1.1.4 类

1.1.5 引用import

1.1.6 __init__.py文件

1.2 内置函数

1.2.1 getattr()函数

1.2.2 print函数

2 python运行和调试

3 调库大法好

3.1 argparse库

3.2 easydict库

3.3 yaml库

3.4 json库

3.5 numpy

3.6 pandas

3.7 h5py

3.8 torch

3.9 torchtext

3.10 math

3.11 tqdm

3.12 glob

3.13 logging

3.14 time

1.1.6 `init.py`文件