10 Mayıs 2013 Cuma

Fonksiyonlar

Fonksiyon,belirli sayıda verileri kullanarak bunları işleyen ve bir sonuç üreten komut grubudur.
Fonksiyonlar programlamada kullanacağımız ve sürekli tekrar eden komutların kullanımını daha da kolaylaştırmak için oluşturacağımız yapılardır.


Bu tanımlamaları yaptıktan sonra şu şekilde bir açıklama yapabiliriz. Elimizde bir kod kümesi var ve biz bunu programımız için de tekrar tekrar kullanıyoruz. Bu noktada fonksiyonlar devreye giriyor ve bu kod kümesini tekrar tekrar yazmak yerine bir fonksiyon haline çeviriyoruz. İstediğimiz yerde bu fonksiyonu çağırıyoruz.
Yani fonksiyonlar bizi kod israfından kurtararak daha az kod ile aynı işi yapmamızı sağlar.
Fonksiyon Tanımlamak
Python'da fonksiyon tanımlarken diğer programa dillerinden biraz farklı olarak "def" isimli bir parçacıktan yararlanacağız. "def" parçacığından sonra fonksiyonumuzun adını yazacağız.İsim verirken Türkçe karakter kullanmamanız gerektiğine kesinlikle dikkat etmelisiniz.Şimdi bir örnek verelim;
def fonk_adi():
Python'da fonksiyon tanımlamak bu kadar kolay. Dikkatinizi çekmiş olmalı fonksiyon adını verdikten sonra parantez açıp kapadık ve iki nokta üst üste koyduk. Fonksiyon tanımlarken bu kurallara uymamız gerekir. Aksi halde programımız hata verecektir. Fonksiyon oluştururken gövde kısmının girintili bir şekilde yazılması gerekir. Şimdi gelin ilk fonksiyonumuzu oluşturalım;
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def ilk_fonksiyon():
    print "Merhaba Python, fonksiyonlar ile tanışıyorum."
Bu şekilde fonksiyonumuzu tanımladıktan sonra programımızı çalıştırırsak herhangi bir çıktı alamadığımızı göreceksiniz.Çünkü şu anda biz fonksiyonumuzu sadece tanımladık. Python'a "Tanımladığım 'ilk_fonksiyon' isimli fonksiyonu burada kullan." demedik.Şimdi gelin bunu yapalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def ilk_fonksiyon():
    print "Merhaba Python, fonksiyonlar ile tanışıyorum."

ilk_fonksiyon()
Merhaba Python, fonksiyonlar ile tanışıyorum.
Gördüğünüz gibi fonksiyonumuzu çağırdık ve çıktımızı başarılı bir şekilde aldık.Şimdi şu şekilde biraz daha kullanışlı bir örnek verelim;
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def dogru():
    print "Tebrikler,girdiğiniz parola doğru."
    
def yanlis():
    print "Üzgünüz,girdiğiniz parola yanlış."
    
parola="123456"

giris = raw_input("Parolayı giriniz:")

if(parola==giris):
    dogru()
else:
    yanlis()

Parolayı giriniz:123456
Tebrikler,girdiğiniz parola doğru.
Bu programı dikkatlice incelerseniz kurallara nasıl uyduğumuzu göreceksiniz.
Fonksiyonlarda Parametre Kullanımı
Şimdiye kadar ki kullandığımız fonksiyonlarda tanımlama yaparken parantez içini hep boş bıraktık.Bu şekilde kullanabiliriz veya bu parantezler içine bir takım veriler eklememiz gereken durumlar olabilir.Bu verilere programlama dillerinde parametre adı verilir.
Bu parametre olayını şu şekilde bir örnek vererek çok daha iyi anlamınızı sağlayabiliriz.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def carp():
    sayi1 = 15
    sayi2 = 10
    carpim = sayi1*sayi2
    print carpim
    
carp()

150
Burada gördüğünüz gibi fonksiyon herhangi bir parametre almadı ve bizim sabit olarak atadığımız iki sayıyı çarptı.Şimdi bu iki sayıyı kullanıcıdan aldığımız bir program yazalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def carp(sayi1,sayi2):
    carpim = sayi1*sayi2
    print "Girdiğiniz sayıların çarpımı:",carpim
    
sayi1 = int(raw_input("Birinci sayıyı giriniz:"))
sayi2 = int(raw_input("İkinci sayıyı giriniz:"))
carp(sayi1,sayi2)

Birinci sayıyı giriniz:10
İkinci sayıyı giriniz:5
Girdiğiniz sayıların çarpımı: 50
Şimdi bu programda ne yaptığımızı şu şekilde anlatalım:İlk önce kullanıcıdan iki sayı aldık ve bu iki sayıyı parametre olarak "carpim" fonksiyonumuza gönderdik.Sonra bu iki sayıyı fonksiyonumuzda kullandık.İlk örneğimizde fonksiyon sadece elle belirtilen 10 ve 15 sayılarını çarparak bunları ekrana yazacaktır.İkinci örneğimiz ise kullanıcı hangi sayıyı girmek isterse onu sağlayacak bu şekilde işlevsel bir program yazmış olduk.

Fonksiyonu tanımlarken ve fonksiyonu çağırırken kullandığımız değişken isimleri aynı olmak zorunda değildir.Bizim bu örneğimizde öyle olması sizi böyle bir düşünceye kapılmanıza sebep olmasın.Bu örneği sayıları kullanıcıdan almadan ve değişken kullanmadan şu şekilde de çağırabilirdik.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def carp(sayi1,sayi2):
    carpim = sayi1*sayi2
    print "Girdiğiniz sayıların çarpımı:",carpim
    
carp(10,20)
Not: Fonksiyonlar tanımlanırken parantez içinde belirtilen değerlere "parametre" adı verilir.Aynı fonksiyon çağrılırken parantez içinde belirtilen değerlere ise "argüman" adı verilir.Ama genel olarak her ikisi içinde "parametre" kullanılır. sum() fonksiyonu gönderdiğimiz herhangi bir liste elemanlarını toplayarak bize geri döndüren hazır bir fonksiyondur.Şimdi gelin sum() fonksiyonu ile aynı işi yapan toplam() fonksiyonumuzu kendimiz yazalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def toplam(liste):
    toplam = 0
    for i in liste:
        toplam += i
    print toplam

liste = [1,2,3,4,5,8,10]    
toplam(liste)

33
Gördüğünüz gibi liste elemanları toplandı ve ekrana yazıldı.Bu programdan anlayabileceğiniz gibi fonksiyonlara liste,demet,sözlük ve kümeleri parametre olarak gönderebilirsiniz.
İsimli ve Sıralı Argümanlar
Şu ana kadar kullandığımız fonksiyonlarda fark etmesek bile sıralı argümanları kullandık.Sıralı argümanlarda fonksiyona gönderdiğimiz argümanların sırası çok önemlidir.
#!/usr/bin/env python
# -*- coding: utf-8 -*-


def fonksiyon(isim,not1,not2):
    ortalama = (not1+not2)/2
    print isim,"adındaki öğrencinin not ortalaması:",ortalama
    
    
fonksiyon("Mazlum",80,90)

Mazlum adındaki öğrencinin not ortalaması: 85
Bu fonksiyonda fonksiyona gönderilen ilk argüman fonksiyon için "isim" parametresine gider.Yani fonksiyon tanımlanırken sıra nasıl ise bu kullanımda argümanlar o sıra ile alınır.
fonksiyon(80,"Mazlum",90)

Traceback (most recent call last):
  File "/home/mazlumagar/workspace/Python/a.py", line 10, in
    fonksiyon(80,"Mazlum",90)
  File "/home/mazlumagar/workspace/Python/a.py", line 6, in fonksiyon
    ortalama = not1+not2
TypeError: cannot concatenate 'str' and 'int' objects
Gördüğünüz gibi burada "isim" parametresine 80 ve "not1" parametresine "Mazlum" değeri atandı.Fonksiyon içinde "Mazlum" ve 90 değerlerini toplamaya çalıştı.Bir karakter dizisini ve sayıyı toplamaya çalıştığı için bize hata döndürdü.
İşte bu tarz sorunlar yaşamak istemiyorsak isimli argümanları kullanabiliriz.Hemen bu örneğimizi isimli argüman türüne çevirelim ve aradaki farkı görelim.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def fonksiyon(isim,not1,not2):
    ortalama = (not1+not2)/2
    print isim,"adındaki öğrencinin not ortalaması:",ortalama
    
    
fonksiyon(not1=80,isim="Mazlum",not2=90)

Mazlum adındaki öğrencinin not ortalaması: 85
Parametre sayısı çok fazla olan ve sırasını hatırlamadığınız fonksiyonlarda isimli argümanları kullanarak parametre gönderebilirsiniz.Bu şekilde kullanım işinizi kolaylaştıracaktır.Bunu söylememize rağmen programı yazarken daha çok sıralı argümanlardan faydalanıyoruz.
Varsayılan Değerli Argümanlar
Bu tür argümanlar fonksiyon tanımlanırken parametreye varsayılan olarak atanır.
Bu konuyu hazır olarak bulunan range() fonksiyonu üzerinden anlatırsak çok rahat bir şekilde anlayacaksınız.
Hatırlarsanız range() fonksiyonu herhangi bir sayıya kadar olan sayıların listesini veriyordu.
sayilar = range(14)
print sayilar

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
Ama biz istersek ikinci bir argüman daha ekleyebiliriz.
sayilar = range(6,14)
print sayilar

[6, 7, 8, 9, 10, 11, 12, 13]
Gördüğünüz gibi bu sefer 0'dan değilde girdiğimiz sayıdan başladı.Gelin şimdi bir argüman daha ekleyelim.
sayilar = range(6,14,2)
print sayilar

[6, 8, 10, 12]
Bu seferde 1'er 1'er değilde girdiğimiz sayı kadar artarak gidiyor.İşte buradan anlıyoruz ki eğer biz fonksiyona nereden başladığını ve kaçar kaçar gitmesi gerektiğini argüman olarak göndermezsek fonksiyon bunları kendisi varsayılan olarak belirliyor. Örneğin biz burada başlangıç değerini girmezsek fonksiyon onu 0 olarak alıyor. Bu şekilde varsayılan değerli argümanları kullanmak o fonksiyonları kullanırken işimizi kolaylaştırır.Gelin şimdi kendi yazdığımız bir fonksiyon da varsayılan argümanları kullanalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def topla(sayi,kacar=1):
    toplam = 0
    i=0
    while(sayi>i):
        toplam += i
        i+=kacar
    print "Toplam:",toplam

topla(10)

Toplam:45
Biz de tanımladığımız bu fonksiyonda kaçar kaçar gideceğini varsayılan olarak 1 atadık.Eğer fonksiyonu şu şekilde kullanırsak sonucun değiştiğini göreceğiz.
topla(10,3)

Toplam: 18
Fonksiyonu çağırırken ikinci bir argüman olarak 3 sayısını atadığımız için "kacar" parametresi artık 1 değilde bizim gönderdiğimiz sayı olarak değişti.
Not:Varsayılan değerli argümanlarda dikkat etmemiz gereken en önemli kural; varsayılan değerli parametrenin sıralamanın en sonunda olması gerektiğidir.
Yani fonksiyonu şu şekilde tanımlarsak;
def topla(kacar=1,sayi):

  File "/home/mazlumagar/workspace/Python/a.py", line 4
    def topla(kacar=1,sayi):
SyntaxError: non-default argument follows default argument
Python bize bu şekilde bir hata döndürecektir.
İstenen Sayıda Sıralı Argüman Kullanımı
Bugüne kadar oluşturduğumuz bütün fonksiyonlar belirli sayıda parametre alıyordu. Peki biz parametre sayısını sınırlamasak,istediğimiz kadar argüman girsek olmaz mı? Bu istediğimizi bir çok programlama dilinde yapamazken Python bize bu imkanı sağlıyor.
def ogrenci(ad,numara,fakülte,sinif)
Bu tanımladığımız fonksiyon gördüğünüz gibi 4 parametre almaktadır.Eğer biz argüman gönderirken 4'ten az veya 4'ten fazla parametre yollarsak program bize hata verecektir. Gelin şimdi aynı fonksiyon üzerinden gidelim ve yaptığımız sınırlamayı kaldırarak istediğimiz sayıda argüman girebileceğimiz fonksiyona dönüştürelim.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def ogrenci(*bilgiler):
    bilgi=""
    for i in bilgiler:
        bilgi+=i
    print "Ögrencinin bilgileri:\n",bilgi

ogrenci("Mazlum ","Teknoloji Fakütesi ","Bilgisayar Mühendisliği ","1.Sınıf")

Ögrencinin bilgileri:
Mazlum Teknoloji Fakütesi Bilgisayar Mühendisliği 1.Sınıf
Bu fonksiyondaki farklılık hemen dikkatiniz çekmiştir.Fonksiyonda parametre sınırlaması yapmayarak "*bilgiler" gibi bir yapı kullandık.Burada önemli olan kısım "*bilgiler" olarak kullandığımız yapıdır.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def ogrenci(*bilgiler):
    print bilgiler

ogrenci("Mazlum ","Teknoloji Fakutesi ","Bilgisayar Muhendisligi ","1.Sinif")

('Mazlum ', 'Teknoloji Fakutesi ', 'Bilgisayar Muhendisligi ', '1.Sinif')
Bu fonksiyonu çağırdığımızda aldığımız çıktıya dikkat ederseniz bir "demet" olduğunu fark edeceksiniz. Bizim girdiğimiz argümanlar fonksiyonda demet türünden saklanıyor.Demetler üzerinde yapabileceğimiz bütün işlemleri "*bilgiler" üzerinde de yapabiliriz.Demek istediğimizi "demetler" konusunda işlenen enumerate fonksiyonunu kullanarak daha iyi anlayalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def demet(*bolumler):
    for sira,bolum in enumerate(bolumler):
        print "%s : %s"%(sira,bolum)

demet("Bilgisayar","Elektrik-Elektronik","Makina","İnşaat")

0 : Bilgisayar
1 : Elektrik-Elektronik
2 : Makina
3 : İnşaat
Burada demetler konusunda öğrendiğimiz herşeyi "bolumler" üzerinde yapabiliriz. Kullandığımız "*" operatör sadece fonksiyonda parametre alırken kullanmak zorunda değiliz,aynı şekilde parametre gönderirken kullanabiliriz.Bu operatörün görevi bir dizi(liste,demet vb.) bütün ögeleri tek tek fonksiyona uygulamasıdır.
#!/usr/bin/env python
# -*- coding: utf-8 -*-


def bolum(bolum1,bolum2,bolum3,bolum4):
    print bolum1,bolum2,bolum3,bolum4

bolumler = ["Bilgisayar ","Elektrik-Elektronik ","Makina ","İnşaat "]

bolum(*bolumler)

Bilgisayar  Elektrik-Elektronik  Makina  İnşaat 
Gördüğünüz gibi bu sefer sınırlı parametre alan fonksiyona elimizdeki bir listenin elemanlarını "*" operatörü ile gönderdik.Burada önemli olan; listemizdeki eleman sayısı ile fonksiyonda ki parametre sayısının eşit olmasıdır.Eğer eşit olmaz ise şu şekilde bir hata ile karşılaşırız.
Traceback (most recent call last):
  File "/home/mazlumagar/workspace/Python/a.py", line 10, in
    fnk(*liste)
TypeError: fnk() takes exactly 2 arguments (3 given)
#!/usr/bin/env python
# -*- coding: utf-8 -*-



def ortalama(*notlar):
    toplam=0
    for ders in notlar:
        toplam+=int(ders)
    print toplam/len(notlar)
    
    

notlar = []
sayi=0
print "Öğrenci Notlarını Giriniz:\n"
while 5>sayi:
    notlar.append(raw_input("Not:"))
    sayi+=1

ortalama(*notlar)

Öğrenci Notlarını Giriniz:

Not:10
Not:20
Not:50
Not:80
Not:90
50
g Bu fonksiyon örneğimizde ilk elimizdeki listenin elemanlarını tek tek "*" operatörü ile fonksiyona gönderdik.Aynı şekilde fonksiyonda "*" operatörü ile demet olarak aldık ve işlemlerimizi yaptık.
İstenen Sayıda İsimli Argüman Kullanımı Fonksiyonlara istediğimiz sayıda sıralı argüman göndermeyi öğrendikten sonra şimdi de istediğimiz sayıda isimli argüman göndermeyi öğrenelim. Sıralı argümanlarda "*" operatörünü kullanıyorduk.İsimli argümanlarda ise "**" operatörünü kullanarak verileri fonksiyona alıyoruz.Hatırlarsanız isimli argümanları anlatırken şöyle bir örnek vermiştik.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def fonksiyon(isim,not1,not2):
    ortalama = (not1+not2)/2
    print isim,"adındaki öğrencinin not ortalaması:",ortalama
    
    
fonksiyon(not1=80,isim="Mazlum",not2=90)

Mazlum adındaki öğrencinin not ortalaması: 85
Şimdi bunu "**" operatörünü kullanarak değiştirelim ve aradaki farkı görelim.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def fonksiyon(**bilgiler):
    ortalama = (bilgiler["not1"]+bilgiler["not2"])/2
    print bilgiler["isim"],"adındaki öğrencinin not ortalaması",ortalama
    
fonksiyon(not1=80,isim="Mazlum",not2=90)

Mazlum adındaki öğrencinin not ortalaması: 85
Gördüğünüz gibi aslında sıralı argümanlardan tek farkı fonksiyon orada argümanları "demet" olarak alıyordu burada ise "sözlük" olarak alıyor.Yani istenen sayıda isimli argümanları kullanırken sözlüklerin tüm özelliklerinden yararlanabiliriz.Sıralı argümanlarda yaptığımız gibi argümanları gönderirken "**" operatöründen faydalanabiliriz.Yani bu örneğimizi şu hale getirerek de kullanabiliriz.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def fonksiyon(**bilgiler):
    ortalama = (bilgiler["not1"]+bilgiler["not2"])/2
    print bilgiler["isim"],"adındaki öğrencinin not ortalaması",ortalama
    
sozluk = {"not1":80,"isim":"Mazlum","not2":90}
fonksiyon(**sozluk)

Mazlum adındaki öğrencinin not ortalaması: 85
Sıralı argümanlarda yaptığımız gibi bir örnek yapalım ve mantığını tam olarak anlayalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def not_ortalamasi(**ortalamalar):
    for i,k in ortalamalar.items():
        print "'",i,"' isimli öğrencinin not ortalaması:",k
    

ortalama = {"Mazlum":2.4,"Okan":2.7,"Sunay":3.2,"Nilay":3.0,"Sultan":2.6,"Mücahit":3.3}
not_ortalamasi(**ortalama)

' Sunay ' isimli öğrencinin not ortalaması: 3.2
' Sultan ' isimli öğrencinin not ortalaması: 2.6
' Mücahit ' isimli öğrencinin not ortalaması: 3.3
' Mazlum ' isimli öğrencinin not ortalaması: 2.4
' Okan ' isimli öğrencinin not ortalaması: 2.7
' Nilay ' isimli öğrencinin not ortalaması: 3.0
Gördüğünüz gibi ilk önce "ortalama" adında bir "sözlük" oluşturduk.Sonra bu sözlüğün elemanlarını "**" operatörü ile teker teker "not_ortalamasi" fonksiyonumuza gönderdik."**" operatörü ile bu gelen verileri "sözlük" şeklinde aldık ve sözlüklerde gördüğümüz "items()" metodundan faydalanarak ekrana yazdırdık.
Global Deyimi
"global" kelimesi Türkçede "evrensel" demektir.Bu deyim sadece Python için özel değildir.
Günümüzde var olan hemen hemen bütün programlama dillerinde bulunur.Birazdan göreceğimiz "return" ve "pass" deyimi de aynı şekilde hemen hemen bütün programlama dillerinde bulunurlar.Bu deyimler artık kalıplaşmıştır.
Şimdi tekrar "global" deyimine dönelim.Programlama dillerinde bir fonksiyon içinde tanımlanan değişkenler fonksiyon ile oluşturulur ve fonksiyon sonlandığı zaman oluşturulan bu değişkenler de fonksiyon ile beraber sonlanır.Yani bir fonksiyon içinde oluşturulan fonksiyonu fonksiyon dışında herhangi bir yerde kullanamayız.Şimdi bu dediklerimizi örnek vererek açıklayalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def fonk():
    a="Global değişkenler"
    print a

fonk()
Bu programı çalıştırdığımız zaman ekranda "Global değişken" yazısının çıktığını göreceğiz.Şimdi programımızı şu hale getirelim.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def fonk():
    a="Global değişkenler"

fonk()
print a
Programı çalıştığınız zaman şu hata ile karşılaşacaksınız.
Traceback (most recent call last):
  File "/home/mazlumagar/workspace/Python/global.py", line 8, in
    print a
NameError: name 'a' is not defined

Python bize şunu demek istiyor:"Sen ekrana 'a' değişkenini yaz dedin.Ama ben böyle bir değişken bulamadım." Sanırım anlatmak istediğimizi daha iyi anladınız.Peki biz bu fonksiyon içinde tanımlanan değişkene dışarıdan erişemez miyiz? Eğer bunu istersek "global" deyimi yardımımıza koşuyor.Şimdi programımızı şu hale getirelim.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def fonk():
    global a="Global değişkenler"

fonk()
print a

Global değişkenler
Gördüğünüz gibi herhangi bir hata ile karşılaşmadan,işlemimizi başarı ile gerçekleştirdik.
return Deyimi
Şu ana kadar yazdığımız bütün fonksiyonlarda ekrana bir sonuç bastırdık. Ama program yazarken her zaman böyle yapmayız. Yazdığımız bir fonksiyondan değer döndürmek ve bu değer ile işlemler yapmak isteyebiliriz. Yani "return" deyimi fonksiyonun deriye herhangi bir değer döndürmesini sağlar.
#!/usr/bin/env python
# -*- coding: utf-8 -*-


def dondur(not_):
    if not_ > 50:
        return "Dersten Geçtiniz."
    else:
        return "Dersten Kaldınız."

sonuc = dondur(60)
print sonuc

Dersten Geçtiniz.
Gördüğünüz gibi bu sefer "print" komutu ile çıktımızı ekrana yazdırmadık. "return" deyimini kullanarak çıktıyı bir değişkene atadık ve bu değişkeni ekrana yazdırdık. Bu fonksiyonda "print" komutunu kullanmak daha mantıklıdır. Ama kavramanız açısından basit ama anlaşılır bir program yazdık.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def dondur(sayi):
    return sayi % 2

sonuc = dondur(52)
if sonuc==1:
    print "Sayı Tek."
else:
    print "Sayı Çift."

Sayı Çift.
Burada gördüğünüz gibi geriye bir sayı döndürdük ve bu sayı üzerinde işlemler yaptık. "print" komutu ile "return" deyimini birbirine karıştırmamalısınız. "print" komutu ekrana bir şeyler yazdırmamızı sağlarken "return" deyimi fonksiyonun geriye değer döndürmesini sağlar. pass Deyimi pass deyimini "hata yakalama" konusundan hatırlayacaksınız. Pass Türkçede "geçmek" anlamına gelir. Yani programımızın herhangi bir durumda hiç bir şey yapmasını istemiyorsak bu deyimi kullanırız.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

ucret = raw_input("Ücreti giriniz:")

if ucret>50:
    pass
else:
    print "Bu ücrete kitap bulabilirsiniz."

print "Teşekkürler"

Ücreti giriniz:20
Teşekkürler
Gördüğünüz gibi girilen ücret 50'den küçük olduğu için "if" blokunu atladı ve "else" kısmına geçti.Fonksiyonlarda da bu şekilde fonksiyonu tanımlayıp içini sonradan doldurabilirsiniz.Bu durumda "pass" deyimi bizim işimizi görür.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def gec():
    pass
Burada "pass" deyimini kullanmazsanız şu şekilde bir hata ile karşılaşırsınız.
    
              ^
IndentationError: expected an indented block
Gömülü Fonksiyonlar
Python içinde kullanımımız için hazır olarak bulunan fonksiyonlara gömülü fonksiyonlar denir. Daha önceden gördüğümüz len(),sum(),range() fonksiyonlar bu tür fonksiyonlardır. Bu fonksiyonlar Python içinde kullanıma hazır bir şekilde beklemektedir.
Python'da bulunan bu gömülü fonksiyonların listesine http://docs.python.org/2/library/functions.html adresinden ulaşabilirsiniz.
Program yazarken bir fonksiyon yazmadan önce bu listeyi kontrol etmeli ve eğer istediğimiz fonksiyon varsa onu kullanmalıyız.Çünkü bu fonksiyonlar Python geliştiricileri tarafından hazırlanmış olduğu için çok hızlı ve verimlidirler.
Belgelendirme Dizileri
Fonksiyonların açıklamasının yapılması için "belgelendirme dizileri" kullanılır. Bir fonksiyonun belgelendirme dizisine erişmek için "__doc__" kullanılır. Daha önceden öğrendiğimiz len() fonksiyonunun belgelendirme dizisini ekrana yazdıralım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-


print len.__doc__

len(object) -> integer

Return the number of items of a sequence or mapping.
Gördüğünüz gibi fonksiyonun kullanımı ve açıklaması geldi. Şimdi kendi fonksiyonumuza "belgelendirme dizisi" eklemeyi görelim.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def belge():
    """Bu fonksiyonumuzun belgelendirme dizisidir.
Buraya fonskiyonumuzun kullanımını yazabiliriz."""
    a=10

print belge.__doc__

Bu fonksiyonumuzun belgelendirme dizisidir.
Buraya fonskiyonumuzun kullanımını yazabiliriz.
Belgelendirme dizilerini oluştururken """Belgelendirme Dizisi""" yapısını kullanıyoruz.
Not: Belgelendirme dizileri fonksiyon tanımlamasından hemen sonra gelmelidir. Şu şekilde bir kullanım yanlıştır.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

def belge():
    a=10
    """Bu fonksiyonumuzun belgelendirme dizisidir.
Buradan fonksiyonumuzun ne işe yaradığını öğrenebilirsiniz"""

print belge.__doc__

None

Kaynakça:

9 yorum :

  1. hocam bu += ne demek?

    YanıtlaSil
  2. toplam += i , toplam = toplam + i ifadesinin kısaltılmış halidir.

    YanıtlaSil
  3. -9999999 ile 999999 arasında girilen sayıyı YAZIYLA YAZDIRMA

    YanıtlaSil
  4. konuların cok hızlı ilerliyor boyle kimse bir şey öğrenemez

    YanıtlaSil
  5. Bence konu akıcılığı var, gayet güzel lafı çevirmeden güzelce anlatmış. Takip edenler eğer başka sitelerden de diğer zamanlarda örnekler ve alıştırmalar üzerine de çalışırlarsa tamamdır.

    YanıtlaSil
  6. Bu yorum yazar tarafından silindi.

    YanıtlaSil
  7. Bu yorum yazar tarafından silindi.

    YanıtlaSil