基础语法
字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号 ( ' 或 " ) 来创建字符串。
| 方法 | 描述 |
|---|---|
| 把字符串的第一个字符大写 | |
| 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 | |
| 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | |
| 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace' | |
| 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' | |
| 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. | |
| 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 | |
| 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 | |
| 格式化字符串 | |
| 跟find()方法一样，只不过如果str不在 string中会报一个异常. | |
| 如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False | |
| 如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False | |
| 如果 string 只包含十进制数字则返回 True 否则返回 False. | |
| 如果 string 只包含数字则返回 True 否则返回 False. | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False | |
| 如果 string 中只包含数字字符，则返回 True，否则返回 False | |
| 如果 string 中只包含空格，则返回 True，否则返回 False. | |
| 如果 string 是标题化的(见 title())则返回 True，否则返回 False | |
| 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False | |
| 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 | |
| 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 | |
| 转换 string 中所有大写字符为小写. | |
| 截掉 string 左边的空格 | |
| maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 | |
| 返回字符串 str 中最大的字母。 | |
| 返回字符串 str 中最小的字母。 | |
| 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. | |
| 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. | |
| 类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。 | |
| 类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。 | |
| 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 | |
| 类似于 partition()函数,不过是从右边开始查找 | |
| 删除 string 字符串末尾的空格. | |
| 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串 | |
| 按照行('\r', '\r\n', '\n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 | |
| 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. | |
| 在 string 上执行 lstrip()和 rstrip() | |
| 翻转 string 中的大小写 | |
| 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) | |
| 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 | |
| 转换 string 中的小写字母为大写 | |
| 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
Tensor
Pytorch基础：张量Tensor_张量 tensor-CSDN博客
从内置数据类型创建
>>> x1=[1,2,3]
>>> x1_tensor=torch.tensor(x1,dtype=torch.int32)
>>> print(x1_tensor)
tensor([1, 2, 3], dtype=torch.int32)从numpy创建
>>> import numpy as np
>>> x2_numpy=np.array([1,2,3])
>>> x2.tensor=torch.from_numpy(x2_numpy)
>>> x2_tensor=torch.from_numpy(x2_numpy)
>>> print(x2_tensor)
tensor([1, 2, 3], dtype=torch.int32)维度分析
>>> x= torch.randn(1,3,4,4)
>>> print("ndimension:",x.ndimension()) //张量的维度
ndimension: 4
>>> print("nelement:",x.nelement()) //张量包含的元素总数
nelement: 48
>>> print("size",x.size()) //张量的尺寸信息
size torch.Size([1, 3, 4, 4])
>>> print("shape:",x.shape) //
shape: torch.Size([1, 3, 4, 4])
>>>
>>> x_view=x.view(1,3,4*4)
>>> print("x_view:",x_view.size())
x_view: torch.Size([1, 3, 16])
>>>
>>> x_view=x.view(1,-1)
>>> print("x_view:",x_view.size()) //view的一个参数是-1，pytorch会根据其他维度自动计算这一维度的大小
x_view: torch.Size([1, 48])
>>>
//====transpose方法，将2行3列的张量变换成3行2列的张量
>>> x= torch.randn(2,3)
>>> print(x)
tensor([[-0.7116, 1.0912, -1.3217],
[ 0.1371, -0.6021, -0.9689]])
>>> x_trans=x.transpose(1,0)
>>> print(x_trans)
tensor([[-0.7116, 0.1371],
[ 1.0912, -0.6021],
[-1.3217, -0.9689]])
>>>
//=======squeeze删除1维度，此时张量的数据内容不变
>>> x=torch.randn(1,3,16,16)
>>> x=x.squeeze(0)
>>> print(x.size())
torch.Size([3, 16, 16])
//=======squeeze增加1维度，此时张量的数据内容不变
>>> x=x.unsqueeze(0)
>>> print(x.size())
torch.Size([1, 3, 16, 16])
>>>
argmin,argmax
argmax/argmin函数：得到张量的最大/小输出值的对应索引位置
t=torch.tensor([ [1,2,1,4],
[10,3,2,8],
[6,7,9,66],
[5,46,78,54] ], dtype=torch.float32)
t.argmax() # 输出的是flatten后的索引
t.argmax(dim=0) # 输出的是每列(第0维)的最大值索引
t.aggmax(dim=1) # 输出的是每行(第1维)的最大值索引
t.aggmin(dim=0) # 输出的是每列(第0维)的最小值索引
结果： 11；[1,3,3,2]；[3,0,3,2]；[0,0,0,0]zip
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped) # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b)) # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>>>> a = ['a', 'b', 'c', 'd']
>>> b = ['1', '2', '3', '4']
>>> list(zip(a, b))
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]
>>> dict_one = {'name': 'John', 'last_name': 'Doe', 'job': 'Python Consultant'}
>>> dict_two = {'name': 'Jane', 'last_name': 'Doe', 'job': 'Community Manager'}
>>> for (k1, v1), (k2, v2) in zip(dict_one.items(), dict_two.items()):
... print(k1, '->', v1)
... print(k2, '->', v2)
...
name -> John
name -> Jane
last_name -> Doe
last_name -> Doe
job -> Python Consultant
job -> Community Manager
total_sales = [52000.00, 51000.00, 48000.00]
prod_cost = [46800.00, 45900.00, 43200.00]
for sales, costs in zip(total_sales, prod_cost):
profit = sales - costs
print(f'Total profit: {profit}')
结果：
Total profit: 5200.0
Total profit: 5100.0
Total profit: 4800.0
考虑一个场景：你正在处理一些学生的成绩，有这样两个列表：
names = ['John', 'Amy', 'Jack']
scores = [98, 100, 85] # 分数和名字是一一对应的
如果你想对它们进行排序，又不想破坏对应关系的话，就可以这样：
data = list(zip(names, scores))
data.sort()
结果：
[('Amy', 100), ('Jack', 85), ('John', 98)]
如果要先对分数进行排序：
data2 = list(zip(scores, names))
data2.sort()
结果：
[(85, 'Jack'), (98, 'John'), (100, 'Amy')]
构建字典
回到上面处理学生成绩的场景：如果你想将两个列表合并起来，得到一个姓名-分数的字典，就可以：
stu = dict(zip(names, scores))
结果显示：
{'John': 98, 'Amy': 100, 'Jack': 85}
range
- range(n,m,k):相等于其他函数里面的for循环。n是初始值，m是结束值，k是步长，会生成初始值为n,结束值为m-1,递减或者递增的整数序列
- range(n,m):默认生成一个n到m-1的整数序列，对于这个整数序列，我们可以通过list()函数转化为列表类型的数据
- range(n）:默认生成一个0到n-1的整数序列，对于这个整数序列，我们可以通过list()函数转化为列表类型的数据。
range方法生成的是可迭代的数据类型，那么就可以结合for来做遍历循环操作。
range(len())
在处理列表时，有时需要同时遍历列表的索引和数值。这时可以利用 range(len()) 函数来生成与列表长度相同的整数序列，并在循环中使用该序列的元素作为列表的索引。例如，以下代码演示了如何遍历一个列表并输出其索引和数值：
fruit_list = ['apple', 'banana', 'orange']
for i in range(len(fruit_list)):
print('Index:', i, 'Value:', fruit_list[i])join
Python中有.join()和os.path.join()两个函数，具体作用如下：
- . join()： 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
- os.path.join()： 将多个路径组合后返回
#对序列进行操作（分别使用' ' 、' - '与':'作为分隔符）：
a=['1aa','2bb','3cc','4dd','5ee']
print(' '.join(a)) #1aa 2bb 3cc 4dd 5ee
print(';'.join(a)) #1aa;2bb;3cc;4dd;5ee
print('.'.join(a)) #1aa.2bb.3cc.4dd.5ee
print('-'.join(a)) #1aa-2bb-3cc-4dd-5ee#对字符串进行操作（分别使用' ' 、' - '与':'作为分隔符）：
b='hello world'
print(' '.join(b)) # h e l l o w o r l d
print('-'.join(b)) # h-e-l-l-o- -w-o-r-l-d
print(':'.join(b)) # h:e:l:l:o: :w:o:r:l:d#对元组进行操作（分别使用' ' 、' - '与':'作为分隔符）：
c=('aa','bb','cc','dd','ee')
print(' '.join(c)) # aa bb cc dd ee
print('-'.join(c)) # aa-bb-cc-dd-ee
print(':'.join(c)) # aa:bb:cc:dd:e#对字典进行无序操作（分别使用' ' 、' - '与':'作为分隔符）：
d={'name1':'a','name2':'b','name3':'c','name4':'d'}
print(' '.join(d)) # name1 name2 name3 name4
print('-'.join(d)) # name1-name2-name3-name4
print(':'.join(d)) # name1:name2:name3:name4#对于字符串截取后使用join拼接：
str='G20-放假安排'
print(str.split('-')[1:]) #截取从第一个往后 ['放假安排']
print('-'.join('G20-杭州峰会-放假时间-放假安排'.split('-')[1:])) #截取从第一个往后的所有，并且使用 - 连接； 杭州峰会-放假时间-放假安排
str1='G20-杭州峰会-放假时间-放假安排'
print('-'.join(str1.split('-')[:-1]) ) #截取后，去除最后一个
print('G20-杭州峰会-放假时间-放假安排'.split('-')[-1]) # 取出最后一个-后内容#对目录进行操作：
import os
print(os.path.join('/hello/','good/date/','datbody')) #/hello/good/date/datbody常用类和库
tqdm
【python第三方库】tqdm——超详细解读-CSDN博客
tqdm是一个方便且易于扩展的Python进度条，可以在python执行长循环时在命令行界面实时地显示一个进度提示信息，包括执行进度、处理速度等信息，且可在一定程度上进行定制。
from tqdm import tqdm
import time
for i in tqdm(range(100)):
time.sleep(0.1)
pass
pickle
pickle --- Python 对象序列化 — Python 3.12.4 文档
序列化：把对象转换为字节序列的过程称为对象的序列化。
反序列化：把字节序列恢复为对象的过程称为对象的反序列化。
python中的pickle模块实现了基本的数据序列化和反序列化。
通过pickle模块的序列化操作能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，能够从文件中创建上一次程序保存的对象。
pickle模块使用的数据格式是python专用的，能够把python对象直接保存到文件，而不需要转化为字符串，也不用底层的文件访问操作把它们写入到一个二进制文件中。
dump
pickle.dump(obj, file, [,protocol])函数的功能：将obj对象序列化存入已经打开的file中。
参数:
obj：想要序列化的obj对象。
file：文件名称。
protocol：序列化使用的协议。如果该项省略，则默认为0。如果为负值或HIGHEST_PROTOCOL，则使用最高的协议版本。
load
pickle.load(file)函数的功能：将file中的对象序列化读出。
参数:file：文件名称。
dumps
pickle.dumps(obj[, protocol])函数的功能：将obj对象序列化为string形式，而不是存入文件中。
参数:
obj：想要序列化的obj对象。
protocal：如果该项省略，则默认为0。如果为负值或HIGHEST_PROTOCOL，则使用最高的协议版本。
loads
pickle.loads(string)函数的功能：从string中读出序列化前的obj对象。
参数:string：文件名称。
importlib
importlib 是 Python 的标准库模块之一，用于实现import语句的模块。通过 importlib，可以在运行时根据需要导入模块，而不是在代码的开头静态地导入它们。
动态导入
importlib模块支持传递字符串来导入模块。我们先来创建一些简单模块一遍演示。我们在模块里提供了相同接口，通过打印它们自身名字来区分。我们分别创建了foo.py和bar.py，代码如下：
def main():
print(__name__)现在我们尽需要使用importlib导入它们。我们来看看代码是如何实现的，确保该代码在刚才创建的两个文件的相同目录下。
#importer
import importlib
def dynamic_import(module):
return importlib.import_module(module)
if __name__ == "__main__":
module = dynamic_import('foo')
module.main()
module2 = dynamic_import('bar')
module2.main()这里我们导入importlib模块，并创建了一个非常简单的函数dynamic_import。这个函数直接就调用了importlib的import_module方法，并将要导入的模块字符串传递作为参数，最后返回其结果。然后在主入口中我们分别调用了各自的main方法，将打印出各自的name.
$ python3 importer.py
foo
bar也许你很少会代码这么做，不过在你需要试用字符串作为导入路径的话，那么importlib就有用途了。
模块导入检查
导入模块当模块不存在时会抛出ImportError异常，如果我们想在导入模块之前检查该模块是否可以被导入，可以使用importlib模块进行检查，如下：
import importlib.util
def check_module(module_name):
"""检查模块时候能被导入而不用实际的导入模块"""
module_spec = importlib.util.find_spec(module_name)
if module_spec is None:
print('Module: {} not found'.format(module_name))
return None
else:
print('Module: {} can be imported!'.format(module_name))
return module_spec
def import_module_from_spec(module_spec):
"""通过传入模块的spec返回新的被导入的模块对象"""
module = importlib.util.module_from_spec(module_spec)
module_spec.loader.exec_module(module)
return module
if __name__ == '__main__':
module_spec = check_module('fake_module')
module_spec = check_module('collections')
if module_spec:
module = import_module_from_spec(module_spec)
print(dir(module))从源文件中导入
importlib.util工具还有一个功能，可以在仅仅知道模块名字和路径的情况下通过该工具导入，如下：
import importlib.util
def import_source(module_name):
module_file_path = module_name.__file__
module_name = module_name.__name__
module_spec = importlib.util.spec_from_file_location(module_name, module_file_path)
module = importlib.util.module_from_spec(module_spec)
module_spec.loader.exec_module(module)
print(dir(module))
msg = 'The {module_name} module has the following methods: {methods}'
print(msg.format(module_name=module_name, methods=dir(module)))
if __name__ == '__main__':
import os
import_source(os)import_from_github_com
有一个优雅的模块import_from_github_com可以从github中寻找并加载模块，该模块使用了PEP 302中提供的import hook来实现功能。该模块并没有使用importlib模块，而是使用pip安装模块，如果pip没有安装则使用Python的import()函数实际导入新的安装模块。
shutil
shutil：对文件进行高级操作，详细介绍 shutil 模块
shutil 模块是 Python 内置的对文件、目录、压缩文件进行高级操作的模块，该模块对文件的复制、删除和压缩等操作都提供了非常方便的支持。
copy：复制文件或目录
copy 函数可以将一个文件复制为另一个文件（或另一个目录中）。函数原型：
shutil.copy(src, dst, *, follow_symlinks=True)，该函数会返回目标路径，即新创建的文件的路径。参数含义如下：
src：表示文件路径的字符串，表示源文件（注意：必须是文件，如果是目录则报出权限错误）dst：表示文件或目录路径的字符串，如果是一个已经存在的目录，那么会将 src 拷贝到该目录中；否则会创建相应的文件。follow_symlinks：表示是否遵循符号链接，默认为 True。如果为 True 则赋值文件，为 False、并且 src 为软连接，则创建一个新的软连接
import shutil
# 如果 test 存在并且是目录，那么会将 1.txt 拷贝到 test 中
shutil.copy("1.txt", "test")
# 如果 test 不存在，那么会创建一个名为 test 的文件，内容和 1.txt 一致
# 如果 test 存在并且不是目录，那么会把原来的文件覆盖掉（需要具备写权限，否则报错 PermissionError）
shutil.copy("1.txt", "test")
4704
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
