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 ayristiri.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.

Yorumlar

Önemli Not

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>