23 Mayıs 2013 Perşembe

Python ile Crawler Geliştirme

Saldırgan/kötü niyetli kişiler sonuç odaklı oldukları için Python dilinin hızlı ve esnek yapısından sonuna kadar faydalanmaktadır. Bunu açıklamak için konunun girizgahına, yani Python'nun temel sentaksına geri dönüyorum.

print "Hoşgeldin"

Ekrana "Hoşgeldin" yazacaktır. Ardından bir input oluşturalım.

answer = raw_input("Hacker mısın?")

ve gelen değere göre if/else içinde kullanalım.

if answer.lower() == 'evet':

   print "tabi tabi"

else:

   print "hımm"

Yukarıda yaptığımız işlemi unutmadan basit bir iş daha verelim Python'a ve http sorgusu oluşturalım.

İlgili kütüphaneyi çağırıyoruz.

import urllib2

İstekte bulanacağımız sitenin başına http yazıyoruz.

request = urllib2.Request('http://www.pythondersleri.com')

işlemi gerçekleştirip mevcut sitedeki kaynak kodunu döndürüyoruz.

response = urllib2.urlopen(request)
payload = response.read()
print(payload)

Ve ekranımıza sitenin kaynak kodlarını döktük. Görüldüğü üzere bir http sorgusu oluşturmak bile print komutu kadar basit.

Şimdi buradan yola çıkarak bir saldırının temelini oluşturalım ve Python dilini bu süreçte nasıl kullanacağımızı görelim.

Senaryoya göre saldırgan şu aşamaları izleyecek:
  • Hedef belirleme
  • Bilgi toplama
  • Sosyal Mühendislik (Phishing)
  • Sonuç : Kurumun/Kişilerin gizli bilgilerine ulaşmak
Hedefimiz "edu.tr" uzantılı bir web sitesi. Bütün alt domainleri google sayesinde listeledik. Daha sonra bu siteleri tek tek gezinerek işimize yarayan bilgileri toplamaya başlıyoruz(e-posta, sosyalağlar, pdf, txt vb gibi.) . Bu sırada karşımıza bir rehber uygulaması çıkıyor ve bu uygulama sayesinde kurumda çalışan kişilerin mail listesine ulaşabiliyoruz. Fakat mail listesi html çıktı olduğu için, biraz dağınık ve düzenlenmeye ihtiyacı var.

Bunun için http sorgu yaptığımız kodu biraz daha değiştirmemiz gerekiyor. Yine bir http sorgusu oluşturuyoruz ve düzenli ifadelerden faydalanarak html kodunun içindeki mail adreslerini ayıklıyoruz.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import urllib2, re
request = urllib2.Request('http://www.universite.edu.tr/rehber/getir.php?kategori=1000')
response = urllib2.urlopen(request) 
payload = response.read()
results = re.findall(r'[\w\.-]+@[\w\.-]+', payload) ## ['alice@google.com', 'bob@abc.com']
for result in results:
 print(result)

Yukarıda gördüğünüz Python kodunu  ./test.py > test.txt  şeklinde çalıştırdığımızda, mail adreslerinin düzenli bir listesini test.txt   dosyasının içine kaydetmiş olduk.



Böylelikle zararsız gibi gözüken basit bir rehber uygulaması, saldırgan tarafından aktif bir şekilde kullanılmış oldu. Gerisi sizin sosyal mühendislik zekanıza kalıyor.

Son olarak, test sonucunu merak edenler için ufak bir bilgi vermek istiyorum:
  • Bazı parolalar çok kolay tahmin edilebilir durumdaydı.
  • Kullanıcıların web-mail parolasıyla Wi-Fi parolası aynıydı.

...





12 Mayıs 2013 Pazar

Time-Based Hareket


Bir önceki dersimizde ekrana yeşil kutu çizdirip her bir frame'de pozisyon değiştirerek hareket ettirmiştik.Bu frame-based harekettir ve tamamen kullandığımız bilgisayarın görüntüyü işleme hızına bağlıdır.Bu bağımlılıktan kurtulmak için uygulamamızı time-based hale getireceğiz.Yalnız bu demek değil ki uygulamamız yavaş makinelerde de çok hızlı çalışacak.Biz sadece iki frame arasında geçen süreyi hesaplayarak hareketimizi bu süreye göre belirleyeceğiz.

Bildiğiniz gibi clock nesnesinin  tick fonksiyonu bir oyun döngüsünün ne kadar zamanda icra edildiğini hesaplıyor.Bu bilgiyi kullanarak iki frame arasında geçen süreyi hesaplayalım:

time_passed = clock.tick(FPS)
time_passed_seconds = time_passed/1000.0

Böylece saniye cinsinden döngü süremizi hesaplamış olduk.Şimdi ise bunu move fonksiyonu içerisinde kullanalım.Tabiki move fonksiyonunda bazı düzenlemeler yapmamız gerekiyor.

def move(self,second):
 if self.dir == Direction.DOWNLEFT:
  self.pos.left -= self.pixel_per_second * second
  self.pos.top += self.pixel_per_second * second
        ...

Burada pixel_per_second nesnemizin saniye de kaç pixel hareket edeceğini belirliyor.Ben öntanımlı olarak 100 değerini verdim.Bu değeri artırarak yada azaltarak oyun hızında ki değişimi gözlemleye bilirsiniz.Bu yaptığımız değişiklikle hareketimizi zamana bağlı hale getirmiş olduk.
Bir önceki dersteki kodun aynısını kullandığım için sadece değişiklik yaptığımız kısımları ekliyorum.
def __init__(self):
  ...
 self.pixel_per_second= 100
  ...

def move(self,second):
  ...
   ... -= self.pixel_per_second * second
   ... += self.pixel_per_second * second

  ...
   ... += self.pixel_per_second * second
   ... += self.pixel_per_second * second

  ...
   ... -= self.pixel_per_second * second
   ... -= self.pixel_per_second * second

  ...
   ... += self.pixel_per_second * second
   ... -= self.pixel_per_second * second
...        
time_passed = clock.tick(FPS)
time_passed_seconds = time_passed/1000.0
nesne.move(time_passed_seconds)
...

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 Mayıs 2013 Perşembe

Range() ve Xrange() Fonksiyonu


Bildiğiniz gibi for döngüsüyle kullanabileceğimiz 2 adet fonksiyon var.range ve xrange.Peki bunlar arasındaki fark ne?Hangisini tercih etmeliyiz?
Range fonksiyonu verdiğimiz parametrelere göre bellek üzerinde bir dizi yaratıyor.Yani kullanmasak bile,söz gelimi döngünün bir noktada break ile kesildiğini farzedelim,liste bellekte yer işgal etmeye devam ediyor.
Xrange fonksiyonu ise liste yerine bize xrange nesnesi döndürüyor.Bu nesne ise listeye ilişkin sayı değerlerini belleğe kaydetmeden bize sağlıyor.Peki nasıl oluyor bu?Dökümantasyonda çok detaylı bilgi verilmemiş.Tek bildiğimiz xrange tipi nesnenin dizi uzunluğu ne olursa olsun aynı miktarda bellek kullanması.Yani tek bir adres üzerinden iterasyon yapması.Ufak bir uygulamayla performans farkına bakalım:
import time

def f_range(numb):
    tp = 0
    start = time.time()
    for i in range(numb):
        tp += i
    print "range():%f ms"%(time.time() - start)

def f_xrange(numb):
    tp = 0
    start = time.time()
    for i in xrange(numb):
        tp += i
    print "xrange():%f ms"%(time.time() - start)

if __name__ == '__main__':
    f_range(100000)
    f_xrange(100000)

Sonuç:
range():0.015436 ms
xrange():0.012636 ms

Görüldüğü üzere xrange az da olsa bir performans artışı sağlıyor.Eğer amacımız sadece iterasyon ise xrange kullanmak daha mantıklı.
Yalnız aklımızda bulunsun, Python 3.3'te xrange fonksiyonu çıkartılmış;range ise liste oluşturmak yerine xrange gibi sadece iterasyon yapıyor.

Kaynakça:

8 Mayıs 2013 Çarşamba

Demetler

Demetler
Merhaba arakadaşlar bu yazımızda demetlerden bahsedeceğiz.
Demetler bir önceki konuda Okan arkadaşımızın anlattığı listelerle çok benzerdir. Fakat listelerle arasında küçük ama temel bir fark vardır. Listeleri oluşturduktan sonra veri ekleyip çıkartabilirken demetlerde böyle bir şey yapamıyoruz. Zaten demet denmesinin sebebi de bu. Nasıl günlük hayatta bir demet çiçek bağlandıktan sonra bir daha çözülmüyorsa Python da da aynı durum geçerli :).. Neden listeler gibi daha güçlü bir yapıyı kullanmıyoruz diyorsanız demetler ekleme çıkarma gibi işlemlerle uğraşmadığı için daha hızlı çalışır ve eklenen verilerin program boyunca değiştirilmesini istemiyorsak çok işimize yarar.
Python da demet oluşturma değişken tanımlamaya benzer, hemen bir örnekle gösterelim:

Boş bir demet oluşturma:
>>>demetb=()
>>>
İndisler içeren demet oluşturma:
>>>demet=”Bir”,”Varmış”,1,”Yokmuş
>>>
Evet bu kadar basit mi diyorsanız şu şekilde de yapabilirsiniz isterseniz :) :
>>>demet2=(1,”varmış”,”1”,”yokmuş”)
>>>
Bu oluşturduklarımızın üçü de demet sınıfına girmiş oldu.Bunun kontrolünü şu şekilde yapabiliriz:
>>>type(demet2)
>type tuple="">
>>>
tuple kelimesinin türkçe karşılığı tahmin ettiğiniz gibi demettir :).
Tek öğeli bir demet tanımlamak istersek değişken tanımıyla karşılaşmaması için farklı bir tanımlamaya ihtiyaç duyar:
>>>demet=(“tek”,)
>>>
Demetler böyle basit tanımlamalar dışında şu şekilde bir tanımlamayı da kabul eder:
>>>a = (["kavun", "karpuz", "çilek"],)
>>>
Burada da gördüğünüz gibi demetimizin içinde liste gizlemiş olduk. Yani her ne kadar demetler değiştirilemeyen veri tipleridir desek de içine değiştirilebilir elemanlar alabilir. Burada aslında bir paradoks vardır diyebiliriz :). Şöyle bir tanımlama yapalım:
>>>b=(["kavun", "karpuz", "çilek"],2,3,4,"beş")
Ayrıca tanımlamaları tek tırnak kullanarak da yapabiliriz arkadaşlar.Gördüğümüz gibi demetimizin birinci öğesi bir liste bu öğelere şu şekilde ulaşabiliriz:
>>b[indisno]
>>>b[0]
['kavun', 'karpuz', 'çilek']
>>>
Eğer listenin içindeki herhangi bir elemana erişmek istiyorsak:
>>>b[0][2]
'çilek'
>>>
Bu b[0] elemanımız bir liste olduğu için listelerin tüm metodlarını bu indis için kullanabiliriz:
>>>b[0].append('muz')
>>>b[0]
(['kavun', 'armut', 'erik', 'muz'],2,3,4,'beş')
>>>
Demetlerin Metodları Demetlerde ekleme çıkarma gibi işlemler olmadığı için sadece iki basit metodu vardır.Bunlardan birincisi demette yer alan öğemizin sırasını bulmaya yarayan “index()” metodu, bir diğeri de belirttiğimiz elemanın demet içerisinde kaç defa tekrar ettiğini bulmaya yarayan “count()” metodudur. Şimdi bu metodların nası kullanıldığını görelim: index() metodu
>>>demet=('Lale','Gül','Papatya','Papatya')
>>>demet.index('Gül')
1
>>>
Yani Gül kelimesi birinci indiste yer alıyormuş index metoduna ikinci bir parametre ekleyibiliriz:
>>>demet.index('Papatya',2)
3
>>>
Bu komutla Python a şunu demiş oluyoruz “Papatya kelimesinin ikinci defa geçtiği indis numarasını bana ver.”. count() metodu
>>>demet=('Dergi','Gazete','Dergi','Dergi',0,0,0)
>>>demet.count(0)
3
>>>
Bu yazdığımız ise 0 dan kaç adet bulduğunu sonuç olarak gönderdi bize. İki metodun kullanımı işte bu kadar basit. Son olarak Python daki demetleme ve demet çözme denilen kavramlardan bahsedelim. Demetleme dediğimiz aslında demet tanımla demektir demet çözme ise bir demeti tek tek değişkenlere yerleştirme işlemidir. Şöyle ki:
>>>demet=(["kavun", "karpuz", "çilek"],2,3,4,"beş")
>>>a,b,c,d,e=demet
İkinci satırdaki komutumuz her harfe atama yaparak elimizde farklı türlerde değişkenler oluşturmuş olduk. 'a' artık bir liste, 'b,c,d' integer , 'e' de bir string değişken olmuş oldu. Demetlerle ilgili yazımızda bu kadardı arkadaşlar. Bir daha yazıda görüşmek üzere :).

7 Mayıs 2013 Salı

KARAKTER DİZİLERİ


Bu bölümde birçok programlama dilinde olduğu gibi Python dilinde de sıkça kullanılan Karakter Dizilerinden (string) bahsedeceğiz.

Python'da karakter dizilerini ifade etmek için yapmamız gereken tek şey, ifademizi tırnak ("") içinde belirtmektir. Python'da tırnak içerisinde belirtilen her şey karakter dizisi
olarak kabul edilir.Bir örnek vermemiz gerekirse;

>>>"Python"
'Python'

Şimdi bu ifadenin türünü öğrenmek için daha önceden öğrendiğimiz type fonksiyonumuzu kullanalım.

>>>type("Python")
type 'str'

Gördüğümüz gibi tırnak içerisinde belirttiğimiz "Python" ifadesinin türü str yani stringtir. Peki ifademizi tırnak içerisinde yazmasaydık ne olurdu? Deneyip görelim;
>>>type(Pyhton)
Traceback (most recent call last):
File "", line 1, in 
NameError: name 'Pyhton' is not defined

Gördüğümüz üzere ifademizi tırnak içinde yazmadığımız için derleyici onu string olarak görmedi ve tanımlanamadığına dair hata verdi.

Tırnak içerisinde yazdığımız her ifade string olarak tanımlanır dedik. Bunu şöyle bir örnekle daha iyi kavrayabiliriz.

>>>a=5
>>>type(a)
type 'int'

Burada a değişkeninin türü integer olarak verildi. Peki biz bu ifadeyi tırnak içerisinde yazarsak ne olur?

>>>a="5"
>>>type(a)
type 'str'

a değişkenine atadığımız değeri tırnak içerisinde gönderdiğimiz için type'ı str yani string'tir. Buradan da anlaşılacağı üzere Python'da tırnak içerisinde girilen her değer string'tir.
Aynı ifadeyi şöyle de yazabilirdik.

>>>a=5
>>>type("a")
type 'str'


Burada da type fonksiyonunun içinde a değişkenini string olarak çağırmış olduk.

Yazdığımız stringleri ekrana çıkartmak için çok alışkın olduğumuz "print" komutunu kullanacağız.

>>>print "Pyhton Dersleri"
Pyhton Dersleri

Burada derleyici iki iş yapıyor. Birincisi tırnak içerisinde yazılan stringi okuyor. İkincisi "print" fonksiyonuyla okuduğu string'i ekrana yazdırıyor.Biz bu string'i

>>>"Pyhton Dersleri"
'Pyhton Dersleri'


şeklinde yazdığımızda da görebiliyoruz ancak derleyici burda sadece string'i okuma işlemini yapıyor ekrana yazdırmıyor. İlerde kodlarımızı bir dosyaya kaydedip çalıştırdığımızda
yukarıdaki kodun ekrana hiçbir şey yazdırmadığını göreceksiniz.


Karakter dizilerini kullanırken dikkat etmeniz gereken en önemli nokta tırnak işareti kullanımıdır. Stringimizi yazarken ister çift tırnak(""), ister tek tırnak(''), istersek
üç tırnak("""""") kullanabiliriz. Hangi tırnak işaretini kullandığımızın çok da bir önemi yoktur. Önemli olan başladığımız tırnak işaretini aynı şekilde kapatmamızdır.

Gelin örneklerimize çift tırnak kullanımı ile başlayalım.

>>>print "Python'da karakter dizileri (string) çalışıyoruz."
Python'da karakter dizileri (string) çalışıyoruz.

Burada çift tırnak kullandığımızda yazdığımız string ifadesi hata vermeden çalıştı. Peki bunu tek tırnakla yazarsak

>>>print 'Pyhton'da karakter dizileri (string) çalışıyoruz.'
File "", line 1
print 'Pyhton'da karakter dizileri (string) çalışıyoruz.'
              ^
SyntaxError: invalid syntax


şeklinde bir hata ile karşılaşırız. Bunun sebebi "Pyhton'da" ifadesindeki tek tırnak işaretinden kaynaklanıyor. Derleyici burada kullandığımız tek tırnağı başlangıçta açtığımız
tırnağın kapanışı olarak düşündüğünden, ifadenin devamını okumakta sorun yaşar ve hata verir. Bunu ortadan kaldırmak için çift tırnak kullanabileceğimiz gibi

>>>print 'Pyhton\'da karakter dizileri (string) çalışıyoruz.'
Pyhton'da karakter dizileri (string) çalışıyoruz.


"\" işaretini de kullanabiliriz. Eğer ekrana yazdırmak istediğimiz ifade " (tırnak) içeriyorsa, tırnak işaretinin önüne "\" sembolü konularak tırnak işaretini ekrana yazdırabiliriz.

Üç tırnak kullanımı ise biraz daha özel durumlar içindir.

>>>print """Python'da "karakter dizileri" (string) çalışıyoruz."""
Python'da "karakter dizileri" (string) çalışıyoruz.


Bu örnekte gördüğümüz gibi üç tırnak içinde hem "Pyhthon'da" ifadesinde yer alan tek tırnağı hem de "karakter dizileri" ifadesinde yer alan çift tırnağı ekrana çıkartmış olduk.

Üç tırnağın bir diğer avantajı ise alt alta yazmak istediğimiz ifadeleri rahatlıkla yazabilmemizdir.

>>>print """
...Python Konuları
...1)listeler
...2)demetler
...3)fonksiyonlar
...4)karakter dizileri(string)
..."""

Bu örneğimizde üç tırnaktan sonra gelen üç nokta (...) Python'ın bizden komut girmemize devam etmemiz gerektiğini ifade ediyor. Bu örneğimizin ekran çıktısı ise;

Python Konuları
1)listeler
2)demetler
3)fonksiyonlar
4)karakter dizileri(string)

şeklinde olur.

Tabii üç tırnakta yaptığımız bu tarz bir listeleme şeklini çift veya tek tırnak ile yapamayız.

KARAKTER DİZİLERİNİ BİRLEŞTİRMEK


Python'da karakter dizilerini birleştirmek için sıkça kullandığımız yöntemlerden birisi "+" işaretidir.Bu konuya bir örnek ile açıklık getirelim:

>>>ad = "Sultan"
>>>soyad = "Düzgün"
>>>adSoyad = ad + soyad
>>>print adSoyad
SultanDüzgün

Gördüğümüz gibi ad isimli karakter dizisine soyad isimli karakter dizisini de ekledik. Karakter dizilerinin arasında boşluk bırakmak istersek eğer ;

>>>ad = "Sultan"
>>>soyad = "Düzgün"
>>>bosluk = " "
>>>print ad + bosluk + soyad
Sultan Düzgün


aynı yöntemle boşluk ekleyebiliriz.

Daha önceki yazılarda öğrendiğiniz fonksiyonlardan yararlanarak şöyle bir örnek yapabiliriz.

>>>a = ""
>>>for i in range(10):
... a += str(i)
...
>>>print a
0123456789

Karakter dizilerini birbirine eklerken kullandığımız diğer bir yöntem ise "," işaretidir.

>>>ad = "Sultan"
>>>soyad = "Düzgün"
>>>print ad,soyad
Sultan Düzgün


Burada karakter dizilerinin arasında otomatik olarak bir boşluk bırakıyor. Bu "," işaretinin bir özelliğidir. Eğer boşluk karakterini kendimiz eklemek istersek "," işaretini
kullanacağız. Zaten karakter dizilerini birbirine eklemede en çok kullanılan yöntem de budur.

Şimdi biraz daha gelişmiş bir örnek yazalım. Bu örneğimizde bilgisayarımızın işletim sistemi ile ilgili birkaç bilgi alabileceğiz. Örneğimizde "os.environ" sözlüğünden yararlanacağız.
Bu sözlük sayesinde bir takım anahtar-değer çiftlerini ekrana yazdırabileceğiz.

# -*- coding: cp1254 -*-

import os

print "Kullanıcı adı:  ", os.environ["USERNAME"]
print "Bilgisayar adı: ", os.environ["COMPUTERNAME"]
print "Ev dizini:      ", os.environ["HOMEPATH"]
print "İşlemci:        ", os.environ["PROCESSOR_IDENTIFIER"]
print "İşlemci sayısı: ", os.environ["NUMBER_OF_PROCESSORS"]
print "İşletim sistemi:", os.environ["OS"]

Bu koddan sonra bilgisayarınıza ve kullandığınız işletim sistemine göre farklı sonuçlar alacaksınız. Benim aldığım sonuçlar şöyle;

Kullanıcı adı:   DELL
Bilgisayar adı:  PC
Ev dizini:       \Users\DELL
işlemci:         Intel64 Family 6 Model 58 Stepping 9, GenuineIntel
işlemci sayısı:  4
işletim sistemi: Windows_NT


Karakter dizileri hakkında bilmemiz gereken şeylerden biri de değiştirilemez olmalarıdır. Listeler konusundan da hatırlayacağımız gibi oluşturduğumuz bir listeye yeni
bir eleman ekleyebiliyorduk veya eleman çıkarabiliyorduk. Ancak böyle bir şeyi karakter dizilerinde yapamayız. Örneğin;

>>>a = "Sultan"
>>>a + "Düzgün"
>>>print a
Sultan

Ekran çıktımız karakter dizisinin ilk hali olarak çıktı. Buradan da anlayacağımız gibi bir karakter dizisine yeni bir eleman ekleyeceksek o elemanı diziye atamalıyız.

>>>a = "Sultan"
>>>a += "Düzgün"
>>>print a                                              
SultanDüzgün

KARAKTER DİZİLERİNİ DİLİMLEMEK


Bazen karakter dizilerini dilimleyerek kullanmak zorunda kalabiliriz. Bunun için yapmamız gereken işlem karakter dizisinde dilimlenecek kısmı işaret etmek. Basit bir örnek
verirsek:

>>>a = "Python"
>>>print a[0]
>>>print a[2]
>>>print a[-1]
>>>print a[-3] 
P
t
h
n

Karakter dizilerini dilimleme yöntemini listeleri dilimlerken de kullanabiliriz.

>>>liste = ["Python","çalışıyor","ve","öğreniyoruz"]
>>>print liste[1]
>>>print liste[-1]
>>>print liste[0]
>>>print liste[3] 
çalışıyor
öğreniyoruz
Python
öğreniyoruz

Bu yöntemi kullanarak karakter dizilerine baştan ve sondan olmak üzere sınırlama getirerek bölebiliriz.

>>>a = "Python"
>>>print a[1:4] 
yth

Eğer karakter dizisini baştan başlayıp belli bir kısma kadar bölmek istersek;

>>>a = "Python"
>>>print a[0:4] 
Pyth

yazabiliriz. Veya sıfırı hiç koymayız.

>>>a = "Python"
>>>print a[:4] 
Pyth


En baştan dilimlemeye başlayacağını sıfır yazarak veya o kısmı boş bırakarak ifade edebiliriz. Aynı şekilde karakter dizisini baştan belli bir yerden başlayıp sonuna kadar
yazabiliriz.

>>>a = "Python"
>>>print a[2:] 
thon


Gördüğümüz gibi baştan sınırladığımız yerden başlayıp karakter dizisinin sonuna kadar yazdırmaya devam etti.

Daha farklı bir örnekle devam etmemiz gerekirse;

>>>a = "Python öğreniyoruz."
>>>print a[2:10:2] 
to g

Bu örnekte yaptığımız şey ise karakter dizisinin ikinci elemanından başlayıp onuncu elemanına kadar ikişer ikişer atlayarak yazdırmak.

>>>a = "Python öğreniyoruz."
>>>print a[::3] 
Ph rir.

Bu örnekte de karakter dizisinin başından sonuna kadar üçer üçer atlayarak yazdırdık. Bunu şöyle de yazdırabiliriz.

>>>a = "Python öğreniyoruz."
>>>print a[0:len(a):3]
Ph rir.


Buradaki len bildiğiniz gibi tüm karakter dizisinin başından sınırlanan kısım ile sonuna kadar olan yeri ifade ediyor.

Eğer yazdığımız karakter dizisini tersten yazmak istersek bunu da dilimleme yöntemi ile yapabiliriz.

>>>a = "Python öğreniyoruz."
>>>print a[::-1]
.zuroyinerğö nohtyP

Şu ana kadar öğrendiklerimizi bir örnekte toplayacak olursak:

# -*- coding: utf-8 -*-

liste = ["http://www.python.org",
"http://www.istihza.com",
"http://www.google.com",
"http://www.yahoo.com"]

   for i in liste:
      print "ftp" + i[10:]

ftp.python.org
ftp.istihza.com
ftp.google.com
ftp.yahoo.com

Örnekte gördüğümüz gibi liste elemanlarımızın başında olan "http://" ifadesi yerine "ftp" ifadesini getirdik.

BÜYÜK-KÜÇÜK HARF DEĞİŞİMİ


Python'da en önemli durumlardan biri de yazdığımız stringlerde büyük-küçük harf kullanımı. Python'da harf durumlarını değiştirmek için beş farklı yöntemimiz var. Teker teker
bunları inceleyelim.

1)capitalize()


Bu metodu karakter dizilerinin ilk harfini büyütmede kullanıcaz.Örneğin;

>>>a = "python"
>>>print a.capitalize()
Python

Listelerde de her elemanın ilk harfini büyütmek için bu metoddan yararlanabiliriz.

>>>liste = ["korsan","değil","özgür","yazılım"]
>>>for i in liste:
...print liste.capitalize()
...
   
Korsan
Değil
Özgür
Yazılım

Ancak karakter dizimiz birkaç kelimeden oluşuyorsa sadece ilk harfi büyütebiriz.

>>>a = "korsan değil özgür yazılım"
>>>print a.capitalize()
Korsan değil özgür yazılım

2)title()


Karakter dizisindeki tüm kelimelerin ilk harfini büyük yazmamızı sağlayan bir metoddur.Örneğin;

>>>a = u"korsan değil özgür yazılım"
>>>print a.title()
Korsan Değil Özgür Yazılım

Kodumuzu yazarken stringimiz öncesinde kullandığımız "u" harfi stringin Türkçe karakterlere daha uyumlu bir şekilde yazılmasını sağlar.

3)upper()


Bu metod sayesinde yazdığımız tüm karakter dizisini ekrana büyük harflerle çıkartabileceğiz.

>>>a = "python"
>>>print a.upper()
PYTHON

>>>b = u"korsan değil özgür yazılım"
>>>print b.upper()
KORSAN DEĞİL ÖZGÜR YAZILIM

4)lower()


Bu metod ise upper() metodunun tam tersi işlem yapar. Yani büyük harfle yazdığımız karakter dizisinin ekran çıktısını küçük harflerle yapar.

>>>a = "PYTHON"
>>>print a.lower()
python
>>>b = u"KORSAN DEĞİL ÖZGÜR YAZILIM"
>>>print b.lower()   
korsan değil özgür yazılım

5)swapcase()


Bu metodu upper() ve lower() metodlarının birleşimi gibi düşünebiliriz. Bu metod sayesinde karakter dizisindeki küçük harf büyük harfle, büyük harf ise küçük harfle
ekrana yazdırılır.

>>>a = "python"
>>>print a.swapcase() 
PYTHON
>>>b = "PYTHON"
>>>print b.swapcase()
python
>>>c = "pYtHoN"
>>>print c.swapcase()
PyThOn

BÜYÜK-KÜÇÜK HARF VE BOŞLUK SORGULAMA


Biraz öğrendiğimiz birkaç metodla yazdığımız karakter dizilerinde harf düzenlemesi yapabildik. Şimdi öğreneceğimiz birkaç metodla ise yazdığımız karakter dizilerinde büyük-küçük
harf durumlarını kontrol edeceğiz. Eğer kontrollerimiz doğru olursa bize "true", "yanlış" olursa false değeri dönecek.

1)islower()


Bu metodla karakter dizimizin tamamen küçük harften oluşup oluşmadığını kontrol edeceğiz.

>>>a = "python"
>>>a.islower() 
True
>>>b = "Korsan değil özgür yazılım"
>>>b.islower()
False

2)isupper()


Bu metod sayesinde karakter dizimizin tamamen büyük harften oluşup oluşmadığını inceleyeceğiz.

>>>a = "PYTHON"
>>>a.isupper()
True
>>>b = "Korsan DEĞİL Özgür Yazılım"
>>>b.isupper()
False

3)istitle()


Bu metod ise yazdığımız karakter dizisinin ilk harflerinin büyük olup olmadığını kontrol eder.

>>>a = "Korsan Değil Özgür Yazılım"
>>>a.istitle()
True
>>>b = "Python öğreniyoruz."
>>>b.istitle()   
False

4)isspace()


Bu metod ise yazdığımız karkater dizisinin tüm karakterlerinin boşluktan oluşup oluşmadığını kontrol edecek.Örneğin;

>>>a = "        "
>>>a.isspace()
True
>>>b = "Korsan değil özgür yazılım"
>>>b.isspace()
False
>>>c = ""
>>>c.isspace()
False


Şimdi birazda yukarıda karakter dizilerini yazarken neden "u" harfini kullandığımızdan bahsedelim. "u" harfi "unicode" anlamına gelmektedir. Yazdığımız karakter dizilerinde
Türkçe karakterlerin ekran çıktısında bir sıkıntısı olmasın diye kullandığımız bir terimdir.Örneğin;

>>>a = "şekerli çay"
>>>a.capitalize()
şekerli çay


Burada capitalize fonksiyonu karakter dizisinin ilk harfini büyütmeliydi ama "ş" harfi Türkçe karakter olduğu için gerçekleştiremedi. Biz bu karakter dizisini "unicode" olarak
belirtirsek;

>>>a = u"şekerli çay"
>>>a.capitalize()
Şekerli çay

sorunu ortadan kaldırmış oluruz.

>>>a = "Gün Python Çalışma Günüdür"
>>>a.istitle()
False

Normalde True dönmesi gereken bir kod olamasına rağmen içeriğinde Türkçe karakterler olduğu için False döndü. Bunu da ortadan unicode özelliği ile kaldırabiliriz.

>>>a = u"Gün Python Çalışma Günüdür"
>>>a.istitle()
True


Unicode özelliği her zaman Türkçe karakterleri ifade etmede doğru şekilde çalışmaz. Örneğin "i" harfini "İ" şeklinde büyütmez. Tam tersi de geçerlidir. Yani "I" harfini "ı" diye
küçültmez.Örnek verirsek daha iyi anlayacağız sanırım.

>>>a = u"şekerli çay"
>>>print a.upper()
ŞEKERLI ÇAY

Gördüğümüz gibi "i" harfini "I" olarak büyüttü.

>>>a = u"ISLIK"
>>>print a.lower()
islik

Burada da "I" harfini "i" olarak küçülttü.

SAĞA SOLA YASLAMA İŞLEMLERİ VE SIFIRLA DOLDURMA


Karakter dizilerini ekrana yazdırdığımızda çıktının nerede olacağını belirlemek için birkaç metod kullanırız.

1)center()


center() metodu bir karakter dizisini ortalamak için kullanılır.Örneğin;

>>>a = "python"
>>>print a.center(15) 
python


Bu örnekte yaptığımız karakter dizimizi istediğimiz uzunluk içerisinde ortalayarak yazmak. 15 sayısıyla ifade ettiğimiz şey ise bu örnek için 6+9 dur. Yani saydığımız
stringin uzunluğu + boşluk sayısı.

center() metodunda istediğimiz işareti stringimizin yanına ekleyebiliriz. Şöyleki;

>>>a = "python"
>>>print a.center(15,"#")
#####python####


Bu örnekte de boşluk yerine istediğimiz bir işarete yer verdik.

Bu örneğimizi şöyle de yazabiliriz.

>>>"python".center(15,"#")
#####python####

Eğer belirttiğimiz sayı karakter dizimizin uzunluğundan küçük ise boşluk bırakılmaz veya istediğimiz işaret koyulmaz.

>>>"python".center(5)
'python'

veya

>>>"python".center(5,"#")
'python'

2)ljust()


Bu metod yazdığımız karakter dizilerini sola yaslar. Boşluk veya istenilen işareti ise sağa doğru yerleştirir.Örneğin;

>>>"python".ljust(15)
'python         '

Gördüğümüz gibi yazı soldan başlanarak yazdırıldı boşluk ise sağa doğru bırakıldı.

>>>"python".ljust(15,"#")
'python#########'

3)rjust()


Bu metod ise karakter dizilerini sağa yaslar boşluk veya herhangi bir karakteri ise sola doğru yazdırır.

>>>"python".rjust(15)
'         python'

veya

>>>"python".rjust(15,"#")
'#########python'

Şimdi bu öğrendiklerimizi bir örnekte toplarsak:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

distro = ["Ubuntu", "Python", "SuSe", "Pardus",
  "Fedora", "Linux", "Özgür", "Yazılım",
  "Red Hat", "PC", "Gelecek", "Kali"]

             for k, v in enumerate(distro):
                  if k % 4 == 0:
           print
  print "%s"%(v.ljust(15)),

Bu örneğin ekran çıktısı:

Ubuntu         Python         SuSe           Pardus
Fedora         Linux          Özgür          Yazılım
Red Hat        PC             Gelecek        Kali

Yazdığımız kodda ljust() metodunu kullandığımız için ekran çıktısı sola yaslanmış şekilde ortaya çıktı.

4)zfill()


Bu metod sayesinde karakter dizimizin başına istediğimiz kadar "0" koyabiliyoruz.

>>>sayi = "5"
>>>sayi.zfill(3)
005

KARAKTER DEĞİŞTİRMİ


replace()


Bu metod sayesinde yazdığımız karakter dizisindeki herhangi bir harfi değiştirebilir veya silebiliriz.Bu metodun kullanım şekli:

karakter_dizisi.replace("eski_karakter","yeni_karakter")

Örnek vermemiz gerekirse;

>>>a = "Korsan Değil Özgür Yazılım"
>>>print a.replace("a","ş")
Korsşn Değil Özgür Yşzılım


Örnekte "a" harfi yerine "ş" harfi yazdık.
Eğer kaç tane karakter üzerinde değişiklik yapacağımızı bellirtmek istiyorsak;

>>>a = "Korsan Değil Özgür Yazılım"
>>>print a.replace("a","ş",1)
Korsşn değil Özgür Yazılım 


Burada da gördüğümüz gibi ilk "a" harfi yerine "ş" geldi fakat ikinci "a" harfi aynı şekilde kaldı. Çünkü biz kodumuzda 1 tane "a" harfinin değiştirilmesini istedik.

Eğer karakter dizimizden harf sildirmek istersek bunun için de ;

>>>a = "Korsan Değil Özgür Yazılım"
>>>print a.replace("a","")
Korsn Değil Özgür Yzılım

KARAKTER DİZİLERİNİN BAŞLANGIÇ VE BİTİŞ DEĞERLERİNİ SORGULAMAK


Bu kısımda yazdığımız karakter dizilerinin başlangıç ve bitiş değerlerini nasıl inceleyeceğimizi öğreneceğiz. Örneklerle daha iyi açıklayabiliriz.

1)startswith()


Karakter dizilerinin başlangıç harfini incelememizi sağlayacak olan metoddur.

>>> a = "python"
>>> a.startswith("p")
True

Karakter dizimizin ilk harfi "e" olduğu için true değeri döndü.

>>> a = "python"
>>> a.startswith("c")
False


Karakter dizimizin ilk harfi "c" olmadığı için false değeri döndü.

Bu metodu liste yönteminde de kullanabiliriz. Daha geniş bir örnek verirsek:

>>> liste = ["elma","erik","kiraz","kestane","portakal"]
>>> for i in liste:
...if i.startswith("e"):
...i.replace("e","a")
...if i.startswith("k"):
    i.replace("k","s")
     
alma
arik
siraz
sestane

Bu örneğimizde ise hem liste elemanlarının baş harflerine göre seçtik hem de seçtiğimiz elemanlarının başharflerini önceden öğrendiğimiz replace() metoduyla değiştirdik.

2)endswith()


Karakter dizilerinin son harflerini incelememizi sağlayacak olan metoddur. Örneğin;

>>> a = "python"
>>> a.endswith("n")
True

Karakter dizimizin son harfi "n" ile bittiği için true değerini döndürdü.

>>> a = "python"
>>> a.endswith("b")
False


Karakter dizimiz "b" harfi ile bitmediği için false değerini döndü.

Şimdi listelerden bir örnek verelim:

>>> liste = ["korsan","değil!","özgür","yazılım!"]
>>> for i in liste:
... if i.endswith("!")
... i.replace("!","")
  
değil
yazılım

Örnekte yaptığımız şey listedeki "!" ile biten elemanların son karakterini silip ekrana yazdırmak.

KARAKTER DİZİLERİNİ SAYMA


count()


Bu metodla karakter dizimizin sayımını yapabiliyoruz. Mesela yazdığımız bir karakter dizisinin içinde bir hrfte kaç tane olduğunu bu metodla öğrenebiliriz. Bir örnekle
daha iyi anlayabiliriz.

>>> a = "korsan değil özgür yazılım"
>>> a.count("a")
2

Yazdığımız karakter dizisinde "a" harfinden iki tane bulunduğu için sonuç 2 olarak döndü. Gelin şimdi de girdiğimiz bu karakter dizisinde her harften kaç tane olduğunu bulalım.

# _*_ coding:utf-8 _*_
  
while True:
  
#kullanıcıdan bir karakter dizisi alıp bu dizideki boşlukları replace() ile silmek
#Böylece karakter dizisindeki tüm herfleri ele alabilceğiz.
   
a = raw_input("karakter dizinizi giriniz:").replace(" ","")
   
#şimdi ise karakter dizisindeki birden fazla olan harfleri teke indireceğiz.
   
b = a(set)
   
#son olarak b dizisi içindeki harflerin kaç tane olduğunu ekrana yazdırıyoruz.
   
    for i in b:
      print "%s harfinden  = %s tane var." %(i,a.count(i))


Bu örneğimizin ekran çıktısı:

karakter dizinizi giriniz:

Şimdi herhangi bir karakter dizisi üzerinden yola çıkalım.

karakter dizinizi giriniz:korsan değil özgür yazılım

Burada a dizisi "korsandeğilözgüryazılım" şeklini alır. Daha sonra b dizisi devreye girer. b dizisi ise "korsandeğilözgüryzılm" şeklini alır. Ekran çıktımız ise:

a harfinden = => 2 tane
e harfinden = => 1 tane
d harfinden = => 1 tane
g harfinden = => 1 tane
i harfinden = => 1 tane
k harfinden = => 1 tane
m harfinden = => 1 tane
l harfinden = => 2 tane
o harfinden = => 1 tane
n harfinden = => 1 tane
ğ harfinden = => 1 tane
s harfinden = => 1 tane
r harfinden = => 2 tane
ö harfinden = => 1 tane
y harfinden = => 1 tane
z harfinden = => 2 tane
ı harfinden = => 2 tane
ü harfinden = => 1 tane


KARAKTER DİZİLERİNİN NİTELİĞİNİ SORGULAMA

Bu kısımda bir karakter dizisinin alfabetik mi nümerik mi yoksa alfanümerik mi olduğunu inceleyeceğimiz metodlar kullanacağız. Hemen örneklerle başlayalım.


1)isalpha()


Bu metod girdiğimiz karakter dizisinin alfabetik olup olmadığını inceler. Eğer alfabetik bir karakter dizisi girmişsek true girmemişsek false değerini döndürür. Bir örnekle
açıklayalım.

>>> "python".isalpha()
True

Burada "python" alfabetik bir karakter dizisi olduğu için true değeri döndü.

>>> "1020".isalpha()
False

Bu örnekte ise "1020" dizisi nümerik olduğu için false değeri döndü.

>>> "pythondersleri.com".isalpha()
False


Burada ise "." karakteri alfabetik bir değer olamdığı için false değeri döndü. Yani bir karakter dizisinin alfabetik olması için tüm karakterlerin alfabetik olması gerekir.
Arada boşluk karakteri bile olmamalıdır.

>>> "python dersleri".isalpha()
False 

Alfabetik karakterleri sorgularken yazdığımız karakter dizilerinin Türkçe karakterlerden dolayı hata vermemesi için unicode olarak tanımlamamızda yarar vardır. Örneğin;

>>> "şeker".isalpha()
False


False değeri döndü çünkü "ş" harfi Türkçe karakter olduğu için alfabetik karakter olarak tanımlamadı. Eğer karakter dizisini unicode olarak tanımlarsak bu sorunu ortadan
kaldırmış oluruz.

>>> u"şeker".isalpha()
True

2)isdigit()


Bu metod ise girdiğimiz karakter dizisinin nümerik olup olmadığını kontrol etmemize yarar.
>>> "1020".isdigit()
True
>>> "python".isdigit()
False

Bu metodla da boşluk veya herhangi bir karakter kullanıldığında false değeri döner.

>>> "1020 15".isdigit()
False

veya

>>> "1020.15".isdigit()
False

3)isalnum()


Bu metod ise karakter dizisinin alfanümerik olup olmadığını inceler. Her alfabetik ya da nümerik karakter aynı zamanda alfanümerik bir karakterdir. (Tam tersi geçerli değildir.

>>> "python".isalnum()
True
>>> "1020".isalnum()
True
>>> "python1020".isalnum()
True


Gördüğümüz gibi alfabetik ve nümerik karakterleri bir arada kullanabiliyoruz.

Şimdi öğrendiğimiz üç metodu da daha iyi kavramak için bir örnek yapalım.

>>> for i in "python1020_?dersleri":
... if i.isalpha():
...         print "%s karakteri alfabetik karakterdir." %i
... elif i.isdigit():
...     print "%s karakteri nümerik karakterdir." %i
... else:
...     print "%s karakteri özel karakterdir." %i
...
  
p karakteri alfabetik karakterdir.
y karakteri alfabetik karakterdir.
t karakteri alfabetik karakterdir.
h karakteri alfabetik karakterdir.
o karakteri alfabetik karakterdir.
n karakteri alfabetik karakterdir.
1 karakteri nümerik karakterdir.
0 karakteri nümerik karakterdir.
2 karakteri nümerik karakterdir.
0 karakteri nümerik karakterdir.
_ karakteri özel karakterdir.
? karakteri özel karakterdir.
d karakteri alfabetik karakterdir.
e karakteri alfabetik karakterdir.
r karakteri alfabetik karakterdir.
s karakteri alfabetik karakterdir.
l karakteri alfabetik karakterdir.
e karakteri alfabetik karakterdir.
r karakteri alfabetik karakterdir.
i karakteri alfabetik karakterdir.

Ekran çıktımız bu şekilde olacaktır. Buradaki alfabetik ve nümerik karakterler aynı zamanda alfanümeriktirler. Ancak özel karakterler bu kapsam içine girmezler.

SEKME BOŞLUKLARINI GENİŞLETME


expandtabs()


Yazdığımız bir karakter dizisinde ne kadar boşluk bırakmak istediğimizi belirtebileceğimiz bir metoddur.
>>> a = "Korsan\tdeğil\tözgür\tyazılım"
>>> print a.expandtabs(5)  
Korsan     değil     özgür     yazılım

Gördüğümüz gibi karakterlerin arasında 5 tane boşluk bırakabildik.

KARAKTER KONUMU BULMA

Bu kısımda yazdığımız karakter dizisinde bir karakterin konumunu bulmada kullanacağımız metodları öğreneceğiz. Sırayla başlayalım.


1)find()


Bu metod karakter dizimizdeki herhangi bir karakterini bulmada yardımcı olur bize. Bu metod karakter dizilerini soldan sağa doğru okur. Bir örnekle açıklayalım.

>>> a = "ekmek"
>>> a.find("e") 
0


"t" harfi karakter dizimizde 2. indeksli karakter olduğu için "2" değeri geri döndü.

Eğer aradığımız arf karakter dizimizde bulunmuyorsa "-1" değeri döner. Örneğin;

>>> a = "python"
>>> a.find("s") 
-1


Bu metodla istediğimiz aralık içerisinde de arama yapabiliriz. Bunun için kullanacağımız ifade;

"karakter_dizisi".find("aranacak_karakter",baslangıç_değeri,bitiş_değeri)



>>> a = "python"
>>> a.find("h",2,5) 
3

2. ve 5. indeks arasında "h" harfi 3. indeste yer alıyor.

2)rfind()


Bu metod find() metodu ile aynı işlemleri yapar. Tek farkı karakter dizilerini sağdan sola doğru okur.

>>> a = "ekmek"
>>> a.rfind("e") 
3


Bu örneği yukarıda find() metodu ile yaptığımızda bize 0 değerini döndürmüştü. Çünkü find() metodu karakter dizisini soldan sağa doğru okur. Bu örneğimizde ise rfind() metodu
kullandığımız için 3 değeri döndü. Çünkü rfind() metodu karakter dizisini sağdan sola doğru okudu ve karşısına ilk çıkan "e" harfinin indeksini değer olarak döndürdü.

3)index()


Bu metod find() metodu ile aynı işi yapıyor. Tek farkı karakter dizisinde olmayan eleman girdiğimizde "-1" değeri yerine hata mesajı döndürmesidir.

>>> a = "ekmek"
>>> a.index("e") 
0

>>> b = "python"
>>> b.index("s") 
Traceback (most recent call last):
File "", line 1, in 
ValueError: substring not found

4)rindex()


Bu metod da index() metodu ile aynı işi yapıyor. Tek farkı karakter dizisini sağdan sola doğru okuması.

>>> a = "ekmek"
>>> a.rindex("e") 
3

Bu metod da olmayan bir karakteri aradığımızda hata mesajı döndürür.

>>> b = "python"
>>> b.rindex("s") 
Traceback (most recent call last):
File "", line 1, in 
ValueError: substring not found

a)join()


Bu metodu yazdığımız karakter dizilerinin arasına bişey koymak istediğimiz zaman kullanacağız. Şöyleki:

>>> a = "Python"
>>> ".".join(a)
P.y.t.h.o.n


Dikkat edersek yadığımız kodda "a.join()" diye bir ifade kullanmadık. Çünkü bu metodu kullanırken uygulayacağımız işareti önce, hangi karakter dizisine uygulayacağımızı ise
parantez içerisinde belirtiyoruz.

Bu metodu listelerde de kullanabiliriz.
>>> liste = ["Korsan","değil","özgür","yazılım"]
>>> print ";".join(liste)
Korsan;değil;özgür;yazılım

Daha dinamik bir örnek verirsek;

>>> liste = ["C:","Program Files","Python"]
>>> print "\\".join(liste) 
C:\\Program Files\\Python

KARAKTER DİZİLERİNİ PARÇALARA AYIRMA


Karakter dizilerini parçalara ayırmada iki yöntem kullanacağız.

1)partititon()


Bu metodu kullanarak bir karakter dizisini üç parçaya bölebiliyoruz. Bu metod karakter dizisini soldan sağa okur.

>>> a = "adana"
>>> a.partition("a")
('','a','dana')

Eğer yazdığımız karakter ifademizde yoksa şu şekilde bir ayırma işlemi yapıyor.

>>> b = "python"
>>> b.partition("a") 
('python','','')

2)rpartition()


Bu metod partition() metodu ile aynı aynı işe yapar. Tek farkı karakter dizilerini sağdan sola doğru okumasıdır.

>>> a = "adana"
>>> a.rpartition("a") 
('adan','a','')

KAYNAKLAR





Listeler

Listeler, içerisinde farklı türden verileri barındırabilen taşıyıcılardır. Python'ı güçlü kılan özelliklerden biri
olan listelerde, her bir eleman bir indis (index) numarasına sahiptir ve bir listenin başlangıç indisi 0 (sıfır)'dır.

Şimdi bir listeyi nasıl oluşturabileceğimizi inceleyelim:

liste = []

Her veri yapısının tanımında olduğu gibi listelerin tanımında da önce bir değişken adı verip, daha sonra bu
değişkene çeşitli atamalar yaparak listemizi oluşturmuş olduk. Yukarıdaki örnekte oluşturduğumuz liste içerisine eleman eklemediğimiz için bu liste içi boş bir listedir. Şimdi ise başlangıçta elemanları belli olan bir liste tanımlayalım:

liste1 = ['p','y','t','h','o','n']


Yukarıda oluşturduğumuz liste 'python' kelimesinin harflerini içerisinde barındırıyor. Şimdi ise hem string (metin), hem de sayı türünden veriler barındıran bir liste oluşturalım:

liste2 = ['okan','vurdu',1905]

Yukarıdaki örneklerle Python'da bir listenin nasıl tanımlandığını öğrenmiş olduk. Şimdi ise bir listenin herhangi bir elemanına nasıl erişilir onu inceleyelim:

cumle = ['hayat','python','ile','guzel']
print "Listenin 2. elemanı:", cumle[1]

Çıktı:
Listenin 2. elemanı: python


Gördüğümüz gibi print metodu yardımıyla "cumle" isimli listemizin 2. elemanını (yani 1. indisteki eleman) ekrana yazdırmış olduk. Şimdi gelin, tanımlamış olduğumuz bir listeye ait eleman sayısını nasıl öğrenebiliriz onu irdeleyelim:

liste3 = [1,2,3,4,5,6,7,8,9]
len(liste3)

Çıktı:
9

Gördüğümüz gibi len methodu, içerisine parametre olarak yazdığımız listenin eleman sayısını bize geri döndürmüş oldu. Şimdi ise listenin elemanlarına tek tek erişmek yerine belirli indis numaraları arasındaki elemanlarına nasıl erişilir konusuna bir gözatalım:

cumle = ['hayat','python','ile','guzel']
print cumle[1:3]

Yukarıdaki kod bloğunu çalıştırdığımızda karşımıza şöyle bir çıktı gelecektir:

['python','ile']

Başlangıç indisinden bitiş indisine kadar (bitiş indisi dahil değil) olan elemanları ekrana yazdırmış olduk. Burada : sol tarafındaki değer başlangıç indisini, sağ tarafındaki değer bitiş indisini ifade ediyor. Eğer başlangıç indisini belirtmezseniz Python yazdığınız kodu yorumlarken başlangıç indisini 0 kabul eder.
Yine benzer bir durum olarak bitiş indisini belirtmezseniz, Python kodunuzu yorumlarken bunu listenin son indisi olarak kabul eder. (Son eleman dahil edilir) Bu durumu şöyle örnekleyelim:

cumle = ['hayat','python','ile','guzel']
print cumle[:2]

Çıktı:
['hayat','python']


cumle = ['hayat','python','ile','guzel']
print cumle[1:]

Çıktı:
['python','ile','guzel']

Ekrana elemanları belirli aralıklarla yazdırmak isteyebilirsiniz. Python geliştiricileri bu konuyu da atlamamışlar ve artış miktarı özelliğini listeler içerisine dahil etmişler. Gelin anlatmak istediğimizi bir örnekle inceleyelim:

liste4 = ['okan','vurdu','www.okanvurdu.net',1,3,4,'python']
print cumle[1::2]

Çıktı:
['vurdu',1,4]

Gördüğümüz gibi listemizin 1. indisinden başlayıp son indisine kadar olan elemanları ikişer ikişer atlayarak ekrana yazdırdık. Sizde buna benzer örnekleri çoğaltabilirsiniz.

Şimdi ise listelere ait metotlara bir gözatalım:

append() : Listeye eleman eklemeye yarayan metottur.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']

takimlar.append('Trabzonspor')

remove() : Listeden eleman silmeye yarayan metottur. Parametre olarak silinecek elemanın değerini alır.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']
takimlar.remove('Beşiktaş')

del : Yine liste içerisinden bir elemanı silmek için kullanılır. remove() metodundan farkı, parametre olarak silinecek elemanın indis numarasını almasıdır.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']
del takimlar[1]

pop() : Liste içerisinden eleman silmenin başka bir yoludur. İçerisinde parametre olarak sayı değeri gönderdiğinizde belirttiğiniz indisteki elemanı listeden çıkartır ve çıkardığı elemanı ekrana yazar. Eğer herhangi bir parametre göndermezseniz listenin en sonundaki elemanı listeden çıkartır.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']
takimlar.pop(2)

reverse() : Liste elemanlarının sırasını tersine çevirmek için kullanılır.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']
print takimlar
takimlar.reverse()
print takimlar

Çıktı:
['Galatasaray','Fenerbahçe','Beşiktaş']
['Beşiktaş','Fenerbahçe','Galatasaray']


sort() : Liste ögelerini alfabetik olarak sıralamaya yarayan mettottur.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']
takimlar.sort()
print takimlar

Çıktı:
['Beşiktaş','Fenerbahçe','Galatasaray']

index() : Liste içerisinde arama yapmayı sağlayan methottur. Eğer aranılan öge listede mevcutsa, bu ögenin indisini geri döndürür.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']
takimlar.index('Galatasaray')

Çıktı:
0

count() : Yine liste içerisinde arama yapmada kullanılan bir metottur. Geriye aradığımız değerden liste içerisinde kaç adet olduğunu döndürür.

takimlar = ['Galatasaray','Fenerbahçe','Beşiktaş']
takimlar.count('Bursaspor')


Çıktı:
0

Bu yazımızda, Python ile listeleri nasıl kullanabileceğimize dair genel bir fikir sahibi olduk. Çeşitli örnekler türeterek listelerin kullanımı hakkında daha fazla yetkin hale gelebilirsiniz. İyi çalışmalar dileriz...

6 Mayıs 2013 Pazartesi

Resim Ekleme ve Şekil Çizme


Bu dersimizde ekrana şekiller çizdirmeye başlayacağız.Kullanacağımız modüller
draw.Bir de gfxdraw isminde bir modül var ama experimental.Bu yüzden bu modülü
kullanmayacağız.Ekrana resim eklemek içinse image modülünü kullanacağız.Dikkat etmemiz gereken nokta pygame'in koordinat sistemi.Pygame Ekranın sol-üst köşesini (0,0) kabul ediyor ve nesneleri buna göre yerleştiriyor.Normal koordinat sisteminde aşağı doğru y değeri azalırken bu durumda artıyor.
Şimdi draw modülünde kullanabileceğimiz fonksiyonlara bir göz atalım:
  • pygame.draw.rect
  • pygame.draw.polygon
  • pygame.draw.circle
  • pygame.draw.ellipse
  • pygame.draw.arc
  • pygame.draw.line
  • pygame.draw.lines
  • pygame.draw.aaline
  • pygame.draw.aalines

Kodumuz gayet açık.Birinci parametre şekli çizdireceğimiz surface alanı.İkincisi renk.Üçüncüsü ise şekli çizdireceğimiz koordinatlar.Yalnız circle kullanırken radious değerini de vermemiz gerekiyor.Diğer parametreler aynı.Detaylı bilgi için dökümantasyona bakabilirsiniz.

import pygame

RED =   (255, 0,  0)
GREEN = (0,  255, 0)
BLUE =  (0,   0, 255)
pygame.init()
screen=pygame.display.set_mode((640,480))

pygame.draw.line(screen, BLUE, (60, 60), (120,60), 4)
pygame.draw.ellipse(screen, RED, (300, 250, 40,80), 1)

pygame.draw.rect(screen, RED, (50,50,100,25)) 
pygame.draw.polygon(screen, GREEN, ((146, 0),
    (291, 106), (236, 277), (56, 277), (0, 106)))
pygame.draw.circle(screen, BLUE, (200,50), 35)
pygame.draw.polygon(screen, GREEN, ((250,100),(300,0),(350,50)))
pygame.draw.arc(screen, BLUE,(400,10,150,100), 0, 3.14)
pygame.display.flip()

Image modülü ile de basit bir örnek yapalım.Resimlerin yerleştirileceği koordinatları belirlemek için daha önce kullandığımız get_rect() fonksiyonunu kullanacağız.Bu fonksiyon belirttiğimiz nesne üzerinde rectangular alan oluşturuyor.
image = pygame.image.load("head.png")
rect = image.get_rect()
rect.x,rect.y = (100,200)
screen.blit(image,rect)
Burada rect nesnemizin x ve y özelliklerini kullandık.Kullanabileceğimiz diğer özellikler: top, left,bottom,right,topleft, bottomleft, topright, bottomright,midtop, midleft, midbottom, midright,center,,centerx, centery,size, width, height,w,h

Kaynakça:

5 Mayıs 2013 Pazar

Harekete Giriş


Ekrana şekiller çizdirmeye başladığımıza göre artık hareket konusuna giriş yapabiliriz.Öncelikle şunu anlamalıyız:ekranda hiçbir şey hareket etmez.Hareket bir illüzyondur.Biz sadece pikselleri bir yerden başka bir yere kopyalarız.Bunu saniye de birkaç kez yaptığımızda da hareket etkisi yaratılmış olur.
Şimdi ekrana yeşil bir kutu çizdirip hareket ettirelim.Kutumuz diagonal hareket edecek.
Bu yüzden yönleri belirtmemiz gerekiyor. Kodumuzun daha derli toplu olması için Direction isminde bir class tanımlayacağız.
class Direction(object):
  DOWNLEFT = 1
  DOWNRIGHT = 3
  UPLEFT = 7
  UPRIGHT = 9

Ardından Obj class 'ını tanımlayalım.
class Obj(object):
 """docstring for Cisim"""
 
 def __init__(self):
  self.pos = pygame.Rect(200,200, 20, 20)
  self.MOVESPEED = 4
  self.dir = Direction.UPLEFT
Nesnemizi oluştururken pygame'in Rect sınıfını kullandık.Aslında bunu daha önce de yaptık.Hatırlarsanız ekrana yazı yada resim eklerken koordinatlar için get_rect() isimli bir fonksiyon kullanmıştık.İşte bu fonksiyon aslında pygame.Rect sınıfından nesne türetiyor ve biz bu nesnenin koordinatlarına cismimizi yerleştiriyoruz.Burada (200,200) nesnenin koordinatları ve (20,20) ise genişlik ve yükseklik değeri.self.dir ise başlangıç yönümüz.

Nesnemizin hareket fonksiyonu,
def move(self):
 if self.dir == Direction.DOWNLEFT:
  self.pos.left -= self.MOVESPEED
  self.pos.top += self.MOVESPEED

 if self.dir == Direction.DOWNRIGHT:
  self.pos.left += self.MOVESPEED
  self.pos.top += self.MOVESPEED

 if self.dir == Direction.UPLEFT:
  self.pos.left -= self.MOVESPEED
  self.pos.top -= self.MOVESPEED

 if self.dir == Direction.UPRIGHT:
  self.pos.left += self.MOVESPEED
  self.pos.top -= self.MOVESPEED
left, dikdörtgenin sol-üst x değeri; top, dikdörtgenin sol-üst y değeri.Benzer şekilde sağ-üst x değeri right ve sol-alt y değeri de bottom.Koordinat sistemini düşünürsek,sol-alt tarafa doğru hareket etmek için,left değerini azaltıp sürekli top değerini artırmalıyız.Benzer şekilde sol-yukarı tarafa hareket etmek için de left ve top değerini azaltmalıyız.

Nesnemizin ekrandan dışarı çıkmaması için çarpışma kontrolü ve buna bağlı olarak yön değiştirme de yapmalıyız.Bunun için kodumuz şu şekilde:
if self.pos.top < 0:
 if self.dir == Direction.UPLEFT:
  self.dir = Direction.DOWNLEFT
 if self.dir == Direction.UPRIGHT:
  self.dir = Direction.DOWNRIGHT
if self.pos.bottom > 600:
 if self.dir == Direction.DOWNLEFT:
  self.dir = Direction.UPLEFT
 if self.dir == Direction.DOWNRIGHT:
  self.dir = Direction.UPRIGHT
if self.pos.left < 0:
 if self.dir == Direction.DOWNLEFT:
  self.dir = Direction.DOWNRIGHT
 if self.dir == Direction.UPLEFT:
  self.dir = Direction.UPRIGHT
if self.pos.right > 800:
 if self.dir == Direction.DOWNRIGHT:
  self.dir = Direction.DOWNLEFT
 if self.dir == Direction.UPRIGHT:
  self.dir =Direction.UPLEFT

pos.top < 0 ifadesi nesnemizin ekranın üst kısmına çarpma durumu(top değeri,sol-üst y değeriydi.Bu değerin sıfır olduğu tek yer x ekseni).Bu durumda iki ihtimal var:Hareket yönümüz ya yukarı-sol yada yukarı-sağ.Duruma göre yönü aşağı-sol yada aşağı-sağ olarak değiştiriyoruz. Aynı şekilde pos.bottom > 600 ifadesi de nesnemizin ekranın alt kısmına çarpma durumunu ifade ediyor.Bu durumda da hareket yönümüz sol-aşağı yada sağ-aşağı.Duruma göre yönümüzü değiştiriyoruz. Diğer kısımlar ise ekranın sağ tarafına yada sol tarafına çarpma durumları.

Ana döngümüz ise şu şekilde:
pygame.init()
WINDOWWIDTH = 800
WINDOWHEIGHT = 600
FPS = 25
WHITE = (255,255,255)
GREEN = (0,  255,  0)
window = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
clock = pygame.time.Clock()
nesne = Obj()  
while True:
 window.fill(WHITE)
 nesne.move()
 pygame.draw.rect(window,GREEN,nesne.pos)
 pygame.display.flip()
 clock.tick(FPS)

Gördüğünüz gibi bu sefer clock diye bir değişken tanımladık.Bununla oyun döngümüzün saniyede kaç kere icra edileceğini belirleyebiliyoruz.Bu uygulamada döngü hızımız saniyede 25 kare.
Algoritmamız gayet basit:
  • Ekranı temizle 
  • Move fonksiyonunu çalıştır
  • Obj bulunduğu pozisyona nesneyi çiz
  • Ekranı güncelle

Kodumuzun tamamı:
#!/usr/bin/env python
import pygame
from pygame.locals import *

class Direction(object):
 DOWNLEFT = 1
 DOWNRIGHT = 3
 UPLEFT = 7
 UPRIGHT = 9
  
class Obj(object):
 """docstring for Obj"""
 def __init__(self):
  self.pos = pygame.Rect(200,200, 20, 20)
  self.MOVESPEED = 4
  self.dir = Direction.UPLEFT

 def move(self):
  if self.dir == Direction.DOWNLEFT:
   self.pos.left -= self.MOVESPEED
   self.pos.top += self.MOVESPEED

  if self.dir == Direction.DOWNRIGHT:
   self.pos.left += self.MOVESPEED
   self.pos.top += self.MOVESPEED

  if self.dir == Direction.UPLEFT:
   self.pos.left -= self.MOVESPEED
   self.pos.top -= self.MOVESPEED

  if self.dir == Direction.UPRIGHT:
   self.pos.left += self.MOVESPEED
   self.pos.top -= self.MOVESPEED

  
  if self.pos.top < 0:
   if self.dir == Direction.UPLEFT:
    self.dir = Direction.DOWNLEFT
   if self.dir == Direction.UPRIGHT:
    self.dir = Direction.DOWNRIGHT
  if self.pos.bottom > 600:
   if self.dir == Direction.DOWNLEFT:
    self.dir = Direction.UPLEFT
   if self.dir == Direction.DOWNRIGHT:
    self.dir = Direction.UPRIGHT
  if self.pos.left < 0:
   if self.dir == Direction.DOWNLEFT:
    self.dir = Direction.DOWNRIGHT
   if self.dir == Direction.UPLEFT:
    self.dir = Direction.UPRIGHT
  if self.pos.right > 800:
   if self.dir == Direction.DOWNRIGHT:
    self.dir = Direction.DOWNLEFT
   if self.dir == Direction.UPRIGHT:
    self.dir =Direction. UPLEFT

  
  
pygame.init()
WINDOWWIDTH = 800
WINDOWHEIGHT = 600
FPS = 25
WHITE = (255,255,255)
GREEN = (0,  255,  0)
window = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))
clock = pygame.time.Clock()
nesne = Obj()  

while True:
 window.fill(WHITE)
 nesne.move()
 pygame.draw.rect(window,GREEN,nesne.pos)
 pygame.display.flip()
 clock.tick(FPS)

Kaynakça: