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文件（比如p2.py)中通过import机制引用另一个文件（比如p1.py)的部分代码，比如定义的一个class、function等等，就能在p2.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，输入如下：

假设p2.py内容如下，import了p1.py的内容：

from p1 import mainprint("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的输入如下：

分析可知p1.py中的if __name__ == '__main__':的内容没有执行——即p1.py中的main()函数没有执行，没有输出那一行，因此p2.py中importp1.py，p1.py中的\_\_name\_\_ ≠ '\_\_main\_\_'而是\_\_name\_\_ ≠ 'p1'。

import到底导入了什么？

一个python文件中定义的class、function可以在其他python文件中通过import引入并使用，关于import的具体用法（即在一个项目中很多文件夹，同级、不同级文件间的引用，以及绝对路劲的引用和相对路径的引用）可以参考这个博客👉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()，但是输出中第一/第二行还是会有p1中的内容？ 因为p1.py中顶格写的两行print是顶层代码/全局代码，import的时候会解析执行。

argparse解析命令行参数的过程

我们在代码中会定义一些变量，以便在需要的时候更改变量的值，这是一种方式。还有一种更灵活的方式，不用在每次执行时更改变量值（更改代码），而是通过命令行输入参数/变量及其对应的值，此时需要命令行参数解析工具。
python中通过命令行（即输入指令）输入的参数或者值，会存在sys.argv中，比如python p1.py arg1 arg2 arg3 arg4，然后代码是这样的👇：

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

那么输出就是：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-index和model，至于前面的--是指明这是一个可选参数。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'运行的结果分别如下：

可见对于未知参数是按顺序解析的，即先输入的值对应先添加的参数，但是可选参数的值是根据参数名称解析的。

• 解析参数—parse_args()

args = parse.parse_args()

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

argparse使用add_argument()函数添加参数时，除参数名称name or flags外还有很多可选的参数（参考👉add_argumenr()）：
# 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():   passdef correctness(model, dataset, device):passdef load_model(model, device):pass
# 其他内容略

还有在同一目录下的main_forget.py，大致内容如下👇，主要就是从main_train.py中国import了里面的三个函数：

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#…………省略

可以看到，main_train.py中只添加了2个参数，main_forget.py中添加了7个参数。现在我们运行python main_forget.py --model 'resnet34' --gpu-index 3是ok的，输出内容如下：

分析输出内容：上面是main_forget.py文件输出的argparse添加的参数，并且model和gpu-index的值为命令行中输入的；但是后面的输出是什么？？？——后面的输出是main_train.py中的顶层代码！并且main_train.py中的两个参数值也更改为了命令行输入的参数值。
但是当我们输入python main_forget.py --unlearn 'FT' --seed 100时，会发生什么呢？👇

前面依旧对应main_forget.py中的7个变量，此时unlearn和seed更改为命令行输入的值；但是后面却提示error: unrecognized arguments，这是因为从main_train.py引入三个函数的同时，还会额外解析执行其顶层代码，即会再一次创建一个argparse对象，在解析到args = parser.parse_args()时又会去解析匹配命令行的参数，但是main_train.py的argparse解析器只有两个参数——model和gpu-index，命令行输入的却是——unlearn和seed，自然时无法匹配的，因此就会出现解析错误。

上述例子告诉我们，在写一个项目的时候，一些需要多次使用的基础功能性函数单独写咋一个文件中；有argparse的文件不要随便引用，或者单独写一个argparse解析器添加一堆参数的代码文件。总之是要注意代码规范……