1. parámetros de la línea de comando argparse

1. Descripción del parámetro:

nombre o banderas: un nombre o una lista de cadenas de opciones, como foo o -f, --foo.

acción: el tipo básico de acción que se utiliza cuando el parámetro aparece en la línea de comando, acción: la acción cuando la línea de comando encuentra el parámetro, el valor predeterminado es almacenar.
– store_const, significa que la asignación es constante;
– append, almacena los valores encontrados en una lista, es decir, si los parámetros se repiten, se guardarán múltiples valores;
– append_const, guarda un valor definido en la especificación del parámetro en una lista;
– count, almacena el número de encuentros; además, también puede heredar argparse.Action para personalizar el análisis de parámetros;

nargs se usa para describir la cantidad de parámetros pasados, '+' significa pasar al menos un parámetro
nargs: la cantidad de parámetros de la línea de comando que se deben leer, puede ser
un número específico o un signo?, cuando no hay ningún valor especificado, para Usar valor predeterminado para el argumento posicional y usar
el signo constante o * para el argumento opcional, que significa 0 o más parámetros;
o el signo +, que significa 1 o más parámetros.

const: una constante requerida por algunas acciones y selecciones de nargs.

predeterminado: el valor utilizado cuando el parámetro no aparece en la línea de comando.

tipo: el tipo al que se debe convertir el argumento de la línea de comando. (int, lista, cadena, tupla, conjunto, dict)

opciones: un contenedor de parámetros disponibles.

obligatorio: si esta opción de línea de comando se puede omitir, el valor predeterminado es falso.

ayuda: una breve descripción de lo que hace esta opción.

metavar: ejemplo de valores de parámetros utilizados en mensajes de uso.

dest: el nombre del atributo que se agregará al objeto devuelto por parse_args().

2. Uso de parámetros

1. El nombre
del parámetro nombre se utiliza para llamar directamente a args.name.
Hay dos formas de establecer el nombre del parámetro. La diferencia se refleja en si hay - o - antes del nombre (cuando el nombre está abreviado).
El parámetro requerido (sin -) es el siguiente: El orden de las configuraciones corresponde a la lectura y no necesita escribir un nombre cuando llama.
Parámetros opcionales (con -): puede leer fuera de orden y necesita escribir un nombre cuando vocación.

2. Parámetros posicionales
Al pasar parámetros en la línea de comando, el orden de los parámetros pasados ​​es diferente y los resultados de la ejecución a menudo son diferentes, esto se debe a que se utilizan parámetros posicionales, como import argparse parser
=
argparse.ArgumentParser (descripción = 'nombre' )
parser.add_argument('param1', tipo=cadena,ayuda='apellido')
parser.add_argument('param2', tipo=cadena,ayuda='nombre')
args = parser.parse_args()
# Imprimir nombre
print(args .param1+args.param2)

#Definir parámetros posicionales:
parser.add_argument('outfile')

3. Parámetros opcionales
Para evitar el error de los parámetros posicionales anteriores en la línea de comando (es fácil olvidar el orden), puedes usar parámetros opcionales. Esto es un poco como los parámetros de paso de palabras clave, pero necesitas agregar: delante de las palabras clave, aunque parámetros opcionales El método de escritura es relativamente engorroso, pero aumenta la legibilidad de la línea de comando y hace que sea menos probable que cause confusión en los datos debido al orden en que se pasan los parámetros. Por ejemplo:
la entrada anterior debe tener un radio de 1 en el frente y una altura de 3 en la parte posterior. Si desea cambiar el orden de la entrada o llevar el nombre del parámetro al mismo tiempo que el parámetro de entrada, puede use el parámetro de selección y agregue dos analizadores "-" antes del nombre del parámetro al agregar el parámetro
.
Hay otra forma de agregar parámetro alias hasta "-". Tenga en cuenta que el nombre del parámetro modificado por "-" debe existir:
parser.add_argument ('-r', '–radius', type=int, help='Radio del cilindro')
parser.add_argument(' -H', '–altura', tipo=int, ayuda='Altura del cilindro')

4. Nargs
se usa para describir la cantidad de parámetros pasados, que puede ser
un número específico: cuántos '*' se deben pasar
: cualquiera
'?': uno o ninguno 1/0
'+': al menos uno ≥ 1
período posterior Cuando llamas a este parámetro, almacena lo que pasas en forma de lista.
Entonces mejoremos el programa anterior para encontrar la suma de dos números enteros.
import argparse
parser = argparse.ArgumentParser(description='This El código se utiliza para encontrar la suma de dos números enteros. Suma de números enteros')
#Este objeto de análisis es equivalente a un contenedor total que almacena toda la información
parser.add_argument("enteros", type=int,nargs=2,help="first entero")

5. El
tipo de tipo se utiliza para determinar qué tipo de datos utilizar para leer los parámetros.
El valor predeterminado es una cadena, igual que la función de entrada.

6. Atributo requerido
Opcionalmente, puede agregar el atributo requerido en el paso de agregar parámetros. Durante el proceso de entrada de la línea de comando, si solo especifica ciertos parámetros y los valores de otros parámetros no se especifican, es posible que pueda ejecutar el programa, cuál no es Parámetros cuyos valores se especifican se le asignará el valor Ninguno. El atributo requerido requiere que se le asigne un valor al parámetro; de lo contrario, se informará un error
parser.add_argument('-r', '–radius', type=int, metavar='', require=True, help='Radius del cilindro') parser.add_argument
('-H', '–altura', tipo=int, metavar='', requerido=True, ayuda='Altura del cilindro')

7. atributo dest
Puede usar dest = xxx para establecer el nombre de la variable del parámetro en lugar de "-xxx", de manera similar, use args.xxx en el código para obtener el valor del parámetro.
parser.add_argument('-r', destino='radio', tipo=int, ayuda='Radio del cilindro')
parser.add_argument('-H', destino='altura', tipo=int, ayuda='Altura del cilindro')

8. La acción utiliza parámetros mutuamente excluyentes.

4. Conversión mutua entre argparse y dict

import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-f', '--face', help='use this face', dest='source_img')
    parser.add_argument('-t', '--target', help='replace this face', dest='target_path')
    parser.add_argument('-o', '--output', help='save output to this file', dest='output_file')
    parser.add_argument('--keep-fps', help='maintain original fps', dest='keep_fps', action='store_true', default=False)
    parser.add_argument('--keep-frames', help='keep frames directory', dest='keep_frames', action='store_true', default=False)
    parser.add_argument('--all-faces', help='swap all faces in frame', dest='all_faces', action='store_true', default=False)
    parser.add_argument('--max-memory', help='maximum amount of RAM in GB to be used', dest='max_memory', type=int)
    parser.add_argument('--cpu-cores', help='number of CPU cores to use', dest='cpu_cores', type=int, default=max(8 / 2, 1))
    parser.add_argument('--gpu-threads', help='number of threads to be use for the GPU', dest='gpu_threads', type=int, default=8)
    parser.add_argument('--gpu-vendor', help='choice your GPU vendor', dest='gpu_vendor', choices=['apple', 'amd', 'intel', 'nvidia'])

    args = parser.parse_known_args()[0]
    print('所有参数：',args)
    print('图片参数：',args.source_img)

    print('---------------------------------------')

    # 此时得到的configs为Namespace类型，它包含了__dict__属性，
    # 因此可以使用vars将configs转换为字典dic（只要变量包含了__dict__属性就可以使用vars转换为字典）
    print('类型argperser：',type(args))
    dic = vars(args)
    print('类型dict：', type(dic))

    print('---------------------------------------')

    # 1、argparser转字典
    args_dict = vars(args)
    # use the dict
    for k in args_dict.keys():
        print(k, args_dict[k], type(args_dict[k]))

    print('---------------------------------------')

    # 2、 dict 转ArgumentParser
    # create a dict object
    a_student = {
    
    'Name': 'JACK Williams',
                 'ID': 391568,
                 'At_School': True,
                 'Math_Score': 92.3}


    # transfer the dict object to an ArgumentParser object
    args = argparse.Namespace(**a_student)
    print('类型argparser：', type(args))
    # use the ArgumentParser object
    print(args.Name, type(args.Name))
    print(args.ID, type(args.ID))
    print(args.At_School, type(args.At_School))
    print(args.Math_Score, type(args.Math_Score))

if __name__ == '__main__':
    main()
    # 运行参考
    # python run.py --gpu-vendor nvidia --keep-fps --all-faces -f img/face/mimi.jpg -t img/video/nui.mp4 -o img/out/nui.mp4

5. Código de referencia

import math
import argparse
parser = argparse.ArgumentParser(description='Calculate volume of a cylinder')
parser.add_argument('-r', '--radius', type=int, metavar='', required=True, help='Radius of cylinder')
parser.add_argument('-H', '--height', type=int, metavar='', required=True, help='Height of cylinder')
# 添加互斥组
group = parser.add_mutually_exclusive_group()
# 给互斥组添加两个参数
# 给参数的action属性赋值store_true，程序默认为false,当你执行这个命令的时候，默认值被激活成True
group.add_argument('-q', '--quiet', action='store_true', help='Print quiet')
group.add_argument('-v', '--verbose', action='store_true', help='Print verbose')
args = parser.parse_args()
def cylinder_volume(radius, height):
    vol = (math.pi) * (radius**2) * (height)  # 体积公式
    return vol
if __name__ == '__main__':
    volume = cylinder_volume(args.radius, args.height)
    # 互斥参数
    if args.quiet:
        print(volume)
    elif args.verbose:
        print('Volume of a Cylinder with radius %s and height %s is %s' % (args.radius, args.height, volume))
    else:
        print('Volume of Cylinder = %s' % volume)
    # 这就是互斥参数如何工作的，你不能同时执行两个命令，你可以执行一个，所以和互斥组里的两个参数交互时，你只能
    # 执行quiet和verbose中的一个，或者是都不执行按照默认计划来
    # 使用： python test_argparse.py  -r 2 -H 4
    #       python test_argparse.py  -r 2 -H 4 -v
    #       python test_argparse.py  -r 2 -H 4 -q

9. metavar: ejemplos de valores de parámetros utilizados en mensajes de métodos de uso, que ayudan al parámetro -h a ver información de descripción.

3. Programa

# backup.py

import argparse

def main():
    # 定义一个ArgumentParser实例:
    parser = argparse.ArgumentParser(
        prog='backup', # 程序名
        description='Backup MySQL database.', # 描述
        epilog='Copyright(r), 2023' # 说明信息
    )
    # 定义位置参数:
    parser.add_argument('outfile')
    # 定义关键字参数:
    parser.add_argument('--host', default='localhost')
    # 此参数必须为int类型:
    parser.add_argument('--port', default='3306', type=int)
    # 允许用户输入简写的-u:
    parser.add_argument('-u', '--user', required=True)
    parser.add_argument('-p', '--password', required=True)
    parser.add_argument('--database', required=True)
    # gz参数不跟参数值，因此指定action='store_true'，意思是出现-gz表示True:
    parser.add_argument('-gz', '--gzcompress', action='store_true', required=False, help='Compress backup files by gz.')

   
    # 解析参数:
    args = parser.parse_args()

    print('解析完参数：',args)
    print('类型：',type(args))
    args.outfile='take a set'

    # 打印参数:
    print('parsed args:')
    print(f'outfile = {
      
      args.outfile}')
    print(f'host = {
      
      args.host}')
    print(f'port = {
      
      args.port}')
    print(f'user = {
      
      args.user}')
    print(f'password = {
      
      args.password}')
    print(f'database = {
      
      args.database}')
    print(f'gzcompress = {
      
      args.gzcompress}')

if __name__ == '__main__':
    main()
# $ ./backup.py -u root -p hello --database testdb backup.sql

参考: https: // blog.csdn.net / RudeTomatoes / artículo / detalles / 117003291
https: // zhuanlan.zhihu.com / p / 56922793