Quels sont les paramètres de la ligne de commande Python ?

Quels sont les paramètres de ligne de commande Python ? Permettez-moi de vous donner une introduction détaillée à ce que sont les paramètres de ligne de commande :

sys.argv

Vous pouvez également utiliser le sys.argv de sys dans Python. Obtenez les paramètres de ligne de commande :

sys.argv est la liste des paramètres de ligne de commande.

len(sys.argv) est le nombre de paramètres de ligne de commande.

sys.argv[0] est le nom du fichier de script, tel que : test.py

sys.argv[1:] est une liste de paramètres séparés par des espaces

getopt

Prototype de fonction :

getopt(args, shortopts, longopts = [])

Paramètres :
args : paramètres qui doivent être analysés, généralement sys.argv[1:]
shortopts : format court (-), avec deux points : indique que la valeur du paramètre est obligatoire après le paramètre, sans deux points, indiquant qu'aucune valeur de paramètre n'est requise après le paramètre
longopts : format long (--), avec un signe égal, indiquant qu'une valeur de paramètre est requise après le paramètre, sans signe égal, indiquant qu'aucun paramètre n'est requis après le paramètre Valeur
Valeur de retour :
options est une liste contenant les ancêtres Chaque ancêtre est le. formater les informations analysées, telles que [('-i','127.0.0.1'),('-p','80 ')] ;
args est une liste, incluant les paramètres sans '-' ou '- -', tel que : ['55','66']

Recommandations associées : "Tutoriel vidéo Python 》

Exemple :

import sys
import getopt
try:    
    options,args = getopt.getopt(sys.argv[1:],"hp:i:", ["help","ip=","port="])
except getopt.GetoptError:    
    sys.exit()
for name,value in options:   
    if name in ("-h","--help"):        
        usage()    
    if name in ("-i","--ip"):        
        print 'ip is----',value    
    if name in ("-p","--port"):        
    print 'port is----',value
python test.py -i 127.0.0.1 -p 80 55 66
python test.py --ip=127.0.0.1 --port=80 55 66

"hp:i:"
Format court --- Pas de deux-points après h : signifie aucun paramètre, p: et i : Il y a deux points après, indiquant que les paramètres seront nécessaires plus tard
["help"," ip=","port="]
Format long --- Il n'y a pas de signe égal = après l'aide, ce qui signifie qu'il n'y a aucun paramètre derrière, et les trois autres Il y a =, indiquant que les paramètres sont requis plus tard
Remarque : lors de la définition des paramètres de ligne de commande, vous devez d'abord définir les paramètres avec l'option '-', puis définir les paramètres sans '-'

optparse

Class OptionParser

class optparse.OptionParser(usage=None, 
                 option_list=None,
                 option_class=Option,
                 version=None,
                 conflict_handler="error",
                 description=None,
                 formatter=None,
                 add_help_option=True,
                 prog=None,
                 epilog=None)

Paramètres :

usage : instructions d'utilisation du programme, où "%prog" sera remplacé par le nom du fichier (ou l'attribut prog, si l'attribut prog est une valeur spécifiée), "[options]" sera remplacé par les instructions pour chaque paramètre
version : numéro de version

fonction add_option()

add_option(short, long, action, type, dest, default, help)

paramètres :
Court chaîne d'option : est le premier paramètre, indiquant l'abréviation de l'option, telle que -f;
chaîne d'option longue : est le deuxième paramètre, indiquant l'orthographe complète de l'option, telle que --file;
action= : Indique la méthode de traitement de cette option. La valeur par défaut est store, ce qui signifie stocker la valeur de l'option dans les membres de l'objet d'options analysé.

Action peut également avoir d'autres valeurs : pour les valeurs booléennes, utilisez store_true pour stocker true par défaut, utilisez store_false pour stocker false par défaut, store_const est utilisé pour stocker la valeur définie par const dans cette option, et ajoutez des moyens ajouter des paramètres à l'option dans la liste. À l'heure actuelle, cette option est une liste, qui peut contenir plusieurs valeurs, signifie augmenter le compteur de un, et le rappel signifie appeler la fonction spécifiée. Toutes les valeurs d'action sont les suivantes :
store + store_true + store_false + store_const + append + count + callback

type= : indique le type de valeur de cette option, la valeur par défaut est string, et peut être spécifié comme string, int, Choice, float et complex ;
dest= : indique le nom du membre de cette option dans l'objet d'options analysé par optionparser.
help= : Indique les instructions d'utilisation de ce paramètre ;
default= : indique la valeur par défaut de l'option ;
metavar= : indique la valeur par défaut de l'option affichée dans l'aide
const= : lorsque l'action est store_const, ceci la valeur doit être définie ;
choices= : lors de la définition du type sur les choix, vous devez définir cette valeur

function parse_args

(options, args) = parser.parse_args()

Valeur de retour :
options est un répertoire, son contenu est constitué de paires clé-valeur "Paramètre/valeur".
args est une liste, son contenu est le contenu d'entrée restant après avoir exclu les options de tous les paramètres.

Utilisation simple :

from optparse import OptionParser  
  
parser = OptionParser(usage="usage:%prog [options] arg1 arg2")  
parser.add_option("-t", "--timeout",  
                action = "store",  
                type = 'int',  
                dest = "timeout",  
                default = None,  
                help="Specify annalysis execution time limit"  
                )  
parser.add_option("-u", "--url",  
                action = "store_true",  
                dest = "url",  
                default = False,  
                help = "Specify if the target is an URL"  
                )
(options, args) = parser.parse_args() 
if options.url:  
    print(args[0])

Utilisation complexe : regroupement de paramètres

parser = optparse.OptionParser(version="%prog " + config.version)# common_groupcommon_group = optparse.OptionGroup(
    parser, "Common Options",    "Common options for code-coverage.")
parser.add_option_group(common_group)
common_group.add_option(    "-l", "--lang", dest="lang", type="string", default="cpp",    help="module language.", metavar="STRING")
common_group.add_option(    "--module_id", dest="module_id", type="int", default=None,    help="module id.", metavar="INT")
cpp_group = optparse.OptionGroup(
    parser, "C/C++ Options",    "Special options for C/C++.")# cpp_groupparser.add_option_group(cpp_group)
cpp_group.add_option(    "--local-compile", action="store_true", dest="local_compile",    help="compile locally, do not use compile cluster.")
cpp_group.add_option(    "--module_path", dest="module_path", type="string", default=None,    help="module path, like app/ecom/nova/se/se-as.", metavar="STRING")
    
options, arguments = parser.parse_args()
lang = options.lang
module_id = options.module_id
local_compile = options.local_compile
module_path = options.local_compile

argparse

Class ArgumentParser

class argparse.ArgumentParser(prog=None, 
                usage=None, 
                description=None, 
                epilog=None, 
                parents=[], 
                formatter_class=argparse.HelpFormatter,
                prefix_chars='-', 
                fromfile_prefix_chars=None, 
                argument_default=None, 
                conflict_handler='error', 
                add_help=True)

Paramètres :
prog : le nom du programme (par défaut : sys.argv[0])
usage : une chaîne décrivant l'utilisation du programme (par défaut : générée à partir des paramètres du parser)
description : le texte avant les informations d'aide sur le paramètre (par défaut : vide)
epilog : le texte après les informations d'aide sur le paramètre (par défaut : vide)
parents : une liste d'objets ArgumentParser, les paramètres de ces objets doivent être inclus
formatter_class : classe pour les informations d'aide personnalisées
prefix_chars : jeu de caractères de préfixe des paramètres facultatifs (par défaut : '-')
fromfile_prefix_chars : jeu de caractères de préfixe du fichier dans lequel les paramètres supplémentaires doivent être lus (par défaut : Aucun)
argument_default : valeur globale par défaut pour les arguments (par défaut : Aucun)
conflict_handler : stratégie pour résoudre les arguments facultatifs conflictuels (généralement pas nécessaire)
add_help : ajoutez l'option -h/–help au analyseur (par défaut : True)

Fonction add_argument()

add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help]
[, metavar][, dest])

参数：
name or flags：选项字符串的名字或者列表，例如foo 或者-f, --foo。
action：在命令行遇到该参数时采取的基本动作类型。
nargs：应该读取的命令行参数数目。
const：某些action和nargs选项要求的常数值。
default：如果命令行中没有出现该参数时的默认值。
type：命令行参数应该被转换成的类型。
choices：参数可允许的值的一个容器。
required：该命令行选项是否可以省略（只针对可选参数）。
help:参数的简短描述。
metavar：参数在帮助信息中的名字。
dest：给parse_args()返回的对象要添加的属性名称。

简单用法：

import argparse
parser = argparse.ArgumentParser(description="progrom description")
parser.add_argument('key', help="Redis key where items are stored")
parser.add_argument('--host')
arser.add_argument('--port')
parser.add_argument('--timeout', type=int, default=5)
parser.add_argument('--limit', type=int, default=0)
parser.add_argument('--progress_every', type=int, default=100)
parser.add_argument('-v', '--verbose', action='store_true')
args = parser.parse_args()
key = args.key
host = args.host
port = args.port
timeout = args.timeout
limit = args.limit
progress-every = args.progress_every
verbose = args.verbose

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!