argparse Modülü¶
Giriş¶
Yazdığımız her uygulama grafik arayüzüne sahip olmaz. Bazı uygulamalar komut satırına daha uygundur ve bu uygulamalar bazı parametrelere ihtiyaç duyar. argparse modülü kullanıcıdan aldığımız parametreler için yardım mesajları, nasıl kullanıldığına yönelik mesajları üretir. Ayrıca bu modül kullanıcı geçersiz parametre girerse uygun hata mesajını bastırır.
Ayrıştırıcı Oluşturmak¶
İlk olarak modülümüzü dahil etmemiz gerekiyor. Modülümüzü dahil ettikten sonra ayrıştırıcımız için nesne oluşturuyoruz.:
import argparse
Ardından ArgumentParser üzerinden yeni bir nesne oluşturuyoruz.:
ayristirici = argparse.ArgumentParser(description='Bu uygulama bazı işler yapıyor.')
Artık argümanlar ekleyebiliriz.
Argüman Eklemek¶
ArgumentParser nesnesine gerekli tüm bilgileri verdikten sonra, add_argument() fonksiyonu ile argümanları ekleyebiliriz.
Örnek:
ayristirici.add_argument('-i', '--ilk_arguman', nargs='+', required=False, help="Bu ilk argümandır")
ayristirici.add_argument('-a', '--ikinci_arguman', required=False, help="Bu ikinci argümandır")
İki argümanımızı eklemiş olduk. Şimdi ayristirici.print_help() ile çıktımızı bastıralım ve inceleyelim.
Not: Normal şartlarda argparse modülü komut satırı için uygundur ancak etkileşimli kabukta çalışırken sonuçları görmek için argparse modülünün print_help() fonksiyonunu kullanacağız.
Argüman Ayrıştırmak¶
ArgumentParser nesnesi parse_args() fonksiyonu yardımıyla argümanları ayrıştırmamıza sağlar. Etkileşimli kabuğumuza:
ayristirici.parse_args(['-a', '7'])
yazalım ve çıktımızı inceleyelim.
Çıktımız:
Namespace(ikinci_arguman='7')
parse_args fonksionuna biz ‘-a’ parametresine vermemize rağmen ayrıştırıcımız bize argümanin ikinci ismini ve ona atadığımız değeri -7- verdi.
ArgumentParser Nesnesi¶
Temel olarak ArgumentParser nesnemizin yapısı:
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, allow_abbrev=True)
Yeni bir ArgumentParser nesnesi oluşturulduğunda alacağı tüm argümanlar anahtar kelime -keyword- olarak iletilmeli.
Argümanlar ve Açıklamaları¶
prog: Uygulamanın adı (varsayılan: sys.argv[0])
usage: Uygulamanın kullanım amacını açıklayan bir metin. (varsayılan: Uygulamaya eklenen parametrelerden oluşur)
description: Argüman yardımından önce ekrana çıkar açıklama metni (varsayılan: None)
epilog: Argüman yardımından sonra ekrana çıkan açıklama metni (varsayılan: None)
parents: Farklı bir ArgumentParser nesnesinin sahip olduğu argümanları dahil eder.
formatter_class: Yardım çıktılarını kişiselleştirir.
prefix_chars: İsteğe bağlı argümanların önüne konulan karakteri ayarlar. (varsayılan: -)
fromfile_prefix_chars: Ek argümanların okunması gereken dosyayı önekleyen karakter kümesi. (varsayılan: None)
argument_default: Argümanlar için global değer. (varsayılan: None)
conflict_handler: Çakışan argümanlar için çözüm stratejisi. (genellikle gereksiz)
add_help: -h / –help seçeneğini ayrıştırıcıya ekler. (varsayılan: True)
allow_abbrev: Kısaltmalar net değilse uzun seçeneklerin kısaltılmasını sağlar. (Varsayılan: None)
prog argümanı¶
ArgumentParser nesnesi varsayılan olarak sys.argv[0] çıktısını uygulama ismi olarak kullanır. Bu genellikle tercih edilen bir yöntemdir çünkü çoğu zaman uygulama ismi ile dosya ismi aynı olur.
ilkuygulama.py isimli bir dosya oluşturalım ve içine kodlarımızı yazalım:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', help='foo yardım')
print(ayristirici.print_help())
Çıktımız:
usage: ilkprogram.py [-h] [--foo FOO]
optional arguments:
-h, --help show this help message and exit
--foo FOO foo help
Gördüğümüz gibi uygulama ismimiz ekrana çıktı ancak biz uygulamamızın ismini farklı kullanmak istiyorsak? O zaman ArgumentParser nesnesine prog parametresini uygulama ismini verelim:
import argparse
ayristirici = argparse.ArgumentParser(prog='Bu benim ilk uygulamam')
ayristirici.add_argument('--foo', help='foo yardım')
print(ayristirici.print_help())
Çıktımız:
usage: Bu benim ilk uygulamam [-h] [--foo FOO]
optional arguments:
-h, --help show this help message and exit
--foo FOO foo yardım
Uygulamamızın ismi değişti.
usage argümanı¶
Yazdığımız uygulamaya kullanıcı için küçük bir açıklama eklemek isteyebiliriz. Bu işlem için usage argümanı bize yetişiyor.
Hemen kodumuzu deneyelim.:
import argparse
ayristirici = argparse.ArgumentParser(usage='Bu uygulama şimdilik tek parametre alıyor. ')
ayristirici.add_argument('--parametre', help='parametre yardım')
print(ayristirici.print_help())
Çıktımız:
usage: Bu uygulama şimdilik tek parametre alıyor.
optional arguments:
-h, --help show this help message and exit
--parametre PARAMETRE
parametre yardım
Eğer biz usage parametresini kullanmasaydık o zaman uygulamamız varsayılan olarak tüm parametrelerin sıralı halini kullanacaktı.:
usage: ilkprogram.py [-h] [--parametre PARAMETRE]
optional arguments:
-h, --help show this help message and exit
--parametre PARAMETRE
parametre yardım
description argümanı¶
description argümanı ile uygulamamız için kısa bilgi ve nasıl çalıştığı hakkında açıklama sunar. Yardım mesajı ve parametreler arasında açıklama sunar.
Kodumuzu yazalım:
import argparse
ayristirici = argparse.ArgumentParser(description='Uygulama hakkında açıklama metni')
ayristirici.add_argument('--parametre', help='parametre yardım')
print(ayristirici.print_help())
Çıktımız:
usage: ilkprogram.py [-h] [--parametre PARAMETRE]
Uygulama hakkında açıklama metni
optional arguments:
-h, --help show this help message and exit
--parametre PARAMETRE
parametre yardım
Varsayılan olarak çıktımız belli bir alana sığdırılır ancak bunu değiştirmek isterseniz `formatter_class` argümanı kullanılır.
epilog argümanı¶
Yazdığımız bazı uygulamalar daha fazla açıklamaya ihtiyaç duyabilir. Bunun için epilog parametresini kullanırız.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser(epilog='Uygulama hakkında ikinci açıklama')
ayristirici.add_argument('--parametre', help='parametre yardım')
print(ayristirici.print_help())
Çıktımız:
usage: ilkprogram.py [-h] [--parametre PARAMETRE]
optional arguments:
-h, --help show this help message and exit
--parametre PARAMETRE
parametre yardım
Uygulama hakkında ikinci açıklama
Varsayılan olarak çıktımız belli bir alana sığdırılır ancak bunu değiştirmek isterseniz `formatter_class` argümanı kullanılır.
parents argümanı¶
Bazı durumlarda, argüman ayrıştırıcılar ortak argüman kümesini paylaşabilir. Argüman tanımlarını tekrarlamak yerine ortak argümanları bir kere tanımlayarak tanımlayıp parents argümanı ile farklı ayrıştırıcılarda kullanabiliriz. parents argümanı ArgumentParser nesnesi alır. Python dosyamızı açalım ve bu kodu yazalım:
import argparse
ana_ayristirici = argparse.ArgumentParser(add_help=False)
ana_ayristirici.add_argument('--ilk_arguman')
ana_ayristirici.add_argument('--ikinci_arguman')
ikinci_ayristirici = argparse.ArgumentParser(parents=[ana_ayristirici])
ikinci_ayristirici.add_argument('ucuncu_arguman')
print(ikinci_ayristirici.print_help())
Çıktımız:
usage: ilkprogram.py [-h] [--ilk_arguman ILK_ARGUMAN]
[--ikinci_arguman IKINCI_ARGUMAN]
ucuncu_arguman
positional arguments:
ucuncu_arguman
optional arguments:
-h, --help show this help message and exit
--ilk_arguman ILK_ARGUMAN
--ikinci_arguman IKINCI_ARGUMAN
parents argümanı ile ana_ayristirici mızın argümanlarını ikinci_ayristiri mizda kullanmış olduk.
NOT: Ana ayrıştırıcımıza `add_help=False` eklememiz gerekir çünkü her iki ayrıştırıcımız `-h/–help` argümanına sahip olur ve bu çakışma sebebiyle uygulamamız `raise` hatası verir.
add_help argümanını kaldırıp kodumuzu çalıştıralım:
Traceback (most recent call last):
File "ilkprogram.py", line 7, in <module>
ikinci_ayristirici = argparse.ArgumentParser(parents=[ana_ayristirici])
File "/usr/lib/python3.7/argparse.py", line 1681, in __init__
self._add_container_actions(parent)
File "/usr/lib/python3.7/argparse.py", line 1450, in _add_container_actions
group_map.get(action, self)._add_action(action)
File "/usr/lib/python3.7/argparse.py", line 1580, in _add_action
action = super(_ArgumentGroup, self)._add_action(action)
File "/usr/lib/python3.7/argparse.py", line 1390, in _add_action
self._check_conflict(action)
File "/usr/lib/python3.7/argparse.py", line 1529, in _check_conflict
conflict_handler(action, confl_optionals)
File "/usr/lib/python3.7/argparse.py", line 1538, in _handle_conflict_error
raise ArgumentError(action, message % conflict_string)
argparse.ArgumentError: argument -h/--help: conflicting option strings: -h, --help
formatter_class argümanı¶
ArgumentParser nesnesi alternatif bir biçimlendirme sınıfı tanımlayıp, yardım mesajlarını kişiselleştirilmesine izin verir. Şimdilik dört sınıfa sahiptir.:
class argparse.RawDescriptionHelpFormatter
class argparse.RawTextHelpFormatter
class argparse.ArgumentDefaultsHelpFormatter
class argparse.MetavarTypeHelpFormatter
RawDescriptionHelpFormatter ve RawTextHelpFormatter metinsel açıklamaların nasıl görüneceği üzerinde daha fazla kontrol sağlar. Varsayılan olarak ArgumentParser nesnesi description ve epilog için satır kaydırma özelliğine sahiptir.
Kodumuzu deneyelim:
import argparse
ayristirici = argparse.ArgumentParser(
description='''Uzunca bir açıklama
yazıyoruz ve alt satıra inelim.''',
epilog='''
Uygulama sonu açıklama
metnimiz.''')
ayristirici.print_help()
Çıktımız:
usage: ilkprogram.py [-h]
Uzunca bir açıklama yazıyoruz ve alt satıra inelim.
optional arguments:
-h, --help show this help message and exit
Uygulama sonu açıklama metnimiz.
Görüldüğü üzere biz alt satıra inmiş olsak bile çıktımız aynı satırda görünüyor. Şimdi uygulamamıza formatter_class parametresine RawDescriptionHelpFormatter ekleyelim. Kodumuzu bu şekilde değiştirelim:
import argparse
import textwrap
ayristirici = argparse.ArgumentParser(
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=textwrap.dedent('''\
Uygulama sonu açıklama
metnimiz. Burası ikinci satırımız.'''))
ayristirici.print_help()
Çıktımızı inceleyelim:
usage: ilkprogram.py [-h]
optional arguments:
-h, --help show this help message and exit
Uygulama sonu açıklama
metnimiz. Burası ikinci satırımız.
Görüldüğü üzere yazdığımız açıklama metni ikinci satıra geçti.
RawTextHelpFormatter maintains whitespace for all sorts of help text, including argument descriptions. However, multiple new lines are replaced with one. If you wish to preserve multiple blank lines, add spaces between the newlines.
ArgumentDefaultsHelpFormatter sınıfı ile argümanların varsayılan değerleri hakkında bilgi eklenebilir. Örnek:
import argparse
ayristirici = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
ayristirici.add_argument('--ilk_arguman', type=int, default=81, help='Bu argüman varsayılan değeri 81!')
ayristirici.add_argument('ikinci_argüman', default=[1, 2, 3], help='İkinci argüman yardim mesajı!')
ayristirici.print_help()
Çıktımız:
usage: ilkprogram.py [-h] [--ilk_arguman ILK_ARGUMAN] ikinci_argüman
positional arguments:
ikinci_argüman İkinci argüman yardim mesajı! (default: [1, 2, 3])
optional arguments:
-h, --help show this help message and exit
--ilk_arguman ILK_ARGUMAN
Bu argüman varsayılan değeri 81! (default: 81)
Çıktımıza baktığımız zaman yardım mesajlarının yanında varsayılan olarak aldığı değerleri bize gösteriyor.
MetavarTypeHelpFormatter sınıfı ile argümanın alacağı değerin tipini ekrana basılır. Örnek:
import argparse
ayristirici = argparse.ArgumentParser(
formatter_class=argparse.MetavarTypeHelpFormatter)
ayristirici.add_argument('--a', type=int)
ayristirici.add_argument('--ikinci_argüman', type=dict)
ayristirici.print_help()
Çıktımız:
usage: ilkprogram.py [-h] [--a int] [--ikinci_argüman dict]
optional arguments:
-h, --help show this help message and exit
--a int
--ikinci_argüman dict
Çıktımıza baktığımızda hangi argümanın alacağı değer tipi argümanın yanında görünür.
prefix_chars argümanı¶
Genellikle komut satırı uygulamalrında argümanlar - ön ekini alır. (Örnek : -f / –arguman) Ayrıştırıcımız bazı durumlarda farklı veya ek ön eklere ihtiyaç duyabilir. Örneğin: +f veya /arguman ArgumentParser nesnemizi oluştururken prefix_chars argümanını kullanarak bu isteğimizi sağlarız. Örnek Kod:
import argparse
ayristirici = argparse.ArgumentParser(prefix_chars='-+')
ayristirici.add_argument('+f')
ayristirici.add_argument('++arguman')
ayristirici.print_help()
Çıktımız:
usage: ilkprogram.py [-h] [+f F] [++arguman ARGUMAN]
optional arguments:
-h, --help show this help message and exit
+f F
++arguman ARGUMAN
fromfile_prefix_chars argümanı¶
Bazı zamanlar örneğin uzun argüman listelerini içeren bir uygulama yazdığımız zaman, argümanları komut satırında yazmak yerine bir dosya içerisinde tutmak daha mantıklı olur. ArgumentParser nesnesine fromfile_prefix_chars argümanı verildiği zaman daha sonra belirtilen karakterlerden herhangi biriyle başlayan argümanlar dosya olarak kabul edilir ve içerdikleri argümanlar ile değiştirilir. Kodumuzu yazalım:
import argparse
with open('args.txt', 'w') as fp:
fp.write('-i\nbar')
ayristirici = argparse.ArgumentParser(fromfile_prefix_chars='@')
ayristirici.add_argument('-i')
print(ayristirici.parse_args(['@args.txt']))
Kodumuzu satır satır inceleyelim.
with open(… satırında args.txt dosyasını w modunda açıyoruz.
fp.write… satırında i argümanını ekliyoruz ve i argümanına bar parametresini dosyamıza yazıyoruz.
Üçüncü satırımızda ayristirici nesnemizi oluşturuyoruz.
Ardından i argümanını ekliyoruz.
Bu satırda parse_args komutu ile argümanımızı ve alacağı değerini döndürüyoruz.
Bir dosyadan okunan argümanlar varsayılan olarak her satırda bir tane olmalı ve komut satırındaki orijinal dosya başvuru argümanı ile aynı yerdeymiş gibi ele alınmalıdır. Bu nedenle örnekte, [‘@args.txt’] ifadesi [‘-i’, ‘bar’] ifadesine eşdeğer olarak kabul edilir.
argument_default argümanı¶
Genellikle, argüman varsayılanları, varsayılan olarak add_argument() fonksiyonu veya belirli bir ad-değer çiftleri kümesiyle set_defaults() fonksiyonunun çağrılmasıyla belirlenir. Ancak bazı durumlarda bağımsız değişkenler için tek bir ayrıştırıcıyı varsayılan olarak belirlemek yararlı olablir. Örneğin parse_args() çağrıldığında, nitelik oluşturmayı global olarak bastırmak için argument_default=SUPPRESS’i kullanırız. Örnek Kod:
import argparse
ayristirici = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
ayristirici.add_argument('--arguman')
ayristirici.add_argument('-ikinci_arguman')
print(ayristirici.parse_args(['--arguman', '1', '-ikinci_arguman', 'python']))
print(ayristirici.parse_args([]))
Çıktımız:
Namespace(arguman='1', ikinci_arguman='python')
Namespace()
Çıktımıza baktığımız zaman parse_args() fonksiyonuna değer verildiğinde bize ad alanı (namespace) olarak argümanımızı ve aldığı değeri döndürüyor. İlk ad alanımız istediğimiz gibi çıktıyı verdi ikincisi ise boş şimdi argument_default=argparse.SUPPRESS’i kaldıralım ve çıktıyı tekrar kontrol edelim.
Yeni Çıktımız:
Namespace(arguman='1', ikinci_arguman='python')
Namespace(arguman=None, ikinci_arguman=None)
Görüldüğü üzere ikinci çıktımız bu sefer argümanın isimlerini ve değerlerini verdi ancak değerleri olmadığı için None olarak döndü.
allow_abbrev argümanı¶
Normal şartlarda parse_args() fonksiyonuna argüman listesi verdiğiniz zaman uzun seçeneklerin kısaltmalarını kabul eder. Eğer bu özelliği devre dışı bırakmak isterseniz allow_abbrev=False şeklinde kullanabilirsiniz.
Örnek Kod:
import argparse
ayristirici = argparse.ArgumentParser(allow_abbrev=True)
ayristirici.add_argument('--foobar')
ayristirici.add_argument('--foonley')
print(ayristirici.parse_args(['--foon', 'Argüman Değeri']))
Bu kodumuzda allow_abbrev değeri True çıktımıza baktığımız zaman:
Namespace(foobar=None, foonley='Argüman Değeri')
parse_args() fonksiyonuna –foon değeri vermemize rağmen Python devamını tamamladı ve –foonley argümanına değeri atadı şimdi allow_abbrev değerini False yapalım.
Çıktımız:
usage: ilkprogram.py [-h] [--foobar FOOBAR] [--foonley FOONLEY]
ilkprogram.py: error: unrecognized arguments: --foon Argüman Değeri
Görüldüğü üzere ilkprogram.py: error: unrecognized arguments hatası verdi. Bu hatanın sebebi kısaltma olarak verdiğimiz argümanı Python tanımadı.
conflict_handler argümanı¶
ArgumentParser nesnesi varsayılan olarak aynı argümanların kullanımına izin vermez. Eğer aynı argümanları kullanmaya denerseniz hata verecektir. Örnek:
import argparse
ayristirici= argparse.ArgumentParser()
ayristirici.add_argument('-i', '--ilk_argüman', help='eski argümanın yardım metni')
ayristirici.add_argument('--ilk_argüman', help='yeni argümanın yardım metni')
Çıktımız:
Traceback (most recent call last):
...
raise ArgumentError(action, message % conflict_string)
argparse.ArgumentError: argument --ilk_argüman: conflicting option string: --ilk_argüman
İki argüman aynı olduğu için uygulamamız hata verdi. Bazen (örneğin parents argümanını kullandığımız zaman) Aynı argümanların eskisini geçersiz kılmak (üstüne yazmak) kullanışlı olablir. Bu özelliği kullanmak için conflict_handler argümanına resolve değerini veriyoruz. Örnek:
import argparse
ayristirici = argparse.ArgumentParser(conflict_handler='resolve')
ayristirici.add_argument('-i', '--ilk_argüman', help='eski argümanın yardım metni')
ayristirici.add_argument('--ilk_argüman', help='yeni argümanın yardım metni')
print(ayristirici.print_help())
Çıktımız:
usage: ilkprogram.py [-h] [-i ILK_ARGÜMAN] [--ilk_argüman ILK_ARGÜMAN]
optional arguments:
-h, --help show this help message and exit
-i ILK_ARGÜMAN eski argümanın yardım metni
--ilk_argüman ILK_ARGÜMAN
yeni argümanın yardım metni
NOT:`ArgumentParser` nesnesi yalnızca yeni verilen argümanın üzerine yazılır. Eğer eski argüman birden farklı seçeneği varsa (`-i/–ilk_argüman` gibi) yeni eklediğiniz hangi argüman ise onun üzerine yazılır. Çıktımıza baktığımız zaman sadece `–ilk_argüman` üzerine yazıldı `-i` argümanının üzerine yazılma olmadı.
add_help argümanı¶
ArgumentParser nesnesi varsayılan olarak ayrıştırıcıların yardım mesajlarını sade şekilde ekrana yazdırır. Örnek kodumuzu bir metin dosyasına yazıp ardından, terminalde dosyamızın bulunduğu dizinde terminalimizde python3 ilkprogram.py -h şeklinde komutunu çalıştıralım:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('-i', help='Yardım metni')
ayristirici.parse_args()
Çıktımız:
usage: ilkprogram.py [-h] [-i I]
optional arguments:
-h, --help show this help message and exit
-i I Yardım metni
Görüldüğü üzere argümanlarımız hakkında basitçe bir yardim belgesi ekrana çıktı. Bazı durumlarda yardım metinlerini devre dışı bırakmak isteyebiliriz. Bu durumda add_help argümanına False değerini veririz. Az önce yazdığımız kodu bu şekilde değiştirip terminalden tekrar çalıştıralım.:
import argparse
ayristirici = argparse.ArgumentParser(add_help=False)
ayristirici.add_argument('-i', help='Yardım metni')
ayristirici.parse_args()
Çıktımız:
usage: ilkprogram.py [-i I]
ilkprogram.py: error: unrecognized arguments: -h
Artık yardım metni yok.
Yardım seçeneği genellikle `-h / –help`’dir. Bunun istisnası, eğer `prefix_chars` argümanı kullanılmışsa ve `-` içermezse, bu durumda `-h / –help` geçerli değildir. Bu durumda, prefix_chars içindeki ilk karakter yardım seçeneklerini ön ek olarak kullanılır:
Örnek:
import argparse
ayristirici = argparse.ArgumentParser(prefix_chars='+/')
ayristirici.print_help()
Çıktı:
usage: ilkprogram.py [+h]
optional arguments:
+h, ++help show this help message and exit
add_argument() Fonksiyonu¶
ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])
Parametreler ve açıklamaları¶
name veya flags: İsim veya seçenek tanımlamak için oluşturulan dizi. Örnek: -s, –sil veya sil.
action: Komut satırında rastlanırsa yapılacak eylem.
nargs: Kullanılması gereken komut satırı argümanlarının sayısı.
const: Bazı eylem ve nargs seçeneklerinin seçimlerinin gerektirdiği sabit bir değer.
default: Komut satırında argüman bulunmazsa varsayılan değer.
type: Argümanın dönüştürüleceği değer türü.
choices: Argümanlar için izin verilen değerlerin bir aralığı ayarlar.
required: Argümanın ihmal edilip edilmeyeceği için kullanılır. (yalnızca isteğe bağlı)
help: Argümanın yaptığı hakkında açıklama.
metavar: Kullanım mesajlarındaki argüman için bir isim.
dest: parse_args() tarafından döndürülen nesneye eklenecek niteliğin adı.
name veya flags (isim veya bayrak)¶
Add_argument() fonksiyonu , -f veya –foo gibi isteğe bağlı bir argüman mı yoksa konumsal bir argüman mı olduğunu bilmesi gerekir. Add_argument() fonksiyonuna iletilen ilk argümanlar bu nedenle bir dizi bayrak veya basit bir argüman adı olmalıdır. Örneğin isteğe bağlı argüman eklemek için:
parser.add_argument('-f', '--foo')
Eğer konumsal argüman eklemek istersek:
parser.add_argument('bar')
Bu şekilde ekleyebiliriz.
Parse_args() fobksiyonu çağrıldığında, isteğe bağlı argümanlar - ön eki tarafından tanımlanır ve kalan argümanların konumsal olduğu varsayılır: Kodları yazalım.:
import argparse
ayristirici = argparse.ArgumentParser(prog='PROG')
ayristirici.add_argument('-f', '--foo')
ayristirici.add_argument('bar')
print(ayristirici.parse_args(['BAR']))
print(ayristirici.parse_args(['BAR', '--foo', 'FOO']))
print(ayristirici.parse_args(['--foo', 'FOO']))
Çıktımız:
Namespace(bar='BAR', foo=None)
Namespace(bar='BAR', foo='FOO')
usage: PROG [-h] [-f FOO] bar
PROG: error: the following arguments are required: bar
Çıktımıza baktığımız zaman bar argümanı konumsal olduğu için ve son parse_args() fonksiyonunda kullanmadığımız için uygulamamız hata verdi.
action¶
ArgumentParser nesnesi,argüman eylemleri ile ilişkilendirir. Bu eylemler, kendisiyle ilişkilendirilmiş komut satırı argümanları ile hemen hemen her şeyi yapabilir, ancak çoğu eylem yalnızca parse_args() fonksiyonunun döndürdüğü nesneye bir nitelik ekler. Action anahtar sözcüğü argümanı, komut satırı argümanlarının nasıl ele alınması gerektiğini belirtir. Bazı sağlanan eylemler:
store - Bu sadece argümanın değerini saklar. Bu varsayılan eylemdir. Örneğin:
import argparse ayristirici = argparse.ArgumentParser() ayristirici.add_argument('--arguman') print(ayristirici.parse_args('--arguman 1'.split()))
Çıktımız:
Namespace(arguman='1')
store_const - const anahtar sözcüğü argümanı tarafından belirtilen değeri saklar. store_const eylemi, genellikle bir tür bayrak belirten isteğe bağlı değişkenlerle birlikte kullanılır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--arguman', action='store_const', const=42)
print(ayristirici.parse_args(['--arguman']))
Çıktımız:
Namespace(arguman=42)
store_true ve store_false - Bunlar, sırasıyla True ve False değerlerini depolamak için kullanılan store_cost durumlarıdır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--arguman', action='store_true')
ayristirici.add_argument('-i', action='store_false')
ayristirici.add_argument('-y', action='store_false')
print(ayristirici.parse_args('--arguman -i'.split()))
Çıktımız:
Namespace(arguman=True, i=False, y=True)
append - Liste saklar ve her argüman değerini listeye ekler. Bir seçeneğin birden çok kez belirtilmesine izin vermek için kullanışlıdır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--arguman', action='append')
print(ayristirici.parse_args('--arguman 1 --arguman 2'.split()))
Çıktımız:
Namespace(arguman=['1', '2'])
append_const - Bir listeyi depolar ve const anahtar sözcüğü argümanı tarafından belirtilen değeri listeye ekler. ( const anahtar sözcüğü argümanı varsayılan olarak None`dır) `append_const genellikle birden fazla argüman sabitlerini aynı listeye kaydetmesi gerektiğinde kullanışlıdır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--str', dest='types', action='append_const', const=str)
ayristirici.add_argument('--dict', dest='types', action='append_const', const=dict)
print(ayristirici.parse_args('--str --dict'.split()))
Çıktımız:
Namespace(types=[<class 'str'>, <class 'dict'>])
count - Anahtar kelime argümanının kullanılma sayısını sayar. Bu ayrıntı düzeylerini artırmak için kullanışlıdır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--say', '-s', action='count')
print(ayristirici.parse_args(['-sss']))
Çıktımız:
Namespace(say=3)
help - Geçerli ayrıştırıcıdaki tüm seçenekler için eksiksiz yardım mesajı yazdırır ve sonra uygulama sonlanır.
version - Sürüm bilgisi yazdırır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser(prog='PROG')
ayristirici.add_argument('--v', action='version', version='%(prog)s 2.0')
print(ayristirici.parse_args(['--v']))
Çıktımız:
PROG 2.0
nargs¶
ArgumentParser nesnesi her argümanı tek bir işlem ile ilişkilendirir. nargs anahtar sözcüğü bir argümanı farklı sayıda argümanı tek bir işlem ile ilişkilendirir.
N (tam sayı) - N argümanları komut satırından bir liste halinde alınır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', nargs=3)
ayristirici.add_argument('bar', nargs=1)
print(ayristirici.parse_args('c --foo a b d'.split()))
Çıktımız:
Namespace(bar=['c'], foo=['a', 'b', 'd'])
nargs=1 bir adet liste elemanı listeler. Bu varsayılan değerden farklıdır
? Komut satırından bir argüman alınacak ve tek bir öğe olarak üretilecektir. Eğer komut satırında argüman yoksa, varsayılan değer üretilir.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', nargs='?', const='c', default='d')
ayristirici.add_argument('-b', nargs='?', default='d')
print(ayristirici.parse_args(['-b', '--foo', 'YY']))
print(ayristirici.parse_args(['-b', '--foo']))
print(ayristirici.parse_args([]))
Çıktımız:
Namespace(b=None, foo='YY')
Namespace(b=None, foo='c')
Namespace(b='d', foo='d')
nargs=’?’ bir kullanım alanı daha vardır. Bu alan isteğe bağlı dosya girdi ve çıktılarıdır. Python Etkileşimli Kabuğumuzda Kodumuzu Yazalım:
import argparse
import sys
parser = argparse.ArgumentParser()
parser.add_argument('infile', nargs='?', type=argparse.FileType('r'),
default=sys.stdin)
parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'),
default=sys.stdout)
parser.parse_args(['input.txt', 'output.txt'])
parser.parse_args([])
Çıktımız:
Namespace(infile=<_io.TextIOWrapper name='input.txt' encoding='UTF-8'>,
outfile=<_io.TextIOWrapper name='output.txt' encoding='UTF-8'>)
Namespace(infile=<_io.TextIOWrapper name='<stdin>' encoding='UTF-8'>,
outfile=<_io.TextIOWrapper name='<stdout>' encoding='UTF-8'>)
* - Mevcut tüm komut satırı argümanları bir liste halinde toplanır. Genel olarak nargs=’*’ ile birden fazla konumsal argüman almanın bir anlamı olmadığını unutmayın. Ancak birden fazla isteğe bağlı argümanı nargs=’*’ ile almak mümkündür.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', nargs='*')
ayristirici.add_argument('--bar', nargs='*')
ayristirici.add_argument('baz', nargs='*')
print(ayristirici.parse_args('a b --foo x y --bar 1 2'.split()))
Çıktımız:
Namespace(bar=['1', '2'], baz=['a', 'b'], foo=['x', 'y'])
Çıktımızı incelediğimiz zaman baz bizim konumsal argümanımızdır diğerleri ise isteğe bağlı argümandır. Eğer baz argümanından nargs=’*’ kaldırırsak:
usage: ilkprogram.py [-h] [--foo [FOO [FOO ...]]] [--bar [BAR [BAR ...]]] baz
ilkprogram.py: error: unrecognized arguments: b
Şeklinde hata verir.
+ - * gibi davranır. Mevcut tüm komut satırı argümanları bir liste halinde toplanır. Ayrıca, en az bir komut satırı argümanı yoksa, bir hata mesajı oluşturulur.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser(prog='PROG')
ayristirici.add_argument('foo', nargs='+')
print(ayristirici.parse_args(['a', 'b']))
print(ayristirici.parse_args([]))
Çıktımız:
Namespace(foo=['a', 'b'])
usage: PROG [-h] foo [foo ...]
PROG: error: the following arguments are required: foo
Çıktımıza baktığımız zaman parse_args() fonksiyonuna liste halinde değer gönderince bize ad alanını döndürüyor. Ancak boş bir liste gönderince hata veriyor.
argparse.REMAINDER - Kalan tüm komut satırı argümanları bir liste halinde toplanır. Diğer komut satırı yardımcılarını gönderilen komut satırı yardımcıları için kullanışlıdır.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser(prog='PROG')
ayristirici.add_argument('--foo')
ayristirici.add_argument('command')
ayristirici.add_argument('args', nargs=argparse.REMAINDER)
print(ayristirici.parse_args('--foo B cmd --arg1 XX ZZ'.split()))
Çıktımız:
Namespace(args=['--arg1', 'XX', 'ZZ'], command='cmd', foo='B')
Eğer nargs anahtar sözcüğü sağlanmazsa, kullanılan argümanların sayısı action tarafından belirlenir. Genellikle bu, tek bir komut satırı argümanının kullanılacağı ve tek bir öğenin üretileceği anlamına gelir.
const¶
‘const` argümanı komut satırından okunamayan ancak ‘ArgumentParser()` için gerekli sabit değerleri tutar. En yaygın iki kullanımı vardır.
add_argument() fonksiyonu action=’store_const’ veya action=’append_cost’ ile çağrıldığı zaman bu iki eylem const değerini parse_args() tarafından döndürülen nesnenin niteliklerine ekler.
add_argument() fonksiyonu isteğe bağlı karakter dizisi (-f veya –foo gibi) ve nargs=’?’ ile çağrıldığı zaman sıfır veya bir komut satırı argümanı tarafından takip edilebilecek isteğe bağlı argüman oluşturur. Komut satırı argümanları ayrıştırılırken isteğe bağlı seçenek dizesi bağımsız değişken ile karşılaşmazsa const değeri kabul edilir.
default¶
Tüm isteğe bağlı argümanlar ve bazı konumsal argümanlar komut satırında bazen atlanabilir. default anahtar sözcüğü argümanı ile eğer argüman değer almazsa varsayılan bir değer atanabilir. Varsayılan olarak default None değerine sahiptir. Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', default=42)
print(ayristirici.parse_args(['--foo', '2']))
print(ayristirici.parse_args([]))
Çıktımız:
Namespace(foo='2')
Namespace(foo=42)
İlk parse_args() fonksiyonunda değer atadığımız için foo argümanının yeni değeri ‘2’ oluyor ancak ikinci parse_args() fonksiyonunda değer olmadığı için varsayılan değerimiz 42 ekrana çıkıyor. default değeri karakter dizisi (string) ise ayrıştırıcı değeri argüman gibi ayırır. Eğer değerin tipi değiştirilmek istenirse type kullanılır. Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', default=42, type=int)
print(ayristirici.parse_args(['--foo', '2']))
print(ayristirici.parse_args([]))
Çıktımız:
Namespace(foo=2)
Namespace(foo=42)
Görüldüğü üzere ilk değerimiz karakter dizisi yerine artık tam sayı (int) oldu.
type¶
ArgumentParser() nesnesi varsayılan olarak komut satırından okuduğu değerleri karakter dizisi (string) olarak alır. Bazı durumlarda farklı tiplerde değişkenlere ihtiyaç duyarız. Bunun için type kullanılır. Şimdi uygulamamızı çalıştırdığımız dizine args.txt dosyası oluşturalım ve kodumuzu çalıştıralım. Kod:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici .add_argument('foo', type=int)
ayristirici .add_argument('bar', type=open)
print(ayristirici .parse_args('2 args.txt'.split()))
Çıktımız:
Namespace(bar=<_io.TextIOWrapper name='args.txt' mode='r' encoding='UTF-8'>, foo=2)
Çıktıya baktığımız zaman bar argümanının dosya hakkında bilgiler içeren bir takım detaylar var ve foo ise tam sayı değerine sahip.
choices¶
Bazen argümanlar belirli değerler ile sınırlandırmak gerekir. Bu durumda choices kullanılır. Eğer kullanıcı geçerli argüman verdiyse uygulama devam edeğer ancak verilen argüman geçersiz ise hata mesajı döner.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('oyun', choices=['tas', 'kagit', 'makas'])
print(ayristirici.parse_args(['kagit']))
print(ayristirici.parse_args(['ates']))
Çıktı:
Namespace(oyun='kagit')
usage: ilkprogram.py [-h] {tas,kagit,makas}
ilkprogram.py: error: argument oyun: invalid choice: 'ates' (choose from 'tas', 'kagit', 'makas')
Çıktımıza baktığımız zaman ilk argümanımız geçerli olduğu için bir hata almadık. Ancak ikinci argümanımız geçersiz olduğundan dolayı uygulamamız bize geçerli argümanlar arasında seçim yapmamızı söylüyor.
required¶
argparse modülü genellikle -f veya –foo gibi isteğe bağlı seçimler ile çalışır ancak bazı durumlarda zorunlu argümanlar vermek gerekebilir. Böyle durumlarda required=True kullanılır.
Örnek Kod:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', required=True)
print(ayristirici.parse_args(['--foo', 'Degisken']))
print(ayristirici.parse_args([]))
Çıktımız:
Namespace(foo='Degisken')
usage: ilkprogram.py [-h] --foo FOO
ilkprogram.py: error: the following arguments are required: --foo
Çıktımızı incelediğimiz zaman bir değişken atadığımız için uygulama hatasız çalıştı ancak ikincisinde değişken olmadığı için hata verdi.
NOT:Zorunlu seçimler genellikle kötü form olarak kabul edilir. Çünkü bu parametreler özünde isteğe bağlıdır ve kullanıcılar isteğe bağlı olmasını ister. Mümkün olduğunca kullanmamak gerekir.
help¶
help değeri karakter dizisi olarak değer alır ve bu değer argümanlar hakkında yardım metinleri içerir. Kullanıcı yardım istediğinde bulununca (genellikle -h veya –help) yardım metinleri görünür.
Örnek Kod:
import argparse
ayristirici= argparse.ArgumentParser()
ayristirici.add_argument('--foo', help='foo için yardım metni')
ayristirici.add_argument('bar', help='bar için yardım metni')
print(ayristirici.parse_args(['-h']))
Çıktımız:
usage: ilkprogram.py [-h] [--foo FOO] bar
positional arguments:
bar bar için yardım metni
optional arguments:
-h, --help show this help message and exit
--foo FOO foo için yardım metni
help çeşitli formatlama yöntemlerini içerir. Bu sayede değerlerinizi farklı yerlerde kullanabilirsiniz. Örnek:
import argparse
ayristirici = argparse.ArgumentParser(prog='merhaba dünya')
ayristirici.add_argument('bar', default=42,
help='bar argümanı için yardım metni ayrıca bu uygulamannın adı: %(prog)s (varsayılan değeri: %('
'default)s)')
print(ayristirici.print_help())
Çıktımız:
usage: merhaba dünya [-h] bar
positional arguments:
bar bar argümanı için yardım metni ayrıca bu uygulamannın adı:
merhaba dünya (varsayılan değeri: 42)
optional arguments:
-h, --help show this help message and exit
Görüldüğü üzere uygulamamızın adı ve varsayılan değerimiz ekrana basıldı.
metavar¶
ArgumentParser() nesnesi yardım metinlerini oluşturduğu zaman, beklenen her argümana atıfta bulunmak için bir yola ihtiyaç duyar. Varsayılan olarak ArgumentParser() nesnesi dest değerini her nesnenin “ismi” olarak kullanır. Varsayılan olarak, konumsal argüman eylemleri için dest değeri doğrudan kullanılır ve isteğe bağlı argüman eylemleri için dest değeri büyük harfe dönüştürülür. Örnek Kod:
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--foo')
parser.add_argument('bar')
print(parser.parse_args('X --foo Y'.split()))
print(parser.print_help())
Çıktımız:
Namespace(bar='X', foo='Y')
usage: ilkprogram.py [-h] [--foo FOO] bar
positional arguments:
bar
optional arguments:
-h, --help show this help message and exit
--foo FOO
Ayrıca metavar alternatif isim belirtebilir.
Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', metavar='YYY')
ayristirici.add_argument('bar', metavar='XXX')
print(ayristirici.print_help())
Çıktımız:
usage: ilkprogram.py [-h] [--foo YYY] XXX
positional arguments:
XXX
optional arguments:
-h, --help show this help message and exit
--foo YYY
Konumsal argümanımızın ismi metavar ile değişti.
NOT:`metavar` yalnızca ekran ismini değiştirir, `parse_args()` ile kontrol ettiğiniz zaman `dest` değerini kullandığını görebilirsiniz.
dest¶
dest ile argümanlara kişiselleştirilmiş isimler verebilirsiniz. Örnek:
import argparse
ayristirici = argparse.ArgumentParser()
ayristirici.add_argument('--foo', dest='bar')
print(ayristirici.parse_args('--foo XXX'.split()))
Çıktımız:
Namespace(bar='XXX')
Bu yardım sayfası https://docs.python.org/3/library/argparse.html referans alınarak hazırlanmıştır.
Önemli Not
Sorularınızı yorumlarda dile getirmek yerine Yazbel Forumunda sorarsanız çok daha hızlı cevap alabilirsiniz.Belgelerdeki bir hata veya eksiği dile getirecekseniz lütfen yorumları kullanmak yerine Github'da bir konu (issue) açın.
Eğer yazdığınız yorum içinde kod kullanacaksanız kodlarınızı <pre><code> etiketleri içine alın. Örneğin:
<pre><code class="python">
print("Merhaba Dünya!")
</code></pre>
