Ορίσματα γραμμής εντολών στην Python

Επισκόπηση

Με την Python να είναι μια πολύ δημοφιλής γλώσσα προγραμματισμού, καθώς και με υποστήριξη για τα περισσότερα λειτουργικά συστήματα και πολλές βιβλιοθήκες που κάνουν εύκολη την επεξεργασία επιχειρημάτων γραμμής εντολών – χρησιμοποιείται ευρέως για τη δημιουργία εργαλείων γραμμής εντολών για πολλούς σκοπούς. Αυτά τα εργαλεία μπορούν να κυμαίνονται από απλές εφαρμογές CLI έως αυτές που είναι πιο σύνθετες, όπως το AWS' awscli εργαλείο.

Πολύπλοκα εργαλεία όπως αυτό ελέγχονται συνήθως από τον χρήστη μέσω ορίσματα γραμμής εντολών, που επιτρέπει στο χρήστη να χρησιμοποιεί συγκεκριμένες εντολές, να ορίζει επιλογές και πολλά άλλα. Για παράδειγμα, αυτές οι επιλογές θα μπορούσαν να επιτρέψουν στο εργαλείο να εξάγει πρόσθετες πληροφορίες, να διαβάσει δεδομένα από μια καθορισμένη πηγή ή να στείλει έξοδο σε μια συγκεκριμένη τοποθεσία.

Γενικά, τα ορίσματα μεταβιβάζονται στα εργαλεία CLI διαφορετικά, ανάλογα με το λειτουργικό σας σύστημα:

• Unix-like: - ακολουθούμενο από ένα γράμμα, όπως -h, ή -- ακολουθούμενη από μια λέξη, όπως --help
• Windows: / ακολουθούμενο από ένα γράμμα ή λέξη, όπως /help

Αυτές οι διαφορετικές προσεγγίσεις υπάρχουν για ιστορικούς λόγους. Πολλά προγράμματα σε συστήματα που μοιάζουν με Unix υποστηρίζουν τόσο τη μονή όσο και τη διπλή παύλα. Ο συμβολισμός μονής παύλας χρησιμοποιείται κυρίως με επιλογές με ένα γράμμα, ενώ οι διπλές παύλες παρουσιάζουν μια πιο ευανάγνωστη λίστα επιλογών, η οποία είναι ιδιαίτερα χρήσιμη για σύνθετες επιλογές που πρέπει να είναι πιο σαφείς.

Λάβετε υπόψη ότι τόσο το όνομα όσο και η έννοια ενός επιχειρήματος είναι συγκεκριμένα για ένα πρόγραμμα – δεν υπάρχει γενικός ορισμός, εκτός από μερικές κοινές συμβάσεις όπως --help για περισσότερες πληροφορίες σχετικά με τη χρήση του εργαλείου. Ως προγραμματιστής ενός σεναρίου Python, θα αποφασίσετε ποια ορίσματα θα παρέχετε στον καλούντα και τι κάνει. Αυτό απαιτεί σωστή αξιολόγηση.

Καθώς η λίστα με τα διαθέσιμα ορίσματα μεγαλώνει, ο κώδικάς σας θα γίνεται πιο περίπλοκος στην προσπάθεια να τα αναλύσετε με ακρίβεια. Ευτυχώς, στην Python υπάρχει μια σειρά από βιβλιοθήκες διαθέσιμες για να σας βοηθήσουν με αυτό. Θα καλύψουμε μερικές από τις πιο κοινές λύσεις, οι οποίες κυμαίνονται από το "κάντο μόνος σου". sys.argv, στην προσέγγιση "έγινε για σένα" με argparse.

Χειρισμός επιχειρημάτων γραμμής εντολών με Python

Η Python 3+ και το οικοσύστημα τριγύρω υποστηρίζουν έναν αριθμό διαφορετικών τρόπων χειρισμού ορισμάτων γραμμής εντολών. Υπάρχουν πολοί βιβλιοθήκες που διευκολύνουν την ανάλυση ορισμών γραμμής εντολών.

Ο ενσωματωμένος τρόπος είναι να χρησιμοποιήσετε το sys μονάδα μέτρησης. Όσον αφορά τα ονόματα και τη χρήση του, σχετίζεται άμεσα με τη βιβλιοθήκη C (libc).

Ο δεύτερος τρόπος είναι ο getopt ενότητα, η οποία χειρίζεται τόσο σύντομες όσο και μεγάλες επιλογές, συμπεριλαμβανομένης της αξιολόγησης των τιμών των παραμέτρων.

Η ενότητα argparse, το οποίο προέρχεται από το optparse ενότητα (διαθέσιμη έως Python 2.7).

Η docopt ενότητα, που είναι διαθέσιμη στο GitHub, επιτρέπει επίσης την ίδια λειτουργικότητα.

Πρόσφατα, το absl βιβλιοθήκη έχει επίσης αποκτήσει ατμό, ως μέσο για την αντικατάσταση optparse και getopt().

Καθένας από αυτούς τους τρόπους έχει τα πλεονεκτήματα και τα μειονεκτήματά του, επομένως αξίζει να αξιολογήσετε τον καθένα για να δείτε ποιος ταιριάζει καλύτερα στις ανάγκες σας.

Η ενότητα sys

Αυτή είναι μια βασική ενότητα που έχει αποσταλεί με την Python από τις πρώτες μέρες. Χρειάζεται μια πολύ παρόμοια προσέγγιση με τη βιβλιοθήκη C χρησιμοποιώντας argc/argv για πρόσβαση στα επιχειρήματα. ο μονάδα sys υλοποιεί τα ορίσματα της γραμμής εντολών σε μια απλή δομή λίστας με όνομα sys.argv.

Κάθε στοιχείο λίστας αντιπροσωπεύει ένα μόνο όρισμα. Το πρώτο στοιχείο στη λίστα, sys.argv[0], είναι το όνομα του σεναρίου Python. Τα υπόλοιπα στοιχεία της λίστας, sys.argv[1] προς την sys.argv[n], είναι τα ορίσματα της γραμμής εντολών 2 έως n.

Ως οριοθέτης μεταξύ των ορισμάτων, χρησιμοποιείται ένα κενό. Οι τιμές ορισμάτων που περιέχουν ένα κενό σε αυτό πρέπει να περιβάλλονται από εισαγωγικά προκειμένου να αναλυθούν σωστά με sys.

Το ισοδύναμο του argc είναι μόνο ο αριθμός των στοιχείων στη λίστα. Για να αποκτήσετε αυτήν την τιμή, χρησιμοποιήστε την Python len() χειριστής. Θα το δείξουμε σε ένα παράδειγμα κώδικα αργότερα.

Εκτύπωση του πρώτου ορίσματος CLI

Σε αυτό το πρώτο παράδειγμα, το σενάριό μας θα καθορίσει τον τρόπο που ονομάστηκε. Αυτές οι πληροφορίες διατηρούνται στο πρώτο όρισμα της γραμμής εντολών, με ευρετήριο με 0. Ο παρακάτω κώδικας δείχνει πώς αποκτάτε το όνομα του σεναρίου Python σας:

import sys

print("The script has the name %s" % (sys.argv[0])

Αποθηκεύστε αυτόν τον κώδικα σε ένα αρχείο με το όνομα arguments-program-name.py, και μετά καλέστε το όπως φαίνεται παρακάτω. Η έξοδος είναι η εξής και περιέχει το όνομα του αρχείου, συμπεριλαμβανομένης της πλήρους διαδρομής του:

$ python arguments-program-name.py
The script has the name arguments-program-name.py
$ python /home/user/arguments-program-name.py
The script has the name /home/user/arguments-program-name.py

Όπως μπορείτε να δείτε από τη δεύτερη κλήση παραπάνω, δεν παίρνουμε μόνο το όνομα του αρχείου Python, αλλά και την πλήρη διαδρομή που χρησιμοποιείται για την κλήση του.

Μετρώντας τον αριθμό των επιχειρημάτων

Σε αυτό το δεύτερο παράδειγμα μετράμε απλώς τον αριθμό των ορισμάτων της γραμμής εντολών χρησιμοποιώντας το ενσωματωμένο len() μέθοδος. sys.argv είναι η λίστα που πρέπει να εξετάσουμε. Στον παρακάτω κώδικα, παίρνουμε τον αριθμό των ορισμάτων και μετά αφαιρούμε 1 επειδή ένα από αυτά τα ορίσματα (δηλαδή το πρώτο) ορίζεται πάντα ως όνομα του αρχείου, το οποίο δεν είναι πάντα χρήσιμο για εμάς. Έτσι, ο πραγματικός αριθμός των ορισμάτων που διαβιβάζονται από τον χρήστη είναι len(sys.argv) - 1:

import sys


arguments = len(sys.argv) - 1
print ("The script is called with %i arguments" % (arguments))

Αποθηκεύστε και ονομάστε αυτό το αρχείο arguments-count.py. Μερικά παραδείγματα κλήσης αυτού του σεναρίου φαίνονται παρακάτω. Αυτό περιλαμβάνει τρία διαφορετικά σενάρια:

• Μια κλήση χωρίς περαιτέρω ορίσματα γραμμής εντολών
• Μια κλήση με δύο επιχειρήματα
• Μια κλήση με δύο ορίσματα, όπου το δεύτερο είναι μια συμβολοσειρά σε εισαγωγικά που περιέχει ένα διάστημα

$ python arguments-count.py
The script is called with 0 arguments
$ python arguments-count.py --help me
The script is called with 2 arguments
$ python arguments-count.py --option "long string"
The script is called with 2 arguments

Επανάληψη μέσω επιχειρημάτων

Το τρίτο παράδειγμά μας εξάγει κάθε μεμονωμένο όρισμα που αποστέλλεται στο σενάριο Python, εκτός από το ίδιο το όνομα του προγράμματος. Επομένως, κάνουμε βρόχο μέσα από τα ορίσματα της γραμμής εντολών που ξεκινούν με το δεύτερος στοιχείο λίστας. Θυμηθείτε ότι αυτός είναι ο δείκτης 1, καθώς οι λίστες βασίζονται στο 0 στην Python:

import sys


arguments = len(sys.argv) - 1


position = 1
while (arguments >= position):
    print ("Parameter %i: %s" % (position, sys.argv[position]))
    position = position + 1

Παρακάτω καλούμε τον κώδικά μας, ο οποίος αποθηκεύτηκε στο αρχείο arguments-output.py. Όπως έγινε με το προηγούμενο παράδειγμά μας, η έξοδος απεικονίζει τρεις διαφορετικές κλήσεις:

• Κάλεσμα χωρίς επιχειρήματα
• Μια κλήση με δύο επιχειρήματα
• Μια κλήση με δύο ορίσματα, όπου το δεύτερο όρισμα είναι μια συμβολοσειρά σε εισαγωγικά που περιέχει ένα διάστημα

$ python arguments-output.py
$ python arguments-output.py --help me
Parameter 1: --help
Parameter 2: me
$ python arguments-output.py --option "long string"
Parameter 1: --option
Parameter 2: long string

Θυμηθείτε, το σημείο εμφάνισης του παραδείγματος συμβολοσειράς είναι ότι οι παράμετροι συνήθως οριοθετούνται από ένα διάστημα, εκτός περιβάλλονται από εισαγωγικά.

Σημαίες Abseil (absl)

Η βιβλιοθήκη Abseil's Flags προορίζεται να φέρει ορίσματα γραμμής εντολών στην παραγωγή, με κατανεμημένα ορίσματα γραμμής εντολών. Όταν μια λειτουργική μονάδα χρησιμοποιεί σημαίες γραμμής εντολών και εισάγεται σε μια άλλη λειτουργική μονάδα – την άλλη λειτουργική μονάδα εισάγει και τις σημαίες, και μπορεί να τα επεξεργαστεί προωθώντας τα στην εισαγόμενη λειτουργική μονάδα.

Αυτό καθιστά τα σύνθετα ορίσματα γραμμής εντολών που μοιράζονται μεταξύ των μονάδων ευκολότερα και λιγότερο περιεκτικά.

Επιπλέον, η βιβλιοθήκη σάς επιτρέπει να ορίσετε τις προεπιλεγμένες τιμές, τις περιγραφές και τον τύπο δεδομένων των ορισμάτων, επομένως δεν απαιτούνται πρόσθετοι έλεγχοι και μετατροπές.

from absl import flags
import sys


flags.DEFINE_string('name', 'User', 'The name of the user.')


FLAGS = flags.FLAGS
FLAGS(sys.argv)

print(f"Hello {FLAGS.name}!")

Οι υποστηριζόμενοι τύποι δεδομένων είναι:

• DEFINE_integer()
• DEFINE_string()
• DEFINE_bool()
• DEFINE_enum()
• DEFINE_list()
• DEFINE_float()

Καθώς DEFINE_multi_integer(), DEFINE_multi_string() και DEFINE_multi_enum() για εισαγωγή πολλών επιχειρημάτων. Επιπλέον, τρέξιμο --help, --helpfull, κ.λπ. εκτυπώστε τις υπάρχουσες σημαίες και τις περιγραφές τους, σε διαφορετικές μορφές.

Η βιβλιοθήκη σάς επιτρέπει επίσης να ορίσετε επικυρώσεις – τόσο ως προς το εύρος, όπως τιμές που βασίζονται σε ακέραιο upper_bound or lower_bound αυτό είναι αποδεκτό και η εκτέλεση αυθαίρετων μεθόδων για έλεγχο τιμών:

def validate_name(value):
    return len(value) > 15

flags.register_validator('name',
                         validate_name,
                         message='Name is over 15 characters long.',
                         flag_values=FLAGS)

Συγκεντρώνοντας τα σε ένα συγκεκριμένο παράδειγμα:

from absl import flags
import sys

flags.DEFINE_string('name', 'User', 'The name of the user.')
flags.DEFINE_integer('tasks', 0, 'The number of tasks a user has.', lower_bound=0)

FLAGS = flags.FLAGS
FLAGS(sys.argv)

print(f"{FLAGS.name} has {FLAGS.tasks} tasks to work on.")

$ python flags.py --name=John --tasks=5
John has 5 tasks to work on.

$ python flags.py --name=John --tasks=-1

Traceback (most recent call last):
  File "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/absl/flags/_flag.py", line 180, in _parse
    return self.parser.parse(argument)
  File "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/absl/flags/_argument_parser.py", line 168, in parse
    raise ValueError('%s is not %s' % (val, self.syntactic_help))
ValueError: -1 is not a non-negative integer
...

Η ενότητα argparse

Η ενότητα argparse είναι διαθέσιμο από την Python 3.2 και μια βελτίωση του optparse ενότητα που υπάρχει μέχρι την Python 2.7. Η τεκμηρίωση της Python περιέχει μια περιγραφή API και ένα σεμινάριο που καλύπτει όλες τις μεθόδους λεπτομερώς.

Η μονάδα προσφέρει μια διεπαφή γραμμής εντολών με τυποποιημένη έξοδο, ενώ οι δύο πρώτες λύσεις αφήνουν μεγάλο μέρος της δουλειάς στα χέρια σας. argparse επιτρέπει την επαλήθευση σταθερών και προαιρετικών ορισμάτων, με έλεγχο ονόματος είτε σε σύντομο είτε σε μεγάλο στυλ. Ως προεπιλεγμένο προαιρετικό όρισμα, περιλαμβάνει -h, μαζί με τη μεγάλη εκδοχή του --help. Αυτό το όρισμα συνοδεύεται από ένα προεπιλεγμένο μήνυμα βοήθειας που περιγράφει τα αποδεκτά ορίσματα.

Ο παρακάτω κώδικας δείχνει την προετοιμασία του αναλυτή και η έξοδος παρακάτω δείχνει τη βασική κλήση, ακολουθούμενη από το μήνυμα βοήθειας. Σε αντίθεση με τις κλήσεις Python που χρησιμοποιήσαμε στα προηγούμενα παραδείγματα, έχετε κατά νου να χρησιμοποιήσετε την Python 3 με αυτά τα παραδείγματα:

import argparse


parser = argparse.ArgumentParser()
parser.parse_args()

$ python3 arguments-argparse-basic.py 
$ python3 arguments-argparse-basic.py -h
usage: arguments-argparse-basic.py [-h]

optional arguments:
  -h, --help  show this help message and exit
$ python3 arguments-argparse-basic.py --verbose
usage: arguments-argparse-basic.py [-h]
arguments-argparse-basic.py: error: unrecognized arguments: --verbose

Στο επόμενο βήμα, θα προσθέσουμε μια προσαρμοσμένη περιγραφή στο μήνυμα βοήθειας για τους χρήστες μας. Η εκκίνηση του αναλυτή με αυτόν τον τρόπο επιτρέπει ένα πρόσθετο κείμενο. Ο παρακάτω κώδικας αποθηκεύει την περιγραφή στο text μεταβλητή, η οποία δίνεται ρητά στο argparse τάξη ως το description παράμετρος. Καλώντας αυτόν τον κωδικό παρακάτω, μπορείτε να δείτε πώς φαίνεται η έξοδος:

import argparse


text = 'This is a test program. It demonstrates how to use the argparse module with a program description.'


parser = argparse.ArgumentParser(description=text)
parser.parse_args()

$ python3 arguments-argparse-description.py --help
usage: arguments-argparse-description.py [-h]

This is a test program. It demonstrates how to use the argparse module with a
program description.

optional arguments:
  -h, --help  show this help message and exit

Ως τελικό βήμα θα προσθέσουμε ένα προαιρετικό όρισμα με όνομα -V, το οποίο έχει ένα αντίστοιχο όρισμα μεγάλου στυλ με όνομα --version. Για να το κάνουμε αυτό χρησιμοποιούμε τη μέθοδο add_argument() που καλούμε με τρεις παραμέτρους (εμφανίζεται για --version, μόνο):

• Το όνομα της παραμέτρου: --version
• Το κείμενο βοήθειας για την παράμετρο: help="show program version"
• Ενέργεια (χωρίς πρόσθετη αξία): action="store_true"

Ο πηγαίος κώδικας για αυτό εμφανίζεται παρακάτω. Διαβάζοντας τα ορίσματα στη μεταβλητή που καλείται args γίνεται μέσω του parse_args() μέθοδο από το parser αντικείμενο. Σημειώστε ότι υποβάλλετε τόσο τη σύντομη όσο και τη μεγάλη έκδοση σε μία κλήση. Τέλος, ελέγχετε αν τα χαρακτηριστικά args.V or args.version ορίζονται και εξάγουν το μήνυμα έκδοσης:

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-V", "--version", help="show program version", action="store_true")


args = parser.parse_args()


if args.version:
    print("This is myprogram version 0.1")

$ python3 arguments-argparse-optional.py -V
This is myprogram version 0.1
$ python3 arguments-argparse-optional.py --version
This is myprogram version 0.1

Η --version Το όρισμα δεν απαιτεί να δοθεί μια τιμή στη γραμμή εντολών. Γι' αυτό ορίσαμε το όρισμα δράσης "store_true". Σε άλλες περιπτώσεις, μπορεί να χρειαστείτε μια πρόσθετη εκχωρημένη τιμή, για παράδειγμα εάν καθορίσετε έναν συγκεκριμένο όγκο, ύψος ή πλάτος. Αυτό φαίνεται στο επόμενο παράδειγμα. Ως προεπιλεγμένη περίπτωση, σημειώστε ότι όλα τα ορίσματα ερμηνεύονται ως συμβολοσειρές:

import argparse


parser = argparse.ArgumentParser()


parser.add_argument("--width", "-w", help="set output width")


args = parser.parse_args()


if args.width:
    print("Set output width to %s" % args.width)

Εδώ δείχνουμε τι συμβαίνει όταν υποβάλλουμε διαφορετικές τιμές ορίσματος. Αυτό περιλαμβάνει τόσο τη σύντομη όσο και τη μεγάλη έκδοση, καθώς και το μήνυμα βοήθειας:

$ python3 arguments-argparse-optional2.py -w 10
Set output width to 10
$ python3 arguments-argparse-optional2.py --width 10
Set output width to 10
$ python3 arguments-argparse-optional2.py -h
usage: arguments-argparse-optional2.py [-h] [--width WIDTH]

optional arguments:
  -h, --help            show this help message and exit
  --width WIDTH, -w WIDTH
                        set output width

Η ενότητα getopt

Όπως ίσως έχετε παρατηρήσει πριν, το sys Η μονάδα χωρίζει τη συμβολοσειρά της γραμμής εντολών μόνο σε μεμονωμένες όψεις. Η Python μονάδα getopt προχωρά λίγο παραπέρα και επεκτείνει τον διαχωρισμό της συμβολοσειράς εισόδου με επικύρωση παραμέτρων. Βασισμένο στο getopt Η λειτουργία C, επιτρέπει τόσο σύντομες όσο και μεγάλες επιλογές, συμπεριλαμβανομένης της εκχώρησης τιμής.

Στην πράξη, απαιτεί την sys μονάδα για να επεξεργάζεται σωστά τα δεδομένα εισόδου. Για να γίνει αυτό, τόσο το sys ενότητα και το getopt Η μονάδα πρέπει να φορτωθεί εκ των προτέρων. Στη συνέχεια, από τη λίστα των παραμέτρων εισαγωγής αφαιρούμε το πρώτο στοιχείο λίστας (δείτε τον κώδικα παρακάτω) και αποθηκεύουμε την υπόλοιπη λίστα ορισμάτων γραμμής εντολών στη μεταβλητή που ονομάζεται argument_list:

import getopt, sys


full_cmd_arguments = sys.argv


argument_list = full_cmd_arguments[1:]

print argument_list

Τα επιχειρήματα στο argument_list μπορεί τώρα να αναλυθεί χρησιμοποιώντας το getopts() μέθοδος. Αλλά πριν το κάνουμε αυτό, πρέπει να πούμε getopts() για το ποιες παράμετροι είναι έγκυρες. Ορίζονται ως εξής:

short_options = "ho:v"
long_options = ["help", "output=", "verbose"]

Αυτό σημαίνει ότι αυτά τα επιχειρήματα είναι εκείνα που θεωρούμε έγκυρα, μαζί με ορισμένες επιπλέον πληροφορίες:

------------------------------------------
long argument   short argument  with value
------------------------------------------
--help           -h              no
--output         -o              yes
--verbose        -v              no
------------------------------------------

Ίσως έχετε παρατηρήσει ότι το o Η σύντομη επιλογή προχωρούσε με άνω και κάτω τελεία, :. Αυτό λέει getopt ότι σε αυτήν την επιλογή θα πρέπει να εκχωρηθεί μια τιμή.

Αυτό μας επιτρέπει τώρα να επεξεργαστούμε μια λίστα επιχειρημάτων. ο getopt() Η μέθοδος απαιτεί τη διαμόρφωση τριών παραμέτρων – τη λίστα των πραγματικών ορισμάτων από argv, καθώς και τις έγκυρες σύντομες και μεγάλες επιλογές (εμφανίζονται στο προηγούμενο απόσπασμα κώδικα).

Η ίδια η κλήση της μεθόδου διατηρείται σε μια δήλωση try-catch για την κάλυψη σφαλμάτων κατά την αξιολόγηση. Μια εξαίρεση δημιουργείται εάν ανακαλυφθεί ένα όρισμα που δεν είναι μέρος της λίστας όπως ορίστηκε προηγουμένως. Το σενάριο Python θα εκτυπώσει το μήνυμα σφάλματος στην οθόνη και θα εξέλθει με τον κωδικό σφάλματος 2:

try:
    arguments, values = getopt.getopt(argument_list, short_options, long_options)
except getopt.error as err:
    
    print (str(err))
    sys.exit(2)

Τέλος, τα ορίσματα με τις αντίστοιχες τιμές αποθηκεύονται στις δύο μεταβλητές που ονομάζονται arguments και values. Τώρα, μπορείτε εύκολα να αξιολογήσετε αυτές τις μεταβλητές στον κώδικά σας. Μπορούμε να χρησιμοποιήσουμε α for-βρόχος για επανάληψη μέσα από τη λίστα των αναγνωρισμένων ορισμάτων, μια καταχώρηση μετά την επόμενη.

for current_argument, current_value in arguments:
    if current_argument in ("-v", "--verbose"):
        print ("Enabling verbose mode")
    elif current_argument in ("-h", "--help"):
        print ("Displaying help")
    elif current_argument in ("-o", "--output"):
        print (("Enabling special output mode (%s)") % (current_value))

Παρακάτω μπορείτε να δείτε την έξοδο από την εκτέλεση αυτού του κώδικα. Θα δείξουμε πώς αντιδρά το πρόγραμμα τόσο με έγκυρα όσο και με μη έγκυρα ορίσματα προγράμματος:

$ python arguments-getopt.py -h
Displaying help
$ python arguments-getopt.py --help
Displaying help
$ python arguments-getopt.py --output=green --help -v
Enabling special output mode (green)
Displaying help
Enabling verbose mode
$ python arguments-getopt.py -verbose
option -e not recognized

Η τελευταία κλήση στο πρόγραμμά μας μπορεί να φαίνεται λίγο μπερδεμένη στην αρχή. Για να το καταλάβετε, πρέπει να γνωρίζετε ότι οι επιλογές στενογραφίας (μερικές φορές ονομάζονται και σημαίες) μπορούν να χρησιμοποιηθούν μαζί με μία μόνο παύλα. Αυτό επιτρέπει στο εργαλείο σας να δέχεται πιο εύκολα πολλές επιλογές. Για παράδειγμα, καλώντας python arguments-getopt.py -vh είναι το ίδιο με την κλήση python arguments-getopt.py -v -h. Έτσι στην τελευταία κλήση παραπάνω, το getopt η μονάδα σκέφτηκε ότι ο χρήστης προσπαθούσε να περάσει -e ως επιλογή, η οποία είναι άκυρη.

Συμπέρασμα

Σε αυτό το άρθρο δείξαμε πολλές διαφορετικές μεθόδους για την ανάκτηση ορισμάτων γραμμής εντολών στην Python, συμπεριλαμβανομένης της χρήσης sys, getopt, να argparse. Αυτές οι μονάδες διαφέρουν ως προς τη λειτουργικότητα, μερικές παρέχουν πολύ περισσότερα από άλλες. sys είναι πλήρως ευέλικτο, ενώ και τα δύο getoptκαι argparse απαιτούν κάποια δομή. Αντίθετα, καλύπτουν το μεγαλύτερο μέρος της πολύπλοκης εργασίας που sys αφήνεται σε εσάς. Αφού επεξεργαστείτε τα παραδείγματα που παρέχονται, θα πρέπει να είστε σε θέση να προσδιορίσετε ποια ενότητα ταιριάζει καλύτερα στο έργο σας.

Σε αυτό το άρθρο δεν μιλήσαμε για άλλες λύσεις όπως το docopts ενότητα, μόλις το αναφέραμε. Αυτή η ενότητα ακολουθεί μια εντελώς διαφορετική προσέγγιση και θα εξηγηθεί λεπτομερώς σε ένα από τα επόμενα άρθρα.

αναφορές