Şu anda kendime Python öğretiyorum ve sadece (aşağıdaki örneğime göre) basitleştirilmiş terimlerle neyi sys.argv[1]temsil ettiğini merak ediyordum . Sadece bir girdi mi istiyor?

#!/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()

Önceki cevapların, kullanıcının bilgisi hakkında birçok varsayımda bulunduğunu belirtmek isterim. Bu cevap, soruyu daha öğretici bir seviyede cevaplamaya çalışır.

Her Python çağrısı sys.argviçin, komut satırında otomatik olarak argümanları (boşluklarla ayrılmış olarak) temsil eden dizelerin bir listesidir. Ad, argv ve argc'nin komut satırı argümanlarını temsil ettiği C programlama kuralından gelir .

Python'a alıştıkça listeler ve dizeler hakkında daha fazla şey öğrenmek isteyeceksiniz, ancak bu arada bilmeniz gereken birkaç şey var.

Bağımsız değişkenleri temsil edildiği gibi yazdıran bir komut dosyası oluşturabilirsiniz. Ayrıca lenlistedeki işlevi kullanarak argüman sayısını da yazdırır .

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

Komut dosyası, Python 2.6 veya üstünü gerektirir. Bu betiği çağırırsanız print_args.py, ne olacağını görmek için onu farklı argümanlarla çağırabilirsiniz.

> 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

Gördüğünüz gibi, komut satırı argümanları komut dosyası adını içerir ancak yorumlayıcı adını içermez. Bu anlamda Python, komut dosyasını çalıştırılabilir olarak ele alır . Çalıştırılabilir dosyanın adını bilmeniz gerekiyorsa (bu durumda python) kullanabilirsiniz sys.executable.

Örneklerden, kullanıcı betiği tırnak içine alınmış bağımsız değişkenlerle çalıştırırsa, boşluk içeren bağımsız değişkenleri almanın mümkün olduğunu görebilirsiniz, bu nedenle elde ettiğiniz, kullanıcı tarafından sağlanan bağımsız değişkenlerin listesidir.

Şimdi Python kodunuzda, bu dizeler listesini programınıza girdi olarak kullanabilirsiniz. Listeler sıfır tabanlı tamsayılarla indekslendiğinden, liste [0] sözdizimini kullanarak tek tek öğeleri alabilirsiniz. Örneğin, komut dosyası adını almak için:

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

İlginç olsa da, nadiren senaryo adınızı bilmeniz gerekir. Bir dosya adı için komut dosyasından sonraki ilk bağımsız değişkeni almak için aşağıdakileri yapabilirsiniz:

filename = sys.argv[1]

Bu çok yaygın bir kullanımdır, ancak hiçbir bağımsız değişken sağlanmadıysa bir IndexError ile başarısız olacağını unutmayın.

Ayrıca Python, bir listenin bir dilimine başvurmanıza izin verir, böylece yalnızca kullanıcı tarafından sağlanan bağımsız değişkenlerin (ancak komut dosyası adı olmadan) başka bir listesini elde etmek için şunları yapabilirsiniz:

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

Ek olarak, Python değişken adlarına bir dizi öğe (listeler dahil) atamanıza izin verir. Dolayısıyla, kullanıcının her zaman iki bağımsız değişken sağlamasını bekliyorsanız, bu bağımsız değişkenleri (dizeler olarak) iki değişkene atayabilirsiniz:

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

Bu nedenle, özel sorunuzu yanıtlamak için, söz konusu komut dosyasına sağlanan sys.argv[1]ilk komut satırı bağımsız değişkenini (a olarak string) temsil eder . Girdi sormaz, ancak komut satırında komut satırından sonra hiçbir argüman sağlanmadıysa IndexError ile başarısız olur.

sys.argv [1] , betiğinize aktarılan ilk komut satırı bağımsız değişkenini içerir .

Örneğin, komut dosyanız adlandırılmışsa hello.pyve siz yayınlarsanız:

$ python3.1 merhaba.py foo

veya:

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

Komut dosyanız yazdırılacak:

Merhaba foo

sys.argv bir listedir.

Bu liste komut satırınız tarafından oluşturulur, komut satırı argümanlarınızın bir listesidir.

Örneğin:

komut satırınıza şöyle bir şey girersiniz,

python3.2 file.py something

sys.argv liste haline gelecektir ['dosya.py', 'bir şey']

Bu durumda sys.argv[1] = 'something'

Frederic'in cevabına ek olarak, örneğin komut dosyanızı aşağıdaki gibi çağırırsanız:

./myscript.py foo bar

sys.argv[0]"./myscript.py" sys.argv[1]"foo" olur ve sys.argv[2]"bar" olur ... vb.

Örnek kodunuzda, betiği aşağıdaki gibi çağırırsanız, betiğin ./myscript.py foo çıktısı "Merhaba foo" olacaktır.

Jason'ın Cevabına birkaç nokta daha eklemek:

Kullanıcı tarafından sağlanan tüm argümanları almak için: user_args = sys.argv[1:]

Sys.argv'yi (Jason tarafından bahsedildiği gibi) dizelerin bir listesi olarak düşünün. Yani tüm liste manipülasyonları burada geçerli olacaktır. Buna "Liste Dilimleme" denir. Daha fazla bilgi için burayı ziyaret edin .

Sözdizimi şu şekildedir: liste [başlangıç: bitiş: adım]. Başlangıcı atlarsanız, varsayılan olarak 0 olur ve bitişi atlarsanız, varsayılan olarak liste uzunluğunu atar.

Diyelim ki 3. argümandan sonra tüm argümanları almak istiyorsunuz, o zaman:

user_args = sys.argv[3:]

Diyelim ki sadece ilk iki bağımsız değişkeni istiyorsun, o zaman:

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

2 ila 4 arasındaki bağımsız değişkenleri istediğinizi varsayalım:

user_args = sys.argv[2:4]

Son argümanı istediğinizi varsayalım (son argüman her zaman -1'dir, bu yüzden burada olan şey saymaya baştan başlamaktır. Yani başlangıç ​​sondur, son yok, adım yok):

user_args = sys.argv[-1]

İkinci son argümanı istediğinizi varsayalım:

user_args = sys.argv[-2]

Son iki argümanı istediğinizi varsayalım:

user_args = sys.argv[-2:]

Son iki argümanı istediğinizi varsayalım. Burada, başlangıç ​​-2, yani ikinci son öğe ve sonra sonuna kadar (":" ile gösterilir):

user_args = sys.argv[-2:]

Son iki argüman dışında her şeyi istediğinizi varsayalım. Burada başlangıç ​​0'dır (varsayılan olarak) ve bitiş ikinci son öğedir:

user_args = sys.argv[:-2]

Argümanları ters sırada istediğinizi varsayalım:

user_args = sys.argv[::-1]

Bu yardımcı olur umarım.

sys.argv, komut dosyası yolunu ve komut satırı argümanlarını içeren bir listedir; yani sys.argv [0] çalıştırdığınız komut dosyasının yoludur ve aşağıdaki tüm üyeler bağımsız değişkenlerdir.

Komut satırı aracılığıyla bir komut dosyası çalıştırırken python betiğinize bağımsız değişkenler geçirmek

python create_thumbnail.py test1.jpg test2.jpg

burada, komut dosyası adı - create_thumbnail.py, bağımsız değişken 1 - test1.jpg, bağımsız değişken 2 - test2.jpg

Create_thumbnail.py betiğinde kullanıyorum

sys.argv[1:]

bana komut satırında ['test1.jpg', 'test2.jpg'] olarak geçtiğim argümanların listesini veriyor

sys.argvsysmodülün bir özelliğidir . Komut satırında dosyaya aktarılan argümanların olduğunu söylüyor. sys.argv[0]dosyanın bulunduğu dizini yakalar. sys.argv[1]komut satırında iletilen ilk argümanı döndürür. Bir example.py dosyamız varmış gibi düşünün.

example.py

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

Şimdi burada, bunu yaptığımızda komut isteminde:

python example.py

2. satıra bir dizin hatası atar. Çünkü henüz geçirilen bir argüman yok. Kullanıcının ilettiği argümanların uzunluğunu görebilirsiniz if len(sys.argv) >= 1: # Code. Example.py'yi bir argüman ileterek çalıştırırsak

python example.py args

Aşağıdakileri yazdırır:

args

Çünkü bu ilk tartışmaydı! PyInstaller kullanarak onu çalıştırılabilir bir dosya yaptığımızı varsayalım. Bunu yapardık:

example argumentpassed

Aşağıdakileri yazdırır:

argumentpassed

Terminalde bir komut verirken gerçekten yardımcı olur. İlk önce argümanların uzunluğunu kontrol edin. Hiçbir argüman iletilmezse, yardım metnini yapın.

sys .argv, bir komut dosyası çalıştırırken aktarılan komut satırı bağımsız değişkenlerini görüntüler veya sys.argv'nin, terminalden çalışırken python'da geçirilen komut satırı argümanlarını depolayacağını söyleyebilirsiniz.

Sadece şunu dene:

import sys
print sys.argv

argv, bir python listesinde iletilen tüm argümanları saklar. Yukarıdakiler, komut dosyasını çalıştıracak olan tüm argümanları yazdıracaktır.

Şimdi bunu filename.py dosyanızı şu şekilde çalıştırmayı deneyin:

python filename.py example example1

bu bir listede 3 argüman yazdıracaktır.

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

Benzer şekilde, argv 1 , bu durumda "örnek" olarak geçen ilk argümandır.

Benzer bir soru zaten burada btw soruldu . Bu yardımcı olur umarım!