Programlama Akademi

13-01-2025 4:30 PM

Python

Python 3'te Fonksiyonlar Nasıl Tanımlanır

Giriş

Bir fonksiyon, bir eylemi gerçekleştiren ve bir kez tanımlandıktan sonra tekrar kullanılabilen bir talimat bloğudur. Fonksiyonlar, kodu daha modüler hale getirerek aynı kodu tekrar tekrar kullanmanıza olanak tanır.

Python’da aşina olabileceğiniz birkaç yerleşik fonksiyon bulunmaktadır, bunlardan bazıları şunlardır:

Fonksiyon adları parantez içerir ve parametreler içerebilir.

Bu öğreticide, kendi fonksiyonlarınızı nasıl tanımlayabileceğinizi ve bunları kodlama projelerinizde nasıl kullanabileceğinizi inceleyeceğiz.

Fonksiyon Tanımlama

Klasik “Merhaba, Dünya!” programını bir fonksiyona dönüştürerek başlayalım.

Metin düzenleyicimizde yeni bir dosya oluşturup programa hello.py adını vereceğiz. Ardından fonksiyonu tanımlayacağız.

Bir fonksiyon, def anahtar kelimesiyle tanımlanır, ardından seçtiğiniz bir isim gelir ve parantezler içinde fonksiyonun alacağı parametreler (boş olabilir) yer alır. Bu işlem iki nokta üst üste ile sona erer.

Bilgi: Bu öğreticideki örnek kodları takip etmek için, yerel sisteminizde bir Python etkileşimli kabuğu açarak python3 komutunu çalıştırın. Daha sonra, >>> isteminin ardından örnekleri kopyalayıp yapıştırabilir veya düzenleyebilirsiniz.

Bu örnekte, hello() adında bir fonksiyon tanımlayacağız:

hello.py

def hello():

Bu, bir fonksiyon oluşturmak için başlangıç ifadesini ayarlar.

Buradan itibaren, fonksiyonun ne yapacağını belirten talimatları eklemek için 4 boşlukla girinti yapılmış bir satır ekleyeceğiz. Bu durumda, konsola Merhaba, Dünya! yazdıracağız:

`hello.py`
def hello():
    print("Merhaba, Dünya!")

Fonksiyonumuz artık tamamen tanımlandı, ancak bu noktada programı çalıştırırsak hiçbir şey olmayacaktır, çünkü fonksiyonu çağırmadık.

Bu yüzden, tanımladığımız fonksiyon bloğunun dışında hello() fonksiyonunu çağıralım:

`hello.py`
def hello():
    print("Merhaba, Dünya!")

hello()

Şimdi programı çalıştıralım:

$ python hello.py

Aşağıdaki çıktıyı almalısınız:

Çıktı

Merhaba, Dünya!

Fonksiyonlar, yukarıda tanımladığımız hello() fonksiyonundan daha karmaşık olabilir. Örneğin, fonksiyon bloğunun içinde for döngüleri, koşullu ifadeler ve daha fazlasını kullanabiliriz.

Örneğin, aşağıda tanımlanan fonksiyon, name değişkeni için girilen değerin bir sesli harf içerip içermediğini kontrol etmek için bir koşullu ifade kullanır, ardından name dizisindeki harfler üzerinde yineleme yapmak için bir for döngüsü kullanır.

`names.py`
# names() fonksiyonunu tanımlayın
def names():
    # input ile name değişkenini ayarlayın
    name = str(input('Adınızı girin: '))
    # Adın sesli harf içerip içermediğini kontrol edin
    if set('aeiou').intersection(name.lower()):
                 print('Adınız bir sesli harf içeriyor.')
    else:
        print('Adınız bir sesli harf içermiyor.')

    # Ad üzerinde yineleme yapın
    for letter in name:
        print(letter)

# Fonksiyonu çağırın
names()

Yukarıda tanımladığımız names() fonksiyonu, bir koşullu ifade ve bir for döngüsü ayarlayarak, kodun bir fonksiyon tanımında nasıl organize edilebileceğini gösterir. Ancak, programımızda ne amaçladığımıza ve kodumuzu nasıl düzenlemek istediğimize bağlı olarak, koşullu ifadeyi ve for döngüsünü iki ayrı fonksiyon olarak tanımlamak isteyebiliriz.

Program içinde fonksiyonlar tanımlamak, kodumuzu modüler ve yeniden kullanılabilir hale getirir, böylece aynı fonksiyonları tekrar yazmadan çağırabiliriz.

Parametrelerle Çalışma

Şu ana kadar, argüman almayan, boş parantezli fonksiyonlara baktık, ancak fonksiyon tanımlarındaki parantezler içinde parametreler tanımlayabiliriz.

Bir parametre, bir fonksiyon tanımında adı verilen bir varlıktır ve fonksiyonun kabul edebileceği bir argümanı belirtir.

x, y ve z parametrelerini alan küçük bir program oluşturalım. Parametreleri farklı konfigürasyonlarda toplamak için bir fonksiyon yazacağız. Bu toplamlardan elde edilen sonuçlar fonksiyon tarafından yazdırılacak. Sonra fonksiyonu çağırıp fonksiyona sayılar geçireceğiz.

add_numbers.py
def add_numbers(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    print(a, b, c)

add_numbers(1, 2, 3)

Bu örnekte, x parametresi için1, y parametresi için 2 ve z parametresi için 3 değerlerini geçtik. Bu değerler, sırasıyla her parametreyle eşleşir.

Program, geçtiğimiz değerlere göre aşağıdaki matematiği yapmaktadır:

a = 1 + 2
b = 1 + 3
c = 2 + 3

Fonksiyon ayrıca a, b ve c değerlerini yazdırır ve yukarıdaki matematiğe dayanarak a'nın 3, b'nin 4 ve c'nin 5 olmasını bekleriz. Programı çalıştıralım:

$ python add_numbers.py

Çıktı:

3 4 5

1, 2 ve 3'ü add_numbers() fonksiyonuna parametre olarak geçirdiğimizde, beklenen çıktıyı alırız.

Parametreler, genellikle fonksiyon tanımları içinde değişkenler olarak tanımlanan argümanlardır. Fonksiyon çalıştırıldığında, bu argümanlara değerler atanabilir.

Anahtar Kelime Argümanları

Parametreleri sırayla çağırmanın yanı sıra, bir fonksiyon çağrısında anahtar kelime argümanlarını kullanarak, çağırıcı parametre adını kullanarak argümanları belirtebilir.

Anahtar kelime argümanları kullanıldığında, parametreleri sırayla geçmek zorunda kalmazsınız çünkü Python yorumlayıcısı, sağlanan anahtar kelimeleri kullanarak değerleri parametrelerle eşleştirir.

Kullanıcı için profil bilgilerini gösterecek bir fonksiyon oluşturalım. Fonksiyona, username (kullanıcı adı, string olarak) ve followers (takipçi sayısı, integer olarak) parametrelerini geçeceğiz.

profile.py
# Parametreleri içeren fonksiyonu tanımla
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

Fonksiyon tanımında profile_info() fonksiyonunun parantezleri içinde username ve followers parametreleri yer alır. Fonksiyon bloğu, iki parametreyi kullanarak kullanıcı hakkında bilgileri string olarak yazdırır.

Şimdi fonksiyonu çağırıp parametrelere değer atayalım:

profile.py
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Parametrelerle fonksiyonu çağır
`profile_info("sammyshark", 945)`

# Anahtar kelime argümanlarıyla fonksiyonu çağır
`profile_info(username="AlexAnglerfish", followers=342)`

İlk fonksiyon çağrısında, username için sammyshark, followers için 945 değeri girildi. İkinci fonksiyon çağrısında ise anahtar kelime argümanları kullanıldı ve değerler argüman değişkenlerine atandı.

Programı çalıştıralım:

$ python profile.py

Çıktı

Username: sammyshark
Followers: 945
Username: AlexAnglerfish
Followers: 342

Çıktıda iki kullanıcı adı ve takipçi sayısı gösteriliyor.

Bu yöntem, parametrelerin sırasını değiştirmemize de olanak tanır. İşte aynı programda farklı bir çağrı örneği:

profile.py
def profile_info(username, followers):
    print("Username: " + username)
    print("Followers: " + str(followers))

# Parametrelerin sırasını değiştir
`profile_info(followers=820, username="cameron-catfish")`

Programı tekrar çalıştırdığımızda şu çıktıyı alırız:

Çıktı

Username: cameron-catfish
Followers: 820

Fonksiyon tanımı aynı print() ifadelerini koruduğu için, anahtar kelime argümanları kullanırsak, parametreleri fonksiyon çağrısına hangi sırayla geçirdiğimizin önemi yoktur.

Varsayılan Argüman Değerleri

Ayrıca, parametrelerden biri veya her ikisi için varsayılan değerler belirleyebiliriz. Takipçi sayısı için varsayılan bir değer olan 1'i nasıl ayarlayacağımıza bakalım:

profile.py

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

Şimdi, yalnızca kullanıcı adı atanmış bir fonksiyonu çalıştırabiliriz ve takipçi sayısı otomatik olarak 1 olarak varsayılacaktır. İstersek takipçi sayısını da değiştirebiliriz.

profile.py

def profile_info(username, followers=1):
    print("Username: " + username)
    print("Followers: " + str(followers))

profile_info(username="JOctopus")
profile_info(username="sammyshark", followers=945)

Programı python profile.py komutuyla çalıştırdığımızda şu çıktıyı alırız:

Çıktı

Username: JOctopus
Followers: 1
Username: sammyshark
Followers: 945

Varsayılan değerlerle sağlanan parametreler, varsayılan bir değere sahip her argüman için değer tanımlamayı atlamamıza olanak tanır.

Bir Değer Döndürme

Bir parametre değerini bir fonksiyona geçirebilir ve bir fonksiyon da bir değer üretebilir.

Bir fonksiyon, bir return ifadesi ile bir değer üretebilir, bu da bir fonksiyondan çıkar ve isteğe bağlı olarak bir ifadeyi çağırana geri döndürür. Eğer bir return ifadesi argümansız kullanılırsa, fonksiyon None döndürecektir.

Şu ana kadar fonksiyonlarımızda print() ifadesini kullanmıştık, ancak şimdi bir değişken döndüren bir program oluşturalım.

Yeni bir metin dosyasında square.py adlı bir program oluşturalım ve bu program x parametresinin karesini alsın ve y değişkenini döndürsün. Sonuç değişkenini, square() fonksiyonunu çalıştırıp içine 3 geçerek bastıralım.

square.py

def kare(x):
    y = x ** 2
    return y

sonuc = kare(3)
print(sonuc)

Programı çalıştırabiliriz ve şu çıktıyı alabiliriz:

$ python square.py

Çıktı

9

Python'dan 3 sayısının karesini almasını istediğimizde beklediğimiz sonuç olan 9, çıktı olarak döndürülüyor.

return ifadesinin nasıl çalıştığını daha iyi anlamak için, programda bu ifadeyi yorum satırı haline getirebiliriz:

square.py

def kare(x):
    y = x ** 2
    # return y

sonuc = kare(3)
print(sonuc)

Şimdi programı tekrar çalıştıralım:

$ python square.py

Çıktı

None

Burada return ifadesini kullanmadığımızda program bir değer döndüremediği için varsayılan olarak None döndürülüyor.

Bir başka örnek olarak, yukarıdaki add_numbers.py programında, print() ifadesini return ifadesiyle değiştirebiliriz.

Add_numbers.py

def sayilari_ekle(x, y, z):
    a = x + y
    b = x + z
    c = y + z
    return a, b, c

toplamlar = sayilari_ekle(1, 2, 3)
print(toplamlar)

Fonksiyonun dışarısında, daha önce olduğu gibi 1, 2 ve 3 değerlerini alarak çalışan fonksiyonun sonucunu toplamlar değişkenine atıyoruz. Ardından toplamlar değişkenini yazdırıyoruz.

Şimdi, return ifadesine sahip olan programı tekrar çalıştıralım:

$ python add_numbers.py

Çıktı

(3, 4, 5)

Fonksiyonun içinde print() ifadesini kullanarak aldığımız 3, 4 ve 5 sayılarının aynısını elde ediyoruz. Bu sefer sonuç bir demet (tuple) olarak döndürülüyor, çünkü return ifadesindeki ifade listesi en az bir virgüle sahip.

Fonksiyonlar, bir return ifadesine ulaştığında, bir değer döndürüp döndürmediklerine bakılmaksızın hemen sonlanır.

Return_loop.py

def bese_kadar_dongu():
    for x in range(0, 25):
              print(x)
              if x == 5:
                     # Fonksiyonu x == 5 olduğunda durdur
                     return
            print("Bu satır çalışmayacak.")

bese_kadar_dongu()

return ifadesini for döngüsü içinde kullanarak fonksiyonu sonlandırdığımızda, döngünün dışındaki satır çalışmaz. Eğer bunun yerine bir break ifadesi kullanmış olsaydık, yalnızca döngü o anda sonlanır ve son print() satırı çalışırdı.

return ifadesi bir fonksiyondan çıkış yapar ve eğer bir parametre ile kullanılırsa, bir değer döndürebilir.

main() fonksiyonunu kullanmak

Python'da programınızın altına bir fonksiyon yazıp çalıştırabileceğiniz gibi (yukarıdaki örneklerde yaptığımız gibi), birçok programlama dili (C++ ve Java gibi) çalıştırmak için bir main fonksiyonu gerektirir. Bir main() fonksiyonunu dahil etmek, Python programlarımızı en önemli bileşenleri bir fonksiyon içinde toplamak gibi mantıksal bir şekilde yapılandırabilir. Bu aynı zamanda programlarımızı Python bilmeyen programcılar için de daha okunabilir hale getirebilir.

hello.py programına bir main() fonksiyonu ekleyerek başlayacağız. hello() fonksiyonumuzu koruyacağız ve ardından bir main() fonksiyonu tanımlayacağız:

hello.py

def hello():
      print("Merhaba, Dünya!")

def main():

main() fonksiyonu içinde, main() fonksiyonunda olduğumuzu bildirmek için bir print() ifadesi ekleyelim. Ayrıca, main() fonksiyonu içinde hello() fonksiyonunu çağıralım:

hello.py

def hello():
      print("Merhaba, Dünya!")

def main():
    print("Bu ana fonksiyon.")
    hello()

Son olarak, programın sonunda main() fonksiyonunu çağıracağız:

hello.py

def hello():
    print("Merhaba, Dünya!")

def main():
    print("Bu ana fonksiyon.")
    hello()

main()

Bu noktada programımızı çalıştırabiliriz:

$ python hello.py

Aşağıdaki çıktıyı alacağız:

Çıktı

Bu ana fonksiyon.
Merhaba, Dünya!

main() içinde hello() fonksiyonunu çağırdığımız ve ardından yalnızca main()'i çalıştırdığımız için, Merhaba, Dünya! metni sadece bir kez yazdırıldı, ve bu da ana fonksiyonda olduğumuzu bildiren metinden sonra gerçekleşti.

Sırada birden fazla fonksiyonla çalışacağımız için, global ve yerel değişkenlerin kapsamını gözden geçirmek faydalı olacaktır. Bir fonksiyon bloğu içinde bir değişken tanımlarsanız, yalnızca o fonksiyon içinde bu değişkeni kullanabilirsiniz. Değişkenleri fonksiyonlar arasında kullanmak istiyorsanız, global bir değişken tanımlamak daha iyi olabilir.

Python'da '__main__', en üst düzeydeki kodun çalıştırılacağı kapsamın adıdır. Bir program standart girdi, bir betik ya da etkileşimli bir komut isteminden çalıştırıldığında, __name__'i '__main__' olarak ayarlamaktadır.

Bu nedenle, aşağıdaki yapıyı kullanma konusunda bir gelenek vardır:

if __name__ == '__main__':
    # Bu ana program olduğunda çalıştırılacak kod buraya gelir

Bu, program dosyalarının ya:

İmkanı tanır.

Bu ifade dışında bulunan herhangi bir kod çalıştırıldığında yürütülecektir. Program dosyanızı bir modül olarak kullanıyorsanız, bu ifade içinde olmayan kod, ikincil dosya çalıştırılırken ithal edilmesi üzerine de çalışacaktır.

Yukarıdaki names.py programımızı genişletelim ve more_names.py adında yeni bir dosya oluşturalım. Bu programda global bir değişken tanımlayıp, orijinal names() fonksiyonumuzu talimatların iki ayrı fonksiyonda olduğu şekilde değiştireceğiz.

İlk fonksiyon, has_vowel(), isim dizisinin bir ünlü içerip içermediğini kontrol edecek.

İkinci fonksiyon ise print_letters(), isim dizisindeki her bir harfi yazdıracak. more_names.py

# Tüm fonksiyonlarda kullanılmak üzere global değişken ismini tanımlayın
isim = str(input('İsminizi girin: '))


# İsimde ünlü olup olmadığını kontrol eden fonksiyonu tanımlayın
def unlu_var_mi():
    if set('aeiou').intersection(isim.lower()):
                print('İsminizde bir ünlü var.')
    else:
                print('İsminizde bir ünlü yok.')


# İsim dizisindeki harfleri yineleyin
def harfleri_yazdir():
    for harf in isim:
        print(harf)

Bu ayar ile, unlu_var_mi() ve harfleri_yazdir() fonksiyonlarını içerecek main() fonksiyonunu tanımlayalım.

More_names.py

# Tüm fonksiyonlarda kullanılmak üzere global değişken ismini tanımlayın
isim = str(input('İsminizi girin: '))


# İsimde ünlü olup olmadığını kontrol eden fonksiyonu tanımlayın
def unlu_var_mi():
    if set('aeiou').intersection(isim.lower()):
                print('İsminizde bir ünlü var.')
    else:
               print('İsminizde bir ünlü yok.')


# İsim dizisindeki harfleri yineleyin
def harfleri_yazdir():
    for harf in isim:
        print(harf)


# Diğer fonksiyonları çağıran ana yöntemi tanımlayın
def main():
    unlu_var_mi()
    harfleri_yazdir()

Son olarak, dosyanın en altına if __name__ == '__main__': yapısını ekleyelim. Amacımız için, yapmak istediğimiz tüm fonksiyonları main() fonksiyonuna koyduğumuzdan, bu if ifadesini takip eden main() fonksiyonunu çağıracağız.

More_names.py

# Tüm fonksiyonlarda kullanılmak üzere global değişken ismini tanımlayın
isim = str(input('İsminizi girin: '))


# İsimde ünlü olup olmadığını kontrol eden fonksiyonu tanımlayın
def unlu_var_mi():
    if set('aeiou').intersection(isim.lower()):
               print('İsminizde bir ünlü var.')
    else:
              print('İsminizde bir ünlü yok.')


# İsim dizisindeki harfleri yineleyin
def harfleri_yazdir():
    for harf in isim:
              print(harf)


# Diğer fonksiyonları çağıran ana yöntemi tanımlayın
def main():
    unlu_var_mi()
    harfleri_yazdir()


# Ana fonksiyonu çalıştırın
if __name__ == '__main__':
     main()

Şimdi programı çalıştırabiliriz:

$ python more_names.py

Program names.py programı ile aynı çıktıyı gösterecektir, ancak burada kod daha düzenli ve modüler bir şekilde kullanılabilir.

Bir main() fonksiyonu tanımlamak istemiyorsanız, programı şu şekilde de sonlandırabilirdiniz:

More_names.py

...
if __name__ == '__main__':
    unlu_var_mi()
    harfleri_yazdir()

main() fonksiyonunu ve if __name__ == '__main__': ifadesini kullanmak, kodunuzu mantıksal bir şekilde düzenleyerek daha okunabilir ve modüler hale getirebilir.

Sonuç

Fonksiyonlar, program içinde eylemler gerçekleştiren komut bloklarıdır ve kodumuzu yeniden kullanılabilir ve modüler hale getirmeye yardımcı olur.

Lisa Tagliaferri tarafından yazılan How To Define Functions in Python 3 Program makalesinin düzenlenmiş çevirisi.

Daha Fazla Oku:

• Sonraki Makale: Python 3'te args ve *kwargs Nasıl Kullanılır
• Önceki Makale: Python'da Döngülerle Çalışırken Break, Continue ve Pass İfadeleri Nasıl Kullanılır

Bu Makaleyi Paylaş