Python is een taal op hoog niveau die is ontworpen voor het uitvoeren van algemene codes en niet voor een specifiek probleem. We kunnen het gebruiken voor algemene doeleinden, zoals het maken van websites met python of het analyseren van de gegevens met behulp van deze python-taal. De 'Python'-programmering biedt ook de command_line-argumenten. De opdrachtregelargumenten zijn die argumenten die we op de console of terminal van een besturingssysteem hebben gegeven na het noemen van de naam van het codebestand samen met de bestandsextensie. We kunnen het ook definiëren als, in elk programma, de waarde die wordt doorgegeven via de opdrachtprompt waarvan wordt gezegd dat het opdrachtregelargumenten zijn. In deze handleiding zullen we het commandoregelargument in 'Python'-programmering bespreken.
Methoden voor opdrachtregelargumenten in Python
- Door gebruik te maken van 'sys.argv'
- Door gebruik te maken van de 'argparse' module
- Door gebruik te maken van de 'getopt' module
We zullen alle methoden in detail uitleggen in deze gids en ook de praktische demonstratie van al die methoden laten zien.
Voorbeeld # 01: volgens sys.argv-methode
We doen deze python-codes in de 'Spyder' -app. We hebben toegang tot opdrachtregelvariabelen en functies door het systeem te importeren. We importeren dus 'sys' en dan declareren en initialiseren we de variabele 'num' met de 'len(sys.argv)'. De 'argv' wordt de lijst met tekenreekswaarden die de argumenten zijn die onze opdrachtregel zal worden. 'len' staat voor de lengte van de argumenten die worden doorgegeven. Dus in de variabele 'num' wordt het aantal waarden opgeslagen dat op de terminal wordt doorgegeven als de opdrachtregel.
We tonen ook de argumentnummers die worden doorgegeven door gebruik te maken van de 'print'. Daaronder plaatsen we de “sys.argv[0]” in het print statement. De 'argv' bevat altijd de programmanaam of codebestandsnaam. De naam van het bestand dat we hebben gemaakt, wordt dus weergegeven op de terminal. Hierna printen we de argumenten die op de terminal worden doorgegeven. Het zal alle getallen afdrukken die we hebben doorgegeven als de opdrachtregelargumenten op het consolescherm.
Hieronder hebben we een for-lus gedefinieerd en daar een variabele 'a' gedeclareerd waarvan het bereik ligt tussen '1' en de lengte van de argv die is opgeslagen in 'num'. Print alle argumenten op de console. 'argv[a]' bevat alle command_line-argumenten. Het toont ze ook op de console. Nu initialiseren we 'som' omdat we de som van alle waarden willen berekenen die we zullen doorgeven op het moment van uitvoering op de terminal.
We gebruiken opnieuw de 'for'-lus en passeren het bereik. Maar deze keer berekenen we de som van al die waarden die we op de terminal hebben doorgegeven. Deze som wordt opgeslagen in de variabele 'som'. Vervolgens printen we ook de som van alle waarden die we zullen doorgeven op het moment van uitvoering op de terminal.
importeren sysop een = enkel en alleen ( sys . argv )
afdrukken ( 'Totaal aantal argumenten doorgegeven hier :' , op een )
afdrukken ( ' \n Naam van Python-bestand:' , sys . argv [ 0 ] )
afdrukken ( ' \n Argumenten die we hebben doorgegeven:' , einde = ' ' )
voor a in bereik ( 1 , op een ) :
afdrukken ( sys . argv [ a ] , einde = ' ' )
Som = 0
voor i in bereik ( 1 , op een ) :
Som + = int ( sys . argv [ i ] )
afdrukken ( ' \n \n De som van argumenten doorgegeven: ' , Som )
Op de terminal plaatsen we eerst het trefwoord 'run'. Plaats vervolgens de bestandsnaam samen met de juiste extensie en geef hier de opdrachtregelargumenten door. Het geeft dus alle regels weer zoals we in de bovenstaande code hebben gedefinieerd. Het geeft eerst de lengte van de opdrachtregelargumenten weer en vervolgens de naam van het bestand. Hierna worden alle opdrachtregelargumenten weergegeven en ook de som van al deze argumenten.
Voorbeeld # 02: Door argparse-methode
Nu gebruiken we in dit voorbeeld de 'argparse' -methode. We importeren eerst de “argparse”. We zullen dus toegang krijgen tot de variabelen en de functie hiervan. We initialiseren een 'data' -variabele en slaan een regel op die we in onze code zullen gebruiken. Hierna initialiseren we een 'parser' en in 'description' geven we de 'data' -variabele door waarin we het bericht hebben opgeslagen dat we willen weergeven en we plaatsen deze allemaal in de 'my_parser' -variabele. We plaatsen ook de 'parse.args()' aan het einde.
importeren argparsegegevens = 'We gebruiken hier de argparse-methode'
mijn_parser = argparse. ArgumentParser ( Omschrijving = gegevens )
mijn_parser. parse_args ( )
Bekijk hieronder de uitkomst. Wanneer we '-h' doorgeven als het opdrachtregelargument, wordt eerst het bericht weergegeven dat we hebben opgeslagen in de 'data' -variabele en wordt ook het 'optionele argument' weergegeven, aangezien deze 'h' het helpbericht toont. Wanneer we '-o' als argument op de opdrachtregel plaatsen, wordt een foutmelding weergegeven dat het een niet-herkend argument is.
Voorbeeld # 03: Door getopt-methode
Dit is de laatste methode die we in deze code gebruiken. We importeren zowel 'sys' als 'getopt' in deze code. Deze 'getopt' is de parser die we hebben gebruikt voor de opdrachtregelargumenten. Vervolgens hebben we in de variabele 'argumentList' de 'sys.argv[1:]' doorgegeven om het eerste argument dat we in de opdrachtregel doorgeven te verwijderen. We initialiseren de 'my_option' met de 'hmo:'.
Hierna initialiseren we de variabele 'my_long_option'. We gebruiken hier de 'try' die de fout zal controleren. Hierna analyseren we de argumenten. De 'getopt' biedt zowel korte als lange opties, samen met de mogelijkheid om een waarde aan te duiden. Hierna controleren we alle argumenten die we zullen doorgeven als opdrachtregelargumenten. Als het opdrachtregelargument '-h' of '–Help' is, wordt het bericht hieronder afgedrukt. Als het opdrachtregelargument '-m' of '—Mijn_bestand' is, wordt het bericht weergegeven dat hierna is geschreven.
Als het opdrachtregelargument '-o' of '–Output' is, wordt ook het bericht weergegeven dat we hierna hebben geschreven. Als het opdrachtregelargument niet van al het bovenstaande is, wordt het foutbericht weergegeven zoals we de 'getopt. fout' in de code.
importeren getopt , sysargumentLijst = sys . argv [ 1 : ]
mijn_opties = 'nacht:'
nieuwe_lange_opties = [ 'Helpen' , 'Mijn bestand' , 'Uitvoer='
proberen :
argumenten , waarden = getopt . getopt ( argumentLijst , mijn_opties , nieuwe_lange_opties )
voor mijn_Argument , mijn_Waarde in argumenten:
als mijn_Argument in ( '-h' , '--Helpen' ) :
afdrukken ( 'Help weergeven' )
elif mijn_Argument in ( '-m' , '--Mijn bestand' ) :
afdrukken ( 'Bestandsnaam weergeven:' , sys . argv [ 0 ] )
elif mijn_Argument in ( '-O' , '--Uitgang' ) :
afdrukken ( ( 'Speciale uitvoermodus inschakelen (% s)' ) % ( mijn_Waarde ) )
behalve getopt . fout net zo fout:
afdrukken ( str ( foutje ) )
Hier zie je dat wanneer we '-h' als de opdrachtregel plaatsen, hetzelfde bericht wordt weergegeven dat we in de code hebben geschreven. Wanneer we twee opdrachtregelargumenten plaatsen als '–Help' en ook '-m', worden hieronder twee berichten weergegeven. In het opdrachtregelargument '-o' hebben we ook de tekenreeks doorgegeven die ook in het bericht wordt weergegeven.
Conclusie
We hebben deze gids verstrekt om u te helpen het concept van 'opdrachtregelargumenten' in 'Python' te leren. We hebben het 'opdrachtregelargument' onderzocht en hier ook drie methoden uitgelegd. We hebben het opdrachtregelargument uitgelegd dat het proces van het doorgeven van de waarden aan het programma samen met de programmanaam op het moment van uitvoering via de opdrachtprompt.