Fonksiyonlar: Parametre eşleştirme

Python fonksiyonlarını çağırırken parametreleri konumlarıyla veya isimlerle eşleştirebilirsiniz. Ayrıca belirsiz sayıda parametre kullanabilirsiniz. Bu parametrelere fonksiyon içinde bir çokuz veya bir sözlük ile erişebilirsiniz.

Parametre eşleştirmenin en basit hali, konumla eşleştirmedir.

>>> def f(a,b,c):
    print a,b,c

>>> f(7,-2,5)
7 -2 5

Bu fonksiyonda birinci parametre a, birinci konumdaki değer olan 7’ye, ikinci parametre b ikini konumda olan -2’ye, üçüncü parametre c ise üçüncü konumdaki 5’e eşleştiriliyor. Başka bir yol olarak, değerleri değişken isimleriyle de eşleştirebilirsiniz. O zaman konum sırası önemli olmaz.

>>> f(c=5, b=-2, a=7)
7 -2 5

Konuma ve isme göre eşleştirmelerin karıştırıldığı melezlemeler de yapılabilir. Bu durumda, önce soldan sağa kadar konumsal eşleştirmeler yapılır, sonra isimler eşleştirilir.

>>> f(7, c=5, b=-2)
7 -2 5

Bir parametre konuma göre eşleştirilmişse, ayrıca isimle eşleştirmek hata oluşturur.

>>> f(7, 5, b=-2)
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    f(7, 5, b=-2)
TypeError: f() got multiple values for keyword argument 'b'

Önce konumsal eşleştirme yapıldığı için, isim eşleştirmesinden sonra isimsiz bir parametre verilemez.

>>> f(a=7, b=-2, 5)
SyntaxError: non-keyword arg after keyword arg

İsim eşleştirmeleri kodu daha açık ve anlaşılır kılar. Bir fonksiyon çağrısının ne yaptığını anlamak kolaylaşır. Ayrıca parametrelerin ne sırada verildiğini hatırlamamıza gerek kalmaz.

>>> gezegen_ekle( isim="Mars", kutle=0.7, yaricap=0.6, uydu=("Phobos","Deimos") )

Fonksiyonu tanımlarken parametrelerine varsayılan değerler atamak mümkündür. Fonksiyon çağrısında bir parametreye değer verilmezse, varsayılan değeri kullanılır.

>>> def f(a, b=2, c=3):
    print a,b,c

Bu fonksiyonu çağırırken a için bir değer vermek zorundayız, ama b ve c için varsayılan değerler kullanılabilir.

>>> f(1)    # b ve c varsayılan değerde
1 2 3
>>> f(a=4)  # b ve c varsayılan değerde
4 2 3
>>> f(1,7)  # c varsayılan değerde
1 7 3
>>> f(1,65,89)    # hepsine yeni değer
1 65 89
>>> f(1,c=8)   # b varsayılan değerde
1 2 8

Python fonksiyonlarının kaç tane parametre alacağını önceden belirtmek zorunda da değilsiniz. Fonksiyon tanımını aşağıdaki gibi yaparak bütün konumsal parametrelerin bir çokuza toplanmasını sağlayabilirsiniz.

>>> def f(*par):
    print par

>>> f()      # hiç parametre yok, boş çokuz.
()
>>> f(3)     # tek parametre, tekli çokuz.
(3,)
>>> f(45, 3-4j, "merhaba", [1,2,3])   # dörtlü çokuz
(45, (3-4j), 'merhaba', [1, 2, 3])

Fonksiyonun tanımında *par kullanmakla bütün parametrelerin bir çokuza toplanmasını sağladık. Bu çokuzun elementlerini tek tek alarak bütün parametrelere sırayla ulaşabiliriz. İstediğimiz kadar parametre kulanabiliriz.

Ama parametre ismi kullanmak istersek yukarıdaki fonksiyon doğru çalışmaz.

>>> f(a=4)
Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    f(a=4)
TypeError: f() got an unexpected keyword argument 'a'

Fonksiyon tanımında çift yıldız kullanarak, isimlerle verilmiş bir parametre listesinin bir sözlüğe toplanmasını sağlayabiliriz.

>>> def g(**par):
    print par

>>> g()
{}
>>> g(a=1, b=4)
{'a': 1, 'b': 4}

Böylece değişken isimlerine ve değerlerine, yukarıdaki tanımda par adını verdiğimiz bir sözlük aracılığıyla erişebiliriz. (Elbette par ismini kullanmak zorunda değilsiniz). Buradaki esnekliğe dikkat edin: Parametre isimleri a ve b fonksiyon tanımlanırken ortada yoktu, fonksiyon çağrısıyla beraber tanımlandılar.

Ama yukarıdaki g fonksiyonu da sadece isimlendirilmiş parametrelerle çalışır, isimsiz (konuma dayalı) parametrelerde hata mesajı verir. Daha genel bir fonksiyon arayüzü şöyle yazılabilir:

>>> def f( *pargs, **kwargs ):
    print pargs    # konum eşleştirmeli parametreler
    print kwargs   # isim eşleştirmeli parametreler

>>> f()   
()
{}
>>> f(1, [3,4], isim = "sarman", kilo = 6.5)
(1, [3, 4])
{'isim': 'sarman', 'kilo': 6.5}

Bu fonksiyon hem konum hem de isim eşleştirmeli parametrelerle çalışabilir. Birçok hazır kütüphanede, böyle genel bir arayüzle tanımlanmış fonksiyonlar bulunur.

---

Yukarıdaki örneklerde, fonksiyonu tanımlarken kullandığımız *par yazımı, parametrleri çokuz haline getiriyordu. Tersini de yapmak mümkün: Fonksiyonu çağırırken bir çokuzdan parametreler çıkartabiliriz.

>>> def f(a,b,c,d):
    print a,b,c,d

>>> x = (4.1, -8, "merhaba", (1,2))
>>> f(x)
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    f(x)
TypeError: f() takes exactly 4 arguments (1 given)
>>> f(*x)
4.1 -8 merhaba (1, 2)

Burada dört parametre isteyen bir fonksiyonumuz var. Vereceğimiz parametreler x isimli bir çokuzda toplanmış. x‘i doğrudan fonksiyona vererek f(x) çağrısı yapmak hataya yol açıyor çünkü dört yerine bir parametre veriyoruz. Bunun yerine f(*x) yazımı kullanmak x‘in elemanlarının konumsal eşleşmeyle parametre olarak verilmesini sağlıyor. Bu işleme “argument unpacking” deniyor (belki “parametre çözme” diyebiliriz).

Eğer parametreler başta elinizde hazır değilse ama program ilerledikçe elde ediyor ve bir çokuza yazıyorsanız, bu notasyon kullanışlı olacaktır.

>>> x = (1,2)
>>> x = x + (3,4)   # Toplama işlemi çokuzları birleştirir
>>> x
(1, 2, 3, 4)
>>> f(*x)
1 2 3 4

Parametreler çokuz harici başka bir sıralı veri tipinde (liste, dize) saklanıyorsa da aynı işlem geçerli olur.

>>> f(*[1,2,3,4])
1 2 3 4
>>> f(*"xyzt")
x y z t

İsim eşleştirmesi yapmak istersek aynı amaç için bir sözlük oluşturmamız ve “**” kullanmamız gerek.

>>> D = {'b':-3, 'd':1+2j, 'a':2, 'c':[1,2,3]}
>>> f(**D)
2 -3 [1, 2, 3] (1+2j)

İki yaklaşımı birleştirmek de mümkün:

>>> f( *(1,4), **{'c':"merhaba", 'd':[19, 20]} )
1 4 merhaba [19, 20]