Bu dersteki bütün IPython Notebook'lar adresinde https://github.com/sinanonur/Python-Lectures mevcuttur ve bu adresteki içerik Türkçe'ye çevirilerek hazırlanmıştır. Bazı kısımlarda değişiklik yapılmıştır.

Fonksiyonlar¶

Çoğu zaman bir algoritmada tekrar eden ifadeler olacaktır ve bunu her seferinde yazmak oldukça zor olacaktır birsürü bellek harcayacaktır ve etkili olmayacaktır. Çözüm fonksiyonlarda.icient. Enter Functions.

Bir fonksiyonun söz dizimi aşşağıdaki gibidir:

def fonksiyonadi(arg1, arg2,... argN):

''' Document String'''

ifadeler(statements)


return <deger>

Yukarıdaki ifade şu şekilde okunaiblir; 'fonksiyonadi' isminde bir bir fonksiyon "arg1,arg2,....argN" parametrelerini alır ve dökümantasyonu '''Document String''' şeklindedir. Çalıştıktan sonra bir "deger" döndürür.

In [1]:

print "Selam!"
print "Naber?"

Selam!
Naber?

Yukarıdaki iki ifadeyi her seferinde yazmak yerine bir fonksiyon tanımlanaral aynı iş tek bir satırda yapabilir.

In [3]:

def ilk_fonksiyon():
    print "Selam!"
    print "Naber?"  

In [4]:

ilk_fonksiyon()

Selam!
Naber?

ilk_fonksiyon() her çalıştığında kullanıcıya sadece bu mesajı gösterir. ilk_fonksiyon()'a bir parametre ekleyerek bir isme hitap etmesini sağlayabiliriz. Parametre gösterildiği gibi eklenir:

In [8]:

def ilk_fonksiyon(isim):
    print "Selam", isim, '!'
    print "Naber", isim, '?'

In [6]:

isim1 = raw_input('Lütfen isminizi girin:')

Lütfen isminizi girin:Sinan

girdiğiniz isim isim1 içinde saklanır. Bu değişkeni ilk_fonksiyon() a argüman olarak verebiliriz.

In [9]:

ilk_fonksiyon(isim1)

Selam Sinan !
Naber Sinan ?

Kullanıcıdan bir isim alıp bunu ilk_fonksiyon()a parametre olarak gönderen diğer bir ikinci_fonksiyon() ekleyerek işleri daha basit hale getirebiliriz.

In [10]:

def ilk_fonksiyon(isim):
    print "Selam", isim, '!'
    print "Naber", isim, '?'
def ikinci_fonksiyon():
    isim = raw_input("Lütfen isminizi girin: ")
    ilk_fonksiyon(isim)

In [12]:

ikinci_fonksiyon()

Lütfen isminizi girin: Sinan
Selam Sinan !
Naber Sinan ?

Return ifadesi¶

Bir fonksiyon bir değer hesapladığında ve bu değer bir değişken içinde saklanması gerektiğinde bu değerin döndürülmesi gerekir. Bunun için return ifadesi kullanılır.

In [13]:

def carp(x,y):
    z = x*y
    return z

Yukarıda tanımlanan kere( ) fonksiyonu 2 argüman alarak sonuç olan z değişkeninin değerini döndürür.carp

In [14]:

c = carp(4,5)
print c

z değeri c değişkeninde saklanarak diğer işlemler için kullanılabilir.

Başka bir değişken tanımlamadan return ifadesi aşşağıdaki şekilde de yazılabilir.

In [17]:

def carp(x,y):
    '''iki argümanı birbiriyle çarpar'''
    return x*y

In [18]:

c = carp(4,5)
print c

carp( ) fonksiyonunu tanımladığımıza göre yukarıda görüldüğü gibi dökümante edebiliriz. carp( ) tanımlı olduğuna göre artık help( ) kullanarak dökümantasyonu görüntüleyebiliriz.

In [20]:

help(carp)

Help on function carp in module __main__:

carp(x, y)
    iki argümanı birbiriyle çarpar

Birden fazla değişken de döndürülebilir fakat sırasına dikkat edin.

In [27]:

liste = [10,50,30,12,6,8,100]

In [25]:

def egfunc(liste):
    en_cok = max(liste)
    en_az = min(liste)
    ilk = eglist[0]
    son = eglist[-1]
    return en_cok,en_az,ilk,son

Eğer fonksiyonun dönen değeri bir değişkene atanmamışsa bir tuple şeklinde döner. Fakat değişkenler kullanılırsa döndürme sırasına göre değişkenlere değerler atanır.

In [28]:

egfunc(liste)

Out[28]:

(100, 6, 10, 100)

In [29]:

a,b,c,d = egfunc(liste)
print ' a =',a,'\n b =',b,'\n c =',c,'\n d =',d

 a = 100 
 b = 6 
 c = 10 
 d = 100

Dahili argümanlar¶

Eğer bir fonksiyonun bir argümanı çoğu durum için aynıysa dahili (implicit) argüman kullanılır.

In [31]:

def dahili_ekle(x,y=3):
    return x+y

dahili_ekle( ) iki argüman alan bir fonksiyondur. Fakat çoğu zaman ilk argümana sadece 3 eklenecektir bu yüzden 3 dahili argümandır.

Eğer fonksiyon çağrılırken ikinci argüman belirtilmemişse 3 olduğu varsayılır.

In [32]:

dahili_ekle(4)

Out[32]:

Fakat ikinci argüman verilirse dahili değerin üstüne yazar.

In [33]:

dahili_ekle(4,4)

Out[33]:

Sınırsız sayıda argüman¶

Eğer bir fonksiyon tarafından kabul edilecek parametrelerin sayısı tam olarak bilinmiyorsa argümandan önce yıldız sembolü koyulur.

In [35]:

def n_ekle(*args):
    sonuc = 0
    sonuc_liste = []
    for i in args:
        sonuc_liste.append(i)
    print sonuc_liste
    return sum(sonuc_liste)

Yukarıdaki fonksiyon her sayıda argüman kabul eder, bir liste oluşturur ve bunların toplamını döndürür.

In [36]:

n_ekle(1,2,3,4,5)

[1, 2, 3, 4, 5]

Out[36]:

In [37]:

n_ekle(1,2,3)

[1, 2, 3]

Out[37]:

Global and Lokal değişkenler¶

Eğer bir değişken bir fonksiyon içinde tanımlanmışsa yerel değişken, dışında tanımlanmışsa global değişkendir.

In [39]:

o1 = [1,2,3,4,5]

Aşşağıdaki örnekte fonksiyonun içerisinde bir listeye bir eleman ekliyoruz. fonksiyonun içinde tanımlanan o2 lokaa değişkendir.

In [48]:

def ornek_fonksiyon():
    def ucuncu_fonksiyon(arg1):
        o2 = arg1[:]
        o2.append(6)
        print "Bu fonksiyonun içinde oluyor:", o2 
    print "Bu fonksiyonçağırılmadan oluyor: ", o1
    ucuncu_fonksiyon(o1)
    print "Bu fonksiyonun dışında oluyor :", o1   
    print "İçeride tanımlanmış bir değişkene dışarıdan erişmeye çalışmak :" , o2

In [41]:

ornek_fonksiyon()

Bu fonksiyonçağırılmadan oluyor:  [1, 2, 3, 4, 5]
Bu fonksiyonun içinde oluyor: [1, 2, 3, 4, 5, 6]
Bu fonksiyonun dışında oluyor : [1, 2, 3, 4, 5]
İçeride tanımlanmış bir değişkene dışarıdan erişmeye çalışmak :

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-41-f9681853e4a8> in <module>()
----> 1 ornek_fonksiyon()

<ipython-input-40-e382e4cafe79> in ornek_fonksiyon()
      7     ucuncu_fonksiyon(o1)
      8     print "Bu fonksiyonun dışında oluyor :", o1
----> 9     print "İçeride tanımlanmış bir değişkene dışarıdan erişmeye çalışmak :" , o2

NameError: global name 'o2' is not defined

If a global variable is defined as shown in the example below then that variable can be called from anywhere.

In [45]:

o3 = [1,2,3,4,5]

In [47]:

def ornek_fonksiyon2():
    def ucuncu_fonksiyon(arg1):
        o3 = arg1[:]
        o3.append(6)
        print "Bu fonksiyonun içinde oluyor:", o3 
    print "Bu fonksiyonçağırılmadan oluyor: ", o3
    ucuncu_fonksiyon(o1)
    print "Bu fonksiyonun dışında oluyor :", o1   
    print "İçeride tanımlanmış bir değişkene dışarıdan erişmeye çalışmak :" , o3

In [49]:

ornek_fonksiyon2()

Bu fonksiyonçağırılmadan oluyor:  [1, 2, 3, 4, 5]
Bu fonksiyonun içinde oluyor: [1, 2, 3, 4, 5, 6]
Bu fonksiyonun dışında oluyor : [1, 2, 3, 4, 5]
İçeride tanımlanmış bir değişkene dışarıdan erişmeye çalışmak : [1, 2, 3, 4, 5]

Lambda Fonksiyonlar¶

Bu ufak fonksiyonlar bir isim olmadan tanımlanırlar ve sonucu döndürüler basit bir ifade taşırlar. Genellikle listelerle işlem yaparken çok kullanışlılardır. lambda anahtar sözcüğü ardından değişken iki nokta ve ilgili ifade şeklinde yazılırlar.

In [50]:

z = lambda x: x * x

In [51]:

z(8)

Out[51]:

map¶

map( ) fonksiyonu belirtilen fonksiyonu listenin her elemanı için ayrı ayrı uygular.

In [52]:

list1 = [1,2,3,4,5,6,7,8,9]

In [53]:

eg = map(lambda x:x+2, list1)
print eg

[3, 4, 5, 6, 7, 8, 9, 10, 11]

Aynı zamanda iki liste ekleyebilirsiniz.

In [54]:

list2 = [9,8,7,6,5,4,3,2,1]

In [55]:

eg2 = map(lambda x,y:x+y, list1,list2)
print eg2

[10, 10, 10, 10, 10, 10, 10, 10, 10]

sadece lambda ile değil var olan fonksiyonlarla beraber de kullanılabilirler.

In [57]:

eg3 = map(str,eg2)
print eg3

['10', '10', '10', '10', '10', '10', '10', '10', '10']

filter¶

filter( ) fonksiyonu bir listedeki elemanları filtrelemek için kullanılır. Bu fonksiyon sonuçları yeni bir listede döndürür.

In [58]:

list1 = [1,2,3,4,5,6,7,8,9]

5'ten küçük olan elemanalrı almak için:

In [59]:

filter(lambda x:x<5,list1)

Out[59]:

[1, 2, 3, 4]

aynı durumda map() kullanıldığında ne olduğuna dikkat edin.

In [60]:

map(lambda x:x<5, list1)

Out[60]:

[True, True, True, True, False, False, False, False, False]

Yani diyebiliriz ki map() için True döndüren değerler filter( )kullanıldığında döndürülecektir.

In [ ]:

filter(lambda x:x%4==0,list1)