【python】argparse解析参数的过程

python基础知识

  • python文件解析
  • if \_\_name\_\_ == '\_\_main\_\_'的作用
  • import到底导入了什么?
  • argparse解析命令行参数的过程
  • Debug—案例分析

python文件解析

Python和C语言的编译、执行过程有很大区别。我们先回顾一下c语言的执行过程,首先代码文件要编译,编译通过(没有报错)后才能执行——此时执行的已经不是原始的代码文件了,而是二进制可执行文件。 但是python文件,不是对整个代码文件先编译再执行的——运行python文件,比如命令行输入python mytest.py,解析器会从mytest.py文件的第一行开始逐行解析并执行。

总结来说:

  • C语言是静态编译的,即源代码在编译阶段被翻译成机器码,然后在运行时直接执行机器码。
  • Python是解释执行的,源代码在运行时被解释器逐行解释执行,不会直接编译成机器码。

这两种编译方式的差异,使得在C语言中变量和函数都可以先声明后使用,比如一个func1()你只要先声明了,就能使用,不管实际定义(函数体)的位置在哪里;但在Python却不行,你必须先定义一个函数,才能使用,否则就会报错。

另外,Python文件中顶格的代码,即顶层的代码是会被直接执行的;定义的class、function等只有在调用的时候才执行。

if __name__ == '__main__'的作用

python一个文件可以作为一个模块(module),一个python文件利用import机制可以引用另一个文件的部分代码,比如p2.py中用import引用p1.py定义的一个class、function等等,这样在p2.py中就能运行p1.py文件的代码,实现代码复用。

那么当p1.py的部分代码(比如针对p1.py的测试代码),只在该文件被直接运行时被执行,而不会在执行p2.py文件的时候被调用,就可以放在if __name__ == '__main__': 条件模块下。 __name__是python内置的一个特殊变量 :

  • 当python文件作为主文件直接执行时,__name__ == ‘__main__’;
  • 当python文件被import到其他文件时,__name__ ==’ __文件名__';

假设p1.py内容如下:

print("1-This is p1.py file~")
def main():
    print("1-This is main() function in p1.py~")
print(f"1-In p1.py:__name__ =={__name__}")
if __name__ == '__main__':
    main()

直接运行p1.py,输出如下,可见此时p1.py文件的__name__ 为’__main__':
【python】argparse解析参数的过程_第1张图片
假设p2.py内容如下,import了p1.py的main(),但是后续并没有调用:

from p1 import main

print("2-This is p2.py file~")
def main():
    print("2-This is main() function in p2.py~")
print(f"1-In p2.py:__name__ =={__name__}")
if __name__ == '__main__':
    main()

运行p2.py的输出如下:
【python】argparse解析参数的过程_第2张图片
分析可知p1.py中的if __name__ == '__main__':的内容没有执行——即p1.py中的main()函数没有被调用,没有输出那一行。因此p2.py中通过import引用p1.py,运行p2.py时,p1.py中的__name__ ≠ '__main__'而是__name__ = 'p1'。 另外可见输出结果的第二行,直接输出了p1.py文件的__name__。

import到底导入了什么?

一个python文件中定义的类、函数、变量等可以在其他python文件中通过import引入并使用,以实现代码复用。关于import的具体用法(即当一个项目文件夹下很多文件夹,同级、不同级python文件间的引用,以及绝对引用和相对引用)可以参考这个博客python中import的用法

这里我想说的是,p2.py引用了p1.py中的某一个函数(比如main()),那仅仅只是main()函数会被解析吗? 实际并不是这样的! 运行p2.py,解析到from p1 import main时,除了找到p1.py的main()相关代码解析以外,还会解析p1.py中的顶层代码——比如全局变量、顶层的print语句等等
p1.py和p2.py的内容同上,在p2.py中仅仅一句from p1 import main与p1相关,且后续并没有调用p1.main(),但为什么输出中第1行和第2行是p1中的内容? 因为p1.py中顶格写的两行print是顶层代码/全局代码,import的时候会解析执行。

argparse解析命令行参数的过程

我们在代码中会定义一些变量,以便在需要的时候更改变量的值,这是一种方式。还有一种更灵活的方式,不用在每次执行时更改变量值(更改代码),而是通过命令行输入参数/变量及其对应的值,此时需要命令行参数解析工具。
python中通过命令行(即输入指令)输入的参数或者值,会存在sys.argv中。测试代码如下:

import sys
for i in sys.argv:
     print(i)

在终端中输入—python p1.py arg1 arg2 arg3 arg4,输出为—p1.py arg1 arg2 arg3 arg4,即第一个是文件本身,之后就对应命令行输入的参数。

python内置的argparse模块,可以定义/添加需要的命令行参数,然后从 sys.argv 解析出这些参数,使用过程分成三步:

  • ①创建一个解析器——argparse.ArgumentParser(description=‘……’)
import argparse
# 创建一个解析实例
parser = argparse.ArgumentParser(description='Declare some parameters')
  • ②添加参数——parser.add_argument()
parser.add_argument('--gpu-index', default = 4, type= int, help='The index of gpu') 
parser.add_argument('--model', default = 'resnet18', type= str, help='The type of model') 

这里添加了两个参数,参数名称分别是gpu-indexmodel,其前缀--指明这是一个可选参数。add_argument()可以添加两类参数:位置参数【参数名称前不需要添加-或者–,如’para1’】,命令行输入时不需要输入参数名称,直接输入需要传入的值即可,argparse从命令行解析这类参数时,是顺序解析的,即先添加的未知参数先解析赋值;可选参数【参数名称前有--或者-,只有一个短横线的是缩写/简写】,argparse解析命令行参数时根据参数名称解析,命令行中参数的顺序与参数添加的顺序无关。

import argparse
parse = argparse.ArgumentParser()
# 添加三个参数,par1和par2是位置参数,命令行不需要输入参数名称
# --name是可选参数,命令行必须输入名称
parse.add_argument('par1',type= int)
parse.add_argument('--name',type= str)
parse.add_argument('par2',type= int)
# 参数解析
args = parse.parse_args()
# 输出各个参数名称及值
for arg in vars(args):  
    print(f"{arg}: {getattr(args, arg)}")  

python p1.py 1 --name 'test' 2和用python p1.py 3 4 --name 'tests'运行的结果分别如下:
【python】argparse解析参数的过程_第3张图片 ___________________ 【python】argparse解析参数的过程_第4张图片
可见对于位置参数是按顺序解析的,即先输入的值对应先添加的参数,但是可选参数的值是根据参数名称解析的。

  • ③解析参数—parse_args()
args = parse.parse_args()

ArgumentParser 通过 parse_args() 方法解析参数。它将检查命令行,把每个参数转换为适当的类型然后调用相应的操作。在大多数情况下,这意味着一个简单的 Namespace 对象将从命令行解析出的属性构建

argparse使用add_argument()函数添加参数时,除参数名称name or flags外还有很多可选的参数(参考add_argumenr()):
【python】argparse解析参数的过程_第5张图片

Debug—案例分析

事情是这样的,我有一个main_train.py,大致内容如下:

import torch
import torch.nn as nn
import torch.utils.data as Data
from torchvision import datasets, transforms
import numpy as np
# 添加参数
import argparse
parser = argparse.ArgumentParser()  
parser.add_argument('--gpu-index', default = 4, type= int, help='The index of gpu') 
parser.add_argument('--model', default = 'resnet18', type= str, help='The type of model') 
args = parser.parse_args()
# 输出参数及值
for arg in vars(args):  
    print(f"{arg}: {getattr(args, arg)}")  
# 准备GPU
gpu_idx = args.gpu_index
if torch.cuda.is_available():
    device = torch.device(f"cuda:{gpu_idx}")
else:
    device = torch.device('cpu')

def load_cifar10():   
   	pass

def correctness(model, dataset, device):
	pass

def load_model(model, device):
	pass
# 其他内容略

还有在同一目录下的main_forget.py,大致内容如下,主要就是从main_train.py中import了里面的三个函数:【注意main_train.py中只添加了2个参数,main_forget.py中添加了7个参数】

import copy
import torch
import torch.nn as nn
import torch.utils.data as Data
from torchvision import datasets, transforms
# 添加参数
import argparse
parser = argparse.ArgumentParser() 
parser.add_argument('--gpu-index', default = 0, type= int, help='The index of gpu') 
parser.add_argument('--model', default = 'resnet18', type= str, help='The type of model') 
parser.add_argument('--batch-size', default = 256, type= int, help='The batchsize of retain and test dataloader') 
parser.add_argument('--seed', default = 200, type= int, help='The seed to set random function') 
parser.add_argument('--rate', default = 0.1, type= float, help='The proportion of forgotten data') 
parser.add_argument('--unlearn', default = 'wfisher', type= str, help='the specific methods of data unlearning',
                    choices=['wfisher','fisher_new','GA','FT','retrain']) 
parser.add_argument("--alpha", default=0.2, type=float, help="unlearn noise")
# 解析参数
args = parser.parse_args()
# 输出参数
for arg in vars(args):  
    print(f"{arg}: {getattr(args, arg)}")  
# !!!引入main_train.py中的三个函数
from main_train import load_cifar10, load_model, correctness

#…………省略

现在我们运行python main_forget.py --model 'resnet34' --gpu-index 3是ok的,输出内容如下:
【python】argparse解析参数的过程_第6张图片
分析输出内容:第一个框对应main_forget.py文件输出的argparse添加的参数,并且model和gpu-index的值为命令行中输入的;但是后面的输出是什么???——后面框对应的是main_train.py中的顶层代码!并且main_train.py中的两个参数值也更改为了命令行输入的参数值。

但是当我们输入python main_forget.py --unlearn 'FT' --seed 100时,会发生什么呢?
【python】argparse解析参数的过程_第7张图片
第一个框依旧对应main_forget.py中的7个变量,此时unlearn和seed更改为命令行输入的值;但是后面却提示error: unrecognized arguments,这是因为从main_train.py引入三个函数的同时,还会额外解析执行其顶层代码,main_train.py中argparse相关部分的代码是顶层代码,因此会再一次创建一个argparse对象,在解析到main_train.py中的args = parser.parse_args()时又会去解析匹配命令行的参数,但是main_train.py的argparse解析器只有两个参数——model和gpu-index,命令行输入的却是——unlearn和seed,自然是无法匹配的,因此就会出现解析错误。

上述例子告诉我们,在写一个项目的时候,一些需要多次使用的基础功能性函数单独写在一个文件中,比如utils.py;顶层创建了argparse解析器的文件不要随便引用,或者单独写一个argparse解析器添加参数的代码文件。总之是要注意代码规范……

你可能感兴趣的:(Pytorch编程学习,python,开发语言,pytorch,argparse,import)