python学习

1 python中的“r”，“b”，“u”，“f”的含义

r 忽略文本中的转义字符；
　　eg
　　　　str1= 'input '
　　　　str= r'input '
　　　　print(str1)
　　　　print(str)

　　输出：
　　　　input
　　　　input

f 支持大括号内的python表达式；
　　eg
　　　　name = 'processing'
　　　　print(f'{name} done in {time.time() - t0:.2f} s')
　　输出：
　　　　processing done in 1.00 s

b 后面字符串是bytes 类型。
　　用处：网络编程中，服务器和浏览器只认bytes 类型数据；

u 含有中文字符组成的字符串
　　作用：
　　　　后面字符串以 Unicode 格式 进行编码，一般用在中文字符串前面，防止因为源码储存格式问题，导致再次使用时出现乱码；

2 基础类型：

　　2.1 字典：

　　　　字典是另一种可变容器模型，且可存储任意类型对象；

　　　　字典的每个键值 key value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：d = {key1 : value1, key2 : value2 }

　　2.2 列表：

　　　　类似于cpp中的数组，是常用结构，list=[1，2，3]

　　2.3 元组：

　　　　元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

　　　　tuple1 = （1，2，3）

 

3 模块

　　Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句；

　　模块让你能够有逻辑地组织你的 Python 代码段；把相关的代码分配到一个模块里能让你的代码更好用，更易懂；

　　模块能定义函数，类和变量，模块里也能包含可执行的代码；

　　举例：

　　下例是个简单的模块 support.py：

　　　　def print_func（par）：

　　　　　　print “hello world”，par

　　　　　　return

　　主函数：

　　　　import support

　　　　　　support.print_func("sk")

　　引用模块：比如要引用模块 math，就可以在文件最开始的地方用 import math 来引入。在调用 math 模块中的函数时，必须这样引用：模块名.函数名；

　　当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

　　搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support.py，需要把命令放在脚本的顶端：

　　输出结果：

　　hello world sk

4 类

import numpy as np# import 简写

import torch.nn as nn

class test:

　　def __init__(self,argv1,argv2=True)：

　　　　if argv1 == ‘test’：
　　　　　　……

　　　　elif argv1 == 'test2':

　　　　　　……
　　　　else:
　　　　　　print('Not support')

　　def func1(self, input):

　　　　return

5 输出进度条，tdqm

　　for i in tqdm(np.unique(ids)) :
　　　　do something；

6 python报错说明：

　　python没有编译，所以一般是运行时报错的；一下列举几个发现的报错机器原因：

　　　　IndentationError：unexpected indent #一般是缩进问题，python的缩进是有明确规定的，这块是缩进异常；

　　　　SyntaxErr：invalid syntax #句法错误，无效的句法，一般是用了无效的命令等；

7 一个实例

#!/usr/bin/env python #python位置
# -*- coding: utf-8 -*- #编码格式 utf8

import sys
import string

print(sys.argv) #输出参数

class node(object): #定义一个，记录开始和结束点的类
    def __init__(self,st,ed):
        self.st = st
        self.ed = ed

def change(in_str): #将原来txt文本中 A 转换成1，""则表示空
    if ( in_str == ' "A" ' ) :
        return 1
    elif ( in_str == ' "" ' ) :
        return -1
    else :
        return in_str

in = sys.argv[1]
out = sys.argv[2]

if ("txt" in out) : #输入文本，必须以txt结尾
    name = out[out.rfind("/") + 1:out.find(".txt")] #rfind,从后往前找；
else :
    exit()

with open(in,"r") as f:
    txt = f.readlines() # 输入到一个列表中
    print(len(txt),' file size
') #列表size

for i in range(len(txt)) :
    txt[i] = txt[i].strip("
") #去掉


#输入格式,输入文件为：input.txt
#count [0]:
#    st=0.1
#    ed=0.3
#    lab=A
#count [1]:
#    st=0.4
#    ed=0.6
#    lab=B

#输出格式
#input 1 0.1 0.3
#input 2 0.4 0.6

list_seg = []
for i in range(len(txt)) :
    if ("count [" in txt[i] ) :#改行包含count [
        st = str(round(float(txt[i + 1][txt[i + 1].find("=") + 1:]),3)) 
        # txt[i + 1][txt[i + 1].find("=") + 1:])获取下一行，等号之后的内容；
        # str(round(float(…),3))，将内容转成float，保存小数点后三位，再转成string
        ed = str(round(float(txt[i + 2][txt[i + 2].find("=") + 1:]),3))
        lab = str(change(txt[i + 3][txt[i + 3].find("=") + 1:]))
        if ( lab == '-1' ):
            continue
        list_seg.append(node(st,ed,lab))#等于cpp中vector的push_back

with open(out_r,"w") as f:
    for i in range(len(list_seg)) :
        f.writelines([name," 1 ",list_seg[i].st,list_seg[i].ed,"
"])

8 argparse.ArgumentParser()用法解析

定义：argparse是一个Python模块：命令行选项、参数和子命令解析器；类似于一个结构体；
　　主要有三个步骤：
　　　　创建 ArgumentParser() 对象；
　　　　调用 add_argument() 方法添加参数；
　　　　使用 parse_args() 解析添加的参数；

　　举例：

　　a 创建解析器
　　　　parser = argparse.ArgumentParser(description='an example')

　　b 添加参数

　　　　parser.add_argument('--batch_size', type=int, default=32,  help='Batch size')
　　c 解析参数
　　　　args = parser.parse_args()

9 python 计时

　　#获取当前时间戳，精确到秒

　　　　>>> import time
　　　　>>> time.time()
　　　　1614862155.740315

　　#时间转换为字符串

　　　　time.strftime(format,dt) dt为具体时间，datetime和date格式均可,甚至可以为时间数组struct_time

　　　　或者

　　　　dt.strftime(format)
　　　　format　可以取"%Y-%m-%d %H:%M:%S"的任意子串，来决定显示年月日时分秒
　　＃字符串转时间

　　　　datetime.datetime.strptime(detestr,format) datestr为字符串

　　

 10 连续等号

　　>>> a=b=c=2 # 连续=是赋值

　　>>> print(a,b,c)
　　2 2 2

　　>>> a==b
　　True
　　>>> a==b==c
　　True
　　>>> d=1
　　>>> a==b==d
　　False
　　>>> a==b==c==d # 连续==是判断，有一个不一样都不行

　　False

11 Variable

　　顾名思义，Variable就是 变量 的意思。实质上也就是可以变化的量，区别于int变量，它是一种可以变化的变量，这正好就符合了反向传播，参数更新的属性；

　　具体来说，在pytorch中的Variable就是一个存放会变化值的地理位置，也就是说，pytorch都是有tensor计算的，而tensor里面的参数都是Variable的形式。如果用Variable计算的话，那返回的也是一个同类型的Variable；

　　注：tensor不能反向传播，variable可以反向传播；

12 python 调试

　　python调试命令是python -m pdb test.py

　　其调试命令和gdb类似，n是单步调试，b是断点；

13 循环方式：

　　range()

　　　　range（） 返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表

　　　　>>> for i in range(5):
　　　　... print(i)
　　　　...
　　　　0
　　　　1
　　　　2
　　　　3
　　　　4　　

　　　　>>> print(range(10)[::2])
　　　　range(0, 10, 2)

　　　　A[开始：结束：步长]等同于range(开始, 结束, 步长)

　　enumerate（）

　　　　enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标；　

　　　　>>> seq = ['one', 'two', 'three'] 

　　　　>>> for i, element in enumerate(seq): # 枚举seq中所有

　　　　 ...　　 print i, element

　　　　 ... 

　　　　0 one 

　　　　1 two

　　　　2 three

 

 　　普通for循环

　　　　>>>i = 0

　　　　>>> seq = ['one', 'two', 'three']

　　　　>>> for element in seq:

　　　　... 　　print i, seq[i]

　　　　... 　　i +=1

　　　　...

　　　　0 one

　　　　1 two

　　　　2 three

 

14 优化器optimizer，使用torch.optim

　　torch.optim是一个实现了多种优化算法的包，大多数通用的方法都已支持，提供了丰富的接口调用，未来更多精炼的优化算法也将整合进来; 
　　为了使用torch.optim，需先构造一个优化器对象Optimizer，用来保存当前的状态，并能够根据计算得到的梯度来更新参数; 
　　要构建一个优化器optimizer，你必须给它一个可进行迭代优化的包含了所有参数（所有的参数必须是变量s）的列表。 然后，您可以指定程序优化特定的选项，例如学习速率，权重衰减等;

　　常见算法是sgd和adam；

　　adam定义见机器学习词汇；

　　参数：

　　　　params(iterable)：可用于迭代优化的参数或者定义参数组的dicts；

　　　　lr (float, optional) ：学习率(默认: 1e-3)； 　　

　　　　betas (Tuple[float, float], optional)：用于计算梯度的平均和平方的系数(默认: (0.9, 0.999)) 　　

　　　　eps (float, optional)：为了提高数值稳定性而添加到分母的一个项(默认: 1e-8) 　　

　　　　weight_decay (float, optional)：权重衰减(如L2惩罚)(默认: 0)
　　函数：

　　　　step(closure=None)函数：执行单一的优化步骤；

　　　　closure (callable, optional)：用于重新评估模型并返回损失的一个闭包；

　　　　load_state_dict（）加载模型；

　　　　zero_grad（）梯度设置成0；

 15 python 监控gpu显存

　　import pynvml

　　pynvml.nvmlInit()

　　handle = pynvml.nvmlDeviceGetHandleByIndex(0)
　　meminfo = pynvml.nvmlDeviceGetMemoryInfo(handle)
　　print(meminfo.total/1024**2)#总显存
　　print(meminfo.used/1024**2)#使用
　　print(meminfo.free/1024**2)#空闲

16 写文件，写log，输出到控制台

　　16.1 示例：

　　　　a

　　　　with open("log", "a") as file: #存储文件
　　　　　　np.savetxt(file, object, fmt="%.2f", delimiter=',')

　　　　b

　　　　with open("log", "w") as file: #这样写入是缩略版本
　　　　　　str1= str(obj)
　　　　　　file.write(strNum)

　　　　c 

　　　　list2 = np.arange(2000).astype(float)
　　　　list3 = []
　　　　ik = 0
　　　　while ik < 10 :
　　　　　　print(ik)
　　　　　　ik += 1
　　　　　　list3.append(list2)

　　　　print(list3) #输出二维数组

　　16.2 控制输出方式：

　　　　np.set_printoptions(threshold=np.inf) #控制省略个数，意思是输出个数为inf时候才开始省略，inf是无限的个数；所以次意是完全输出，不显示省略号；
　　　　如果使用pytorch，需要全部输出，不带省略号，需要添加命令 torch.set_printoptions(threshold=np.inf)