argparse es la biblioteca integrada de Python para analizar los parámetros de la línea de comandos. Puede ayudar a los desarrolladores a crear interfaces de línea de comandos fáciles de usar, para que los usuarios puedan pasar parámetros a los programas a través de la línea de comandos. A través de argparse, puede definir el tipo, el número y el texto de ayuda de los parámetros de la línea de comandos que el programa puede aceptar.
Este artículo incluye principalmente los siguientes contenidos:
Primero, el uso básico de argparse:
#导入argparse模块：
import argparse
#创建ArgumentParser对象：
parser = argparse.ArgumentParser(description='Description of your program')
#添加命令行参数：
parser.add_argument('arg_name', type=str, help='Help text for this argument')
#解析命令行参数：
args = parser.parse_args()
#使用解析得到的参数：
print(args.arg_name)
arg_name : el nombre del parámetro, puede acceder al valor del parámetro a través de args.arg_name.
type : El tipo del parámetro, que puede ser int, float, str, etc.
ayuda : el texto de ayuda para el parámetro, que se mostrará cuando el usuario solicite ayuda.
parser.add_argument es un método de la clase argparse.ArgumentParser que se utiliza para agregar opciones de argumento de línea de comandos al analizador.
parser.add_argument(name or flags, action, nargs, const, default, type, choices, required, help, metavar)
name or flags : El nombre o las opciones del parámetro. Puede ser el nombre de un argumento posicional (sin prefijo) o un nombre de opción con el prefijo - o - -. Por ejemplo, "nombre de archivo" es el nombre de un parámetro posicional y "- -salida" es el nombre de una opción.
action : La acción del parámetro. Especifica qué acción se debe tomar cuando el parámetro aparece en la línea de comando. Las acciones comúnmente utilizadas son "store" (guardar valor, predeterminado), "store_const" (guardar valor constante), "store_true" (guardar True), "store_false" (guardar False), "append" (agregar valor a la lista), "append_const" (agregar una constante a una lista), etc.
nargs : el número de argumentos. Especifica el número de valores aceptados por este parámetro. Los valores comúnmente utilizados son Ninguno (predeterminado, aceptar un valor), '?' (aceptar cero o un valor), '*' (aceptar cero o más valores), '+' (aceptar al menos un valor), etc.
const : Un valor constante. Cuando el parámetro usa la acción store_const, el parámetro especifica el valor constante almacenado.
predeterminado : El valor predeterminado. El valor predeterminado utilizado cuando este parámetro no se proporciona en la línea de comandos.
type : El tipo del valor. Especifica el tipo de datos en el que se debe analizar el valor del parámetro.
elecciones : Límites en los valores. Especifica los valores de parámetros permitidos, solo se aceptarán los valores proporcionados.
requerido : Si es requerido. Si se establece en True, este parámetro es obligatorio y se informará de un error si no se proporciona.
ayuda : texto de ayuda. Se utiliza para mostrar la información de ayuda para este parámetro, normalmente una breve descripción del parámetro.
metavar : se utiliza para mostrar el nombre del parámetro en el mensaje de ayuda.
Entre los parámetros anteriores, el nombre o las banderas, el tipo y la ayuda son los parámetros más utilizados, y se utilizan otros parámetros según sea necesario. En el uso real, puede elegir de manera flexible la configuración de parámetros adecuada de acuerdo con los requisitos de parámetros de la línea de comandos.
A continuación, ilustraremos el uso de argparse a través de un ejemplo simple. Supongamos que queremos escribir un programa de calculadora simple que pueda sumar, restar, multiplicar y dividir dos números.
Cree un nuevo archivo python llamado calculadora e ingrese el siguiente código:
import argparse
def add(x, y):
return x + y
def subtract(x, y):
return x - y
def multiply(x, y):
return x * y
def divide(x, y):
return x / y
parser = argparse.ArgumentParser(description='Simple calculator')
parser.add_argument('operation', type=str, help='Operation to perform: add, subtract, multiply, divide')
parser.add_argument('num1', type=float, help='First number')
parser.add_argument('num2', type=float, help='Second number')
args = parser.parse_args()
if args.operation == 'add':
result = add(args.num1, args.num2)
elif args.operation == 'subtract':
result = subtract(args.num1, args.num2)
elif args.operation == 'multiply':
result = multiply(args.num1, args.num2)
elif args.operation == 'divide':
result = divide(args.num1, args.num2)
else:
print('Invalid operation')
exit(1)
print('Result:', result)
Al ejecutar el programa y pasar parámetros, puede realizar diferentes operaciones. Por ejemplo, ejecute el siguiente comando en la terminal:
python calculator.py add 10 5
Resultado de salida:
Result: 15.0
o:
python calculator.py divide 10 5
Resultado de salida:
Result: 2.0
Use python calculadora.py -h para ver la documentación de ayuda
python calculator.py -h
espectáculo:
usage: calculator.py [-h] operation num1 num2
Simple calculator
positional arguments:
operation Operation to perform: add, subtract, multiply, divide
num1 First number
num2 Second number
optional arguments:
-h, --help show this help message and exit
De esta forma, los usuarios pueden pasar parámetros a través de la línea de comandos y realizar diferentes operaciones de cálculo.
Dos, función parser.add_argument()
A veces nos encontramos con el código parser.add_argument() con nombres largos y cortos, como se muestra a continuación:
# 添加一个可选参数"-s"或"--steps"，用于指定MCTS步数，默认值为1000，同时提供帮助信息
parser.add_argument("-s", "--steps", type=int, default=1000, help="Number of MCTS steps"
parser.add_argument() : Este es un método en el módulo argparse para agregar un argumento de línea de comando. Al llamar a este método, definimos las reglas y propiedades de los argumentos de la línea de comando que queremos que acepte el programa.
" -s " y " --steps ": estos dos parámetros son los nombres de los parámetros de la línea de comandos. "-s" es un indicador corto y "--steps" es un indicador largo. El valor del parámetro puede ser especificado por estas dos banderas.
type=int : Esta es la especificación de tipo del parámetro. Aquí, los valores de los parámetros se interpretarán como tipos enteros.
default=1000 : Este es el valor predeterminado para el parámetro. Si no se proporcionan argumentos -s o --steps en la línea de comando, el programa usa un valor predeterminado de 1000.
help="Número de pasos MCTS ": Esta es una breve descripción del parámetro que se mostrará cuando el usuario use el indicador --help para ver la ayuda. Aquí, el parámetro se utiliza para especificar el número de pasos MCTS (búsqueda de árbol de Monte Carlo).
Para resumir, este código le dice a nuestro programa que el parámetro -s o --steps se puede usar de las siguientes maneras:
-s 2000 o --steps 2000: especifique los nombres y valores de los parámetros en la línea de comando.
Si este parámetro no se especifica en la línea de comandos, se utiliza 1000 como valor de parámetro predeterminado.
Cuando el usuario necesite ver la ayuda, se mostrará la descripción del parámetro: "Número de pasos MCTS".
En el módulo argparse, tanto un indicador corto (generalmente un solo carácter, como "-s") como un indicador largo (generalmente una palabra, como "--steps") se pueden definir para un argumento de línea de comandos. Este enfoque es para facilitar que los usuarios especifiquen el mismo parámetro de diferentes maneras en la línea de comando, haciendo que la línea de comando sea más flexible y fácil de usar.
#使用"-s"标志的示例：
python my_script.py -s 2000
#使用"--steps"标志的示例：
python my_script.py --steps 2000
Ambas formas establecerán el parámetro en 2000. Las banderas cortas generalmente se usan para entradas convenientes en la línea de comandos, mientras que las banderas largas generalmente se usan para nombres de opciones más específicos y legibles.
No existe una diferencia esencial entre definir dos banderas al mismo tiempo, son solo manifestaciones diferentes en la denominación y el uso. El programa reconoce el parámetro en función de los indicadores proporcionados por el usuario y establece su valor en el valor predeterminado o especificado por el usuario.
3. Acerca de - y - -
Cuando se usa argparse para analizar argumentos de la línea de comandos, los nombres de los argumentos generalmente comienzan con "- -". El propósito de esto es distinguir entre argumentos de línea de comando y argumentos posicionales.
En el código original, "- -" no se agrega antes del nombre del parámetro porque este código usa argumentos posicionales (argumentos posicionales). Los parámetros posicionales no necesitan el prefijo "- -", se analizan según la posición en la que aparece el parámetro en la línea de comando. Cree un nuevo archivo de Python llamado script.py .
#script.py
def parse_args():
parser = argparse.ArgumentParser("TreEnhance Hyperparams")
a = parser.add_argument
a("base_dir", help="BASE DIRECTORY")
a("expname",help="Name of the run")
a("dropout", type=float, default=0.6, help="Dropout")
a("num_images", type=int, default=100, help="number of Images")
a("num_steps", type=int, default=10, help="number of steps")
a("val_images", type=int, default=100, help="number of val images")
a("lr", type=float, default=0.001, help="learning rate")
a("size", type=int, default=256, help="image size")
a("num_gen", type=float, default=256, help="number of generation")
a("bs", type=int, default=16, help="batch size")
a("lambd", type=int, default=20, help="lambda in the loss function")
a("loops", type=int, default=5, help="number of optimization loops")
return parser.parse_args()
Por ejemplo, cuando ejecuta este script, debe proporcionar los valores correspondientes en el orden de los parámetros de la función, puede ejecutarlo así:
python my_script.py ./path/to/base_dir my_expname 0.6 100 10 100 0.001 256 256 16 20 5
En la línea de comando anterior, los valores correspondientes se proporcionan en el orden de los argumentos de la función parse_args(). Estos valores se asignarán a los parámetros correspondientes según el orden de los parámetros. Los resultados de la asignación son los siguientes:
base_dir: ./path/to/base_dir
expname: my_expname
dropout: 0.6
num_images: 100 y
así sucesivamente
Sin embargo, en para mejorar la legibilidad y ser más flexible Para especificar parámetros, generalmente se recomienda usar parámetros de línea de comando de formato largo, es decir, agregar "-" antes del nombre del parámetro, como se muestra en el siguiente código:
#script.py
def parse_args():
parser = argparse.ArgumentParser("TreEnhance Hyperparams")
a = parser.add_argument
a("--basedir", nargs='?', default='./', help="BASE DIRECTORY")
a("--expname", default="default_exp", help="Name of the run")
a("--dropout", type=float, default=0.6, help="Dropout")
a("--num_images", type=int, default=100, help="number of Images")
a("--num_steps", type=int, default=100, help="number of steps") # 每个epoch训练的迭代步数
a("--val_images", type=int, default=100, help="number of val images")
a("--lr", type=float, default=0.001, help="learning rate")
a("--size", type=int, default=256, help="image size")
a("--num_gen", type=float, default=50, help="number of generation") # 相当于训练的epoch数，256
a("--bs", type=int, default=8, help="batch size")
a("--lambd", type=int, default=20, help="lambda in the loss function")
a("--loops", type=int, default=5, help="number of optimization loops")
return parser.parse_args()
Use la forma larga de los parámetros de la línea de comandos para especificar los valores de los parámetros en la línea de comandos sin estar en un orden particular. Esto es más legible y permite argumentos opcionales en la línea de comando, puede ejecutar:
python my_script.py --basedir /path/to/base_dir --expname my_expname --dropout 0.6 --num_images 100 --num_steps 10 --val_images 100 --lr 0.001 --size 256 --num_gen 256 --bs 16 --lambd 20 --loops 5
En resumen, el propósito de proporcionar banderas cortas y banderas largas para los parámetros de la línea de comandos es aumentar la flexibilidad y la legibilidad de la línea de comandos, de modo que los usuarios puedan elegir una forma adecuada de especificar los valores de los parámetros de acuerdo con sus preferencias y necesidades. .
4. La diferencia entre args = parser.parse_args() y return parser.parse_args()
args = parser.parse_args() y return parser.parse_args() difieren en sus valores de retorno y propósitos.
args = parser.parse_args(): esta línea de código llamará al método parser.parse_args() para analizar los argumentos de la línea de comando y almacenar el resultado analizado en la variable args. args es un objeto de espacio de nombres que contiene los argumentos de la línea de comandos analizados. Puede acceder a los valores de estos parámetros a través de atributos, como args.expname, args.num_images, etc.
# 示例
args = parser.parse_args()
print(args.expname) # 输出：命令行参数中的 expname 参数值
print(args.num_images) # 输出：命令行参数中的 num_images 参数值
return parser.parse_args(): esta línea de código devolverá el resultado del método parser.parse_args() en la función. Es decir, cuando llame a esta función, analizará los argumentos de la línea de comandos y utilizará el resultado analizado como valor de retorno de la función. De esta forma, puede obtener directamente el valor del parámetro analizado al llamar a la función sin asignarlo a una variable por separado.
# 示例
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--expname", help="Name of the run")
parser.add_argument("--num_images", type=int, default=100, help="number of Images")
# 添加其他命令行参数...
return parser.parse_args()
# 在其他地方调用函数
args = parse_args()
print(args.expname) # 输出：命令行参数中的 expname 参数值
print(args.num_images) # 输出：命令行参数中的 num_images 参数值
Resumen: el método parser.parse_args() se usa para analizar argumentos de línea de comando y almacenar los resultados analizados en un objeto de espacio de nombres. args = parser.parse_args() Asigne este objeto de espacio de nombres a la variable args, para que pueda acceder al valor de los parámetros de la línea de comando a través de los atributos. return parser.parse_args() toma el resultado analizado como el valor de retorno de la función, de modo que puede obtener directamente el valor del parámetro analizado al llamar a la función sin asignación adicional.