Ik ben mezelf momenteel Python aan het aanleren en vroeg me af (verwijzend naar mijn voorbeeld hieronder) in vereenvoudigde bewoordingen wat de sys.argv[1]vertegenwoordigt. Vraagt ​​het gewoon om input?

#!/usr/bin/python3.1
# import modules used here -- sys is a very standard one
import sys
# Gather our code in a main() function
def main():
  print ('Hello there', sys.argv[1])
  # Command line args are in sys.argv[1], sys.argv[2] ..
  # sys.argv[0] is the script name itself and can be ignored
# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
  main()

Antwoord 1, autoriteit 100%

Ik wil graag opmerken dat eerdere antwoorden veel aannames deden over de kennis van de gebruiker. Dit antwoord probeert de vraag op een meer zelfstudieniveau te beantwoorden.

Voor elke aanroep van Python is sys.argvautomatisch een lijst met strings die de argumenten vertegenwoordigen (gescheiden door spaties) op de opdrachtregel. De naam komt van de C-programmeerconventiewaarin argv en argc vertegenwoordigen de opdrachtregelargumenten.

Je zult meer willen leren over lijsten en strings terwijl je vertrouwd raakt met Python, maar in de tussentijd zijn hier een paar dingen die je moet weten.

U kunt eenvoudig een script maken dat de argumenten afdrukt zoals ze worden weergegeven. Het drukt ook het aantal argumenten af, met behulp van de functie lenin de lijst.

from __future__ import print_function
import sys
print(sys.argv, len(sys.argv))

Het script vereist Python 2.6 of hoger. Als je dit script print_args.pynoemt, kun je het met verschillende argumenten aanroepen om te zien wat er gebeurt.

> python print_args.py
['print_args.py'] 1
> python print_args.py foo and bar
['print_args.py', 'foo', 'and', 'bar'] 4
> python print_args.py "foo and bar"
['print_args.py', 'foo and bar'] 2
> python print_args.py "foo and bar" and baz
['print_args.py', 'foo and bar', 'and', 'baz'] 4

Zoals u kunt zien, bevatten de opdrachtregelargumenten de scriptnaam, maar niet de interpreternaam. In die zin behandelt Python het script alshet uitvoerbare bestand. Als u de naam van het uitvoerbare bestand (python in dit geval) wilt weten, kunt u sys.executablegebruiken.

Je kunt aan de voorbeelden zien dat het mogelijk is om argumenten te ontvangen die wel spaties bevatten als de gebruiker het script aanroept met argumenten ingekapseld tussen aanhalingstekens, dus wat je krijgt is de lijst met argumenten zoals geleverd door de gebruiker.

>

Nu kun je in je Python-code deze lijst met strings gebruiken als invoer voor je programma. Aangezien lijsten worden geïndexeerd door op nul gebaseerde gehele getallen, kunt u de afzonderlijke items ophalen met behulp van de syntaxis list[0]. Om bijvoorbeeld de scriptnaam te krijgen:

script_name = sys.argv[0] # this will always work.

Hoewel interessant, je hoeft zelden je scriptnaam te weten. Om het eerste argument na het script voor een bestandsnaam te krijgen, kunt u het volgende doen:

filename = sys.argv[1]

Dit is een veelvoorkomend gebruik, maar houd er rekening mee dat het zal mislukken met een IndexError als er geen argument is opgegeven.

Python laat je ook verwijzen naar een deel van een lijst, dus om een andere lijstte krijgen van alleen de door de gebruiker opgegeven argumenten (maar zonder de scriptnaam), kun je dat doen

user_args = sys.argv[1:] # get everything after the script name

Bovendien kunt u met Python een reeks items (inclusief lijsten) toewijzen aan variabelenamen. Dus als je verwacht dat de gebruiker altijd twee argumenten levert, kun je die argumenten (als strings) toewijzen aan twee variabelen:

user_args = sys.argv[1:]
fun, games = user_args # len(user_args) had better be 2

Dus, om uw specifieke vraag te beantwoorden, vertegenwoordigt sys.argv[1]het eerste opdrachtregelargument (als een string) dat aan het script in kwestie wordt geleverd. Er wordt niet om invoer gevraagd, maar het zal mislukken met een IndexError als er geen argumenten worden opgegeven op de opdrachtregel na de scriptnaam.

Antwoord 2, autoriteit 10%

sys.argv[1]bevat de eerste opdrachtregelargumentdoorgegeven aan je script.

Als uw script bijvoorbeeld hello.pyheet en u geeft het volgende uit:

$ python3.1 hello.py foo

of:

$ chmod +x hello.py  # make script executable
$ ./hello.py foo

Uw script wordt afgedrukt:

Hallo daar foo

Antwoord 3, autoriteit 8%

sys.argvis een lijst.

Deze lijst wordt gemaakt door uw opdrachtregel, het is een lijst met uw opdrachtregelargumenten.

Bijvoorbeeld:

in je commandoregel voer je zoiets als dit in,

python3.2 file.py something

sys.argvwordt een lijst [‘file.py’, ‘something’]

In dit geval sys.argv[1] = 'something'

Antwoord 4, autoriteit 3%

Gewoon toevoegen aan Frederic’s antwoord, bijvoorbeeld als je je script als volgt aanroept:

./myscript.py foo bar

sys.argv[0]zou “./myscript.py” zijn
sys.argv[1]zou “foo” en . zijn
sys.argv[2]zou “bar” zijn … enzovoort.

Als u in uw voorbeeldcode het script als volgt aanroept ./myscript.py foo , zal de uitvoer van het script “Hallo daar foo” zijn.

Antwoord 5, autoriteit 2%

Een paar punten meer toevoegen aan Jason’s antwoord:

Voor het nemen van alle door de gebruiker opgegeven argumenten: user_args = sys.argv[1:]

Beschouw de sys.argv als een lijst met strings zoals (vermeld door Jason). Dus alle lijstmanipulaties zijn hier van toepassing. Dit wordt “List Slicing” genoemd. Ga voor meer informatie naar hier.

De syntaxis is als volgt: list[start:end:step]. Als u start weglaat, wordt deze standaard ingesteld op 0, en als u einde weglaat, wordt standaard de lengte van de lijst weergegeven.

Stel dat u alleen alle argumenten na het derde argument wilt gebruiken, dan:

user_args = sys.argv[3:]

Stel dat u alleen de eerste twee argumenten wilt, dan:

user_args = sys.argv[0:2]  or  user_args = sys.argv[:2]

Stel dat u argumenten 2 tot 4 wilt:

user_args = sys.argv[2:4]

Stel dat je het laatste argument wilt (laatste argument is altijd -1, dus wat hier gebeurt, is dat we de telling terug beginnen. Dus begin is laatste, geen einde, geen stap) :

user_args = sys.argv[-1]

Stel dat u het voorlaatste argument wilt:

user_args = sys.argv[-2]

Stel dat u de laatste twee argumenten wilt:

user_args = sys.argv[-2:]

Stel dat u de laatste twee argumenten wilt. Hier is start -2, dat is het voorlaatste item en dan naar het einde (aangegeven met “:”):

user_args = sys.argv[-2:]

Stel dat je alles wilt behalve de laatste twee argumenten. Hier is start 0 (standaard) en einde is een na laatste item:

user_args = sys.argv[:-2]

Stel dat u de argumenten in omgekeerde volgorde wilt:

user_args = sys.argv[::-1]

Hopelijk helpt dit.

Antwoord 6

sys.argv is een lijst met het scriptpad en de opdrachtregelargumenten; d.w.z. sys.argv[0] is het pad van het script dat u uitvoert en alle volgende leden zijn argumenten.

Antwoord 7

Argumenten doorgeven aan uw python-script
tijdens het uitvoeren van een script via de opdrachtregel

python create_thumbnail.py test1.jpg test2.jpg

hier,
scriptnaam – create_thumbnail.py,
argument 1 – test1.jpg,
argument 2 – test2.jpg

Met in het script create_thumbnail.py dat ik gebruik

sys.argv[1:]

die me de lijst met argumenten geven die ik in de opdrachtregel heb doorgegeven als
[‘test1.jpg’, ‘test2.jpg’]

Antwoord 8

sys.argvis een attribuut van de module sys. Er staat dat de argumenten zijn doorgegeven aan het bestand in de opdrachtregel. sys.argv[0]vangt de map op waar het bestand zich bevindt. sys.argv[1]retourneert het eerste argument dat in de opdrachtregel is doorgegeven. Denk dat we een voorbeeld.py-bestand hebben.

voorbeeld.py

import sys # Importing the main sys module to catch the arguments
print(sys.argv[1]) # Printing the first argument

Nu hier in de opdrachtprompt wanneer we dit doen:

python example.py

Het geeft een indexfout op regel 2. Omdat er nog geen argument is doorgegeven. U kunt de lengte zien van de argumenten die door de gebruiker zijn doorgegeven met behulp van if len(sys.argv) >= 1: # Code.
Als we de example.py uitvoeren met het doorgeven van een argument

python example.py args

Het drukt af:

args

Omdat het de eerste ruzie was! Laten we zeggen dat we er een uitvoerbaar bestand van hebben gemaakt met PyInstaller. We zouden dit doen:

example argumentpassed

Het drukt af:

argumentpassed

Het is erg handig als je een commando geeft in de terminal. Controleer eerst de lengte van de argumenten. Als er geen argumenten zijn doorgegeven, doe dan de helptekst.

Antwoord 9

sys.argv geeft de opdrachtregelargs weer die zijn doorgegeven bij het uitvoeren van een script of je kunt zeggen dat sys.argv de opdrachtregelargumenten opslaat die in python zijn doorgegeven terwijl ze vanaf terminal worden uitgevoerd.

Probeer dit eens:

import sys
print sys.argv

argv slaat alle doorgegeven argumenten op in een python-lijst. Het bovenstaande zal alle doorgegeven argumenten afdrukken om het script uit te voeren.

Probeer dit nu eens door uw bestandsnaam.py als volgt uit te voeren:

python filename.py example example1

dit zal 3 argumenten in een lijst afdrukken.

sys.argv[0] #is the first argument passed, which is basically the filename. 

Evenzo is argv1het eerste argument dat wordt doorgegeven, in dit geval ‘voorbeeld’

Een soortgelijke vraag is hieral gesteld. Ik hoop dat dit helpt!