31 Aralık 2013 Salı

Akademik Bilişim ve Python

1-4 Şubat tarihleri arasında akademik bilişim yapılacak. Ekipten Mehmet Dursun İnce ve Barkın Kılıç Güvenlik 101 Eğitimi verecekler. Kayıtlar bitti ve şuanda 209 insan sadece Güvenlik 101 eğitimi için kayıt yaptırdı. İlk başta 50 kişiye verilmesi planlanan eğitim yoğun ilgi üzerine 100 kişiye çıkartıldı. Bu 100 kişi 209 kişi arasından yapılacak olan bir sınav ile seçilecek. Seçilme işleminin adaletli olabilmesi için her üniversiteden veya başvurulan kurumdan eşit bir şekilde seçilmesi şeklinde planlandığını tahmin ediyoruz. Biz de tabi ki eğitime başvurduk. Şunu söyleyelim ki aynı ekipte olmamız bize direk gitme şansı vermiyor. Biz de herkes gibi sınava girecek ve gitmek için yarışacağız. Yani eğitimi verecek kişiler adalete önem veriyor diyebiliriz. Bizde düşündük ve madem her kurumdan eşit sayıda insan seçilmesi muhtemel bir durum. Bir bakalım hangi kurumlardan kaçar kişi başvurmuş öğrenelim dedik. Tabi ki bu yazının Python ile ilişkisi tam da burada devreye giriyor. Bunu öğrenebilmek için küçük bir Python betiği yazdık.
# -*- coding:utf-8 -*-
from bs4 import BeautifulSoup
import urllib
from collections import Counter

html = urllib.urlopen("http://ab2014.mersin.edu.tr/kursBasvuruDetay.php?id=4").read()

html_icerik = BeautifulSoup(''.join(html))

tablo = html_icerik.find('table')

satirlar = tablo.findAll('tr')

liste = []
bos = 0
sayac=1

for tr in satirlar:
 sutunlar = tr.findAll('td')
 for td in sutunlar:
  if sayac==3:
   metin = td.find(text=True)
   if metin != None:
    liste.append(metin)
   else:
    bos = bos +1
  sayac += 1
 sayac=1

h = dict()
sozluk = Counter([h.setdefault(k,v) for k,v in zip([x.split()[0] for x in liste],liste)])


html_liste = open('akademikbilisim.html','w')

html = u'\n'

for i in h:
 html = html + u'

\n'

html = html + u'

\n'
html = html + u'
'+h[i]+u''+ str(sozluk[h[i]]) +u'
BELİRTİLMEMİŞ'+ str(bos) +u'
' html_liste.write(html.encode("utf-8"))
İlk önce burada kullanmış olduğumuz bs4 modülünden bahsedelim. Bu modül bir Html metnini bölebilmek için geliştirilmiştir. Python ile hazır bir şekilde gelmiyor. İlk önce bu modülü kurmamız gerekiyor. Eğer bir Linux dağıtımı kullanıyorsanız şu şekilde kurabilirsiniz.
apt-get install python-bs4
Daha fazla bilgiye buradan ulaşabilirsiniz. İlk önce http://ab2014.mersin.edu.tr/kursBasvuruDetay.php?id=4 adresine bağlanarak istediğimiz verileri çektik ve bunları bir listeye kaydederek o liste üzerinden işlem yaptık.
Aynı üniversitelerin tekrarlanmaması olayında yardım aldığımızı itiraf edelim.
Son olarak da bunları bir html sayfasına bastırdık. Siz isterseniz doğrudan yazdırabilirsiniz. Ve işte sonuç; Hangi kurumdan kaç kişi Güvenlik 101 eğitimine başvuru yapmış.
KurumKişi Sayısı
ERCİYES ÜNİVERSİTESİ4
POLİS AKADEMİSİ1
ÖZYEĞİN UNİVERSİTY1
MUGLA SİTKİ KOCMAN UNİVERSİTESİ1
BİLKENT ÜNİVERSİTESİ19
FIRAT ÜNİVERSİTESİ6
LKD1
ATM DALAMAN HAVALİMANI YAPIM VE İŞLETME A.Ş1
EFİCA1
BAHÇEŞEHİR ÜNİVERSİTESİ2
YILDIRIM BEYAZIT ÜNİVERSİTESİ1
AHMET YESEVİ UNİVERSİTESİ1
KASTAMONU ÜNİVERSİTESİ1
MEVLANA ÜNİVERSİTESİ2
EGM3
ONDOKUZ MAYIS ÜNİVERSİTESİ BİLGİ İŞLEM DAİRE BAŞKANLIĞI1
ESKİŞEHİR OSMANGAZİ ÜNİVERSİTESİ1
ISPARTA ATABEY MESLEK YÜKSEK OKULU8
EASTERN MEDITERRIAN UNIVERSITY1
EGE UNIVERSITESI1
MERSİN ÜNİVERSİTESİ1
MANDALİN BİLİŞİM HİZMETLERİ1
ÜNİVERSİTE1
GAZİ ÜNİVERSİTESİ3
ÇÖZÜM GÜMRÜKLEME1
KARAMANOĞLU MEHMETBEY ÜNİVERSİTESİ1
GAZİANTEP ÜNİVERSİTESİ BİLGİ İŞLEM DAİRE BAŞKANLIĞI1
ÇANAKKALE ONSEKİZ MART ÜNİVERSİTESİ3
NECMETTİN ERBAKAN ÜNİVERSİTESİ 3
İSTANBUL AYDIN ÜNİVERSİTESİ2
TRAKYA ÜNİVERSİTESİ1
SAKARYA ÜNİVERSİTESİ2
EPATİ BİLİŞİM2
YILDIZ TEKNİK ÜNİVERSİTESİ2
ANTALYA INTERNATIONAL UNİVERSITY1
ULUDAĞ ÜNİVERSİTESİ1
ZİRVE ÜNİVERSİTESİ1
ORTA DOĞU TEKNİK ÜNİVERSİTESİ1
T.C. ADIYAMAN ÜNİVERSİTESİ1
ERDEMLİ ATL, TL VE METEM1
ARTVİN ÇORUH ÜNİVERSİTESİ1
SELÇUK ÜNİVERSİTESİ1
TÜRKİYE BİLİŞİM DERNEĞİ3
ABANT İZZET BAYSAL ÜNİVERSİTESİ1
SAÜ1
İZMİR YÜKSEK TEKNOLOJİ ENSTİTÜSÜ1
MEHMET AKİF ERSOY ÜNİVERSİTESİ2
BAHCESEHİR UNİVERSİTESİ1
ANKARA ÜNİVERSİTESİ11
ÖĞRENCİ1
PROJE KUTUSU ELEKTRONİK1
KAHRAMANMARAŞ SÜTÇÜ İMAM ÜNİVERSİTESİ1
KARABÜK ÜNİVERSİTESİ3
DUMLUPINAR ÜNİVERSİTESİ BİLGİSAYAR MÜHENDİSLİĞİ BÖLÜMÜ2
TOROS UNİVERSİTESİ1
ÇUKUROVA ÜNİVERSİTESİ ENFORMATİK BÖLÜMÜ8
MUSTAFA KEMAL ÜNİVERSİTESİ2
BEYKENT ÜNİVERSİTESİ1
DOKUZ EYLÜL ÜNİVERSİTESİ1
MEB1
SDÜ MYO. BİLGİ GÜVENLİĞİ TEKNOLOJİLERİ1
18 MART ÜNİVERSİTE1
SÜLEYMAN DEMİREL ÜNİVERSİTESİ14
ATABEY MESLEK YÜKSEK OKULU4
MOBİLİZ BİLGİ VE İLETİŞİM HİZMETLERİ A.Ş1
OSMANGAZİ ÜNİVERSİTESİ1
3.ANA JET US K.LIĞI1
INTELRAD1
MUĞLA SITKI KOÇMAN ÜNİVERSİTESİ2
DOĞU AKDENİZ ÜNİVERSİTESİ1
KONYA NECMETTİN ERBAKA ÜNİVERSİTESİ3
DENIZ KUVVETLERİ K.LİGİ1
YEDİTEPE ÜNİVERSİTESİ1
KARADENİZ TEKNİK ÜNİVERSİTESİ5
BELİRTİLMEMİŞ41
Burada bazı verilerin tutarsız olması kişilerin kurum alanını yazarken herhangi bir standarda uymamasından kaynaklanıyor.

19 Aralık 2013 Perşembe

Python ile Twitter Apisi Kullanımı

Python ile twitter apisi kullanarak örnek uygulamalar oluşturmayı göreceğiz. Bunun için ilk önce twitterda uygulama oluşturmamız gerekiyor. https://dev.twitter.com/apps/new adresinden uygulama oluşturabilirsiniz. Uygulama oluşturduktan sonra karşınıza şu şekilde bir pencere gelecek.
Buradaki Consumer key,Consumer secret,Access token,Access token secret değerleri bize lazım olacak. Eğer sizde değerleri yoksa Your access token başlığı altındaki Create my access token butonuna tıklayarak oluşturunuz. Twitter apisini kullanabilmek için Twython modülünü kullanacağız. Eğer Twython bilgisayarınıza kurulu değilse terminalde şu komutları yazarak kurabilirsiniz.
pip install twython

easy_install twython
Twitter apisini kullanabilmek için ilk şu tanımlamaları yapmamız gerekiyor.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from twython import Twython
CONSUMER_KEY = '***'
CONSUMER_SEcRET = '***'
ACCESS_TOKEN = "***"
ACCESS_TOKEN_SECRET = "***"



twitter = Twython(CONSUMER_KEY, CONSUMER_SECRET,
                  ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
twython modülü sayesinde Twitter'a bağlanmış olduk. Burdaki *** değerleri kendi değerleriniz olmalıdır. Şimdi isterseniz ilk önce
update_status()
fonksiyonunu kullanarak tweet atalım. Yukarıdaki kodlara şu satırı ekliyoruz.
twitter.update_status(status='#Python ile tweet atma..')
Tweet atmış olduk.
NOT: Eğer twitterda oluşturduğunuz uygulamanın yazma izni yoksa hata ile karşılaşırsınız. İlk uygulama oluşturulduğunda varsayılan olarak sadece okuma izni vardır.
Bir kullanıcının takipçi sayısı,takip ettiği kişi sayısı, attığı tweet sayısı gibi değerlere ulaşabiliriz.
##Takip ettiği kişi sayısı
user = twitter.get_user_timeline()
print user[0]['user']['friends_count']
138
##Takipçi sayısı
user = twitter.get_user_timeline()
print user[0]['user']['followers_count']
82
##Attığı tweet sayısı
user = twitter.get_user_timeline()
print user[0]['user']['statuses_count']
969
##Kullanıcı adı
user = twitter.get_user_timeline()
print user[0]['user']['screen_name']
_true_false
Bu işlemleri kullanıcı adını kendimiz vererek başka kullanıcı içinde yapabiliriz.
user = twitter.get_user_timeline(screen_name='uygarkoroglu')
print user[0]['user']['followers_count']
206
Şimdi istediğimiz bir kullanıcının son tweetlerini çekerek yeni bir .html sayfasına aktaracağımız basit bir uygulama yapalım.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from twython import Twython
APP_KEY = '***'
APP_SECRET = '***'
ACCESS_TOKEN = "***"
ACCESS_TOKEN_SECRET = "***"



twitter = Twython(APP_KEY, APP_SECRET,
                  ACCESS_TOKEN, ACCESS_TOKEN_SECRET)

user_tweets = twitter.get_user_timeline(screen_name='_true_false',include_rts=True)
tweets = ""
for tweet in user_tweets:
    tweet = Twython.html_for_tweet(tweet)
    tweets += '
  • '+tweet+'
  • ' html = """
      """+ tweets +"""
    """ create_html = open("tweets.html","w") create_html.write(html.encode('utf-8').strip()) create_html.close()
    Buradaki screen_name='_true_false' parametresi hangi kullanıcının tweetleri çekilecekse onun kullanıcını adını belirtir. Programı çalıştırdığınız da bulunduğunuz dizinde son tweetlerin bulunduğu tweets.html dosyası oluşacaktır.
    Daha fazla bilgiye https://twython.readthedocs.org/en/latest/ sayfasından ulaşabilirsiniz.
    Ekipten Mehmet İnce'nin benzer bir twitter modülünü kullanarak yazdığı tweet silme programına Buradan ulaşabilirsiniz.

    14 Aralık 2013 Cumartesi

    Koşul İfadeleri Alıştırmalarının Çözümleri



    Soru çözümleri kişiden kişiye değişebilir. Bir sorunun birden fazla çözümü olabilir. Bunun sebebi kullanıcının sorunun çözümü için izlediği algoritmaya bağlıdır. Doğru çalışan her kod bir çözümdür. Bu yüzden sizin yazmış olduğunuz kodlar aşağıdaki kodların aynısı olmak zorunda değildir.


    Soru 1) Bir dersten geçme notu 50 olarak belirlenmiş olsun. Kullanıcıya notunu sorup dersten geçme-kalma durumunu ekrana yazan programı yazınız.
    Çözüm:
    # !/usr/bin/env python
    # -*- coding: cp1254 -*-
    
    alinanNot = int(input("Notunuzu giriniz:"))
    # Kullanıcıdan notunu girmesini istiyoruz ve
    # Kullanıcı girişini int türüne dönüştürüyoruz
    # Dikkat! Değişkenimizin ismini not olarak tanımlayamayız.
    # Çünkü 'not' deyimi Python'da değil işlemi için kullanılan bir komuttur.
    
    # Girilen notun 0-100 aralığında olacağını da kontrol edelim.
    if alinanNot < 0 or alinanNot > 100:# Girilen not 0'dan küçük ve 100 den büyük ise
        print ("Geçersiz bir not değeri girdiz!")
    
    elif alinanNot < 50:    # Girilen not 50'dan küçük ise
        print ("KALDINIZ")
    else:     # Geriye kalan diğer durumlar için geçtiğini belirtmek için yani [50,100] aralığı
        print ("GEÇTİNİZ")
    

    Soru 2) Bir öğrencinin 2 tane sınav notunu kullanıcıdan alıp ortalamasını bulunuz. 100'lük sistemdeki bu notu 5'lik sistemdeki nota dönüştüren programı yazınız. (0-24->0; 25-44->1; 45-54->2; 55-69->3; 70-84->4; 85-100->5)
    Çözüm:
    # !/usr/bin/env python
    # -*- coding: cp1254 -*-
    
    alinanNot1 = int(input("1. Notunuzu giriniz:"))
    alinanNot2 = int(input("2. Notunuzu giriniz:"))
    
    # Geçersiz not girilmesi durumlarını kontrol edelim
    if alinanNot1 < 0 or alinanNot2 < 0 or alinanNot1 > 100 or alinanNot2 > 100:
        print ("Geçersiz bir not değeri girdiniz!")
    else:
    # Geçerli bir not girildiyse ortalama hesaplanacak ve
    # ortalamanın hangi not aralığında olduğu bulunacak
        ortalama = (int(alinanNot1) + int(alinanNot2)) / 2
        if ortalama <= 100:
            karneNotu = 5
        if ortalama < 85:
            karneNotu = 4
        if ortalama < 70:
            karneNotu = 3
        if ortalama < 55:
            karneNotu = 2
        if ortalama < 45:
            karneNotu = 1
    # Karne notunu bulmak için hep 'if' deyimini kullandık
    # 'elif' deyimi kullansaydık hata yapardık. Bu iki kullanımın
    # farkını ayırt edemiyorsanız, yazımızı tekrar okuyabilirsiniz.
    
    # Ortalamayı ve Karne Notunu ekrana yazalım
    print ("Ortalamanız:",ortalama)
    print ("Karne Notunuz:",karneNotu)
    

    Soru 3) Kullanıcının 1 ile 7 arasında bir sayı girmesini isteyiniz. Girilen sayının haftanın hangi günü olduğunu bulan programı yazınız. Hatalı girişlerde programın uyarı vermesini sağlayınız.
    Çözüm:
    # !/usr/bin/env python
    # -*- coding: cp1254 -*-
     
    sayi = int(input("1-7 arasında bir sayı giriniz(sınırlar dahil):"))
    
    # Sayı belirtilen aralıkta mı?
    if sayi >= 1 and sayi <= 7:
        # Girilen sayı belirtilen aralıkta ise bu koşullar çalışacak
        if sayi == 1:
            print ("Pazartesi")
        elif sayi == 2:
            print ("Salı")
        elif sayi == 3:
            print ("Çarşamba")
        elif sayi == 4:
            print ("Perşembe")
        elif sayi == 5:
            print ("Cuma")
        elif sayi == 6:
            print ("Cumartesi")
        elif sayi == 7:
            print ("Pazar")
    # Belirtilen aralığın dışında bir sayı girilmişse uyarı verelim
    else:
        print("Geçersiz bir değer girdiniz!")
    
    

    10 Aralık 2013 Salı

    random Modülü


    Python'daki modüllerden birisi de random modülüdür. Bu yazımızda da random modülünü inceleyeceğiz.

    Program yazarken zaman zaman rastgele sayılara ihtiyaç duyarız ve bunun için bilgisayara rastgele bir sayı ürettirmemiz gerekir. Bu rastgele olacak olan durum; bir listeden rastgele bir eleman seçme, belli bir aralıkta rastgele sayı tutma gibi farklı durumlar olabilir.

    Biz burada random modülü için en çok kullanılan metotlara değineceğiz; ancak siz daha fazlasını merak ediyorsanız. Etkileşimli kabukta
    >>>import random
    >>>help (random)
    komutlarını yazdığınız zaman, açıklamalarıyla birlikte metotları görebilirsiniz. Aşağıdaki en çok kullanılan metotları hem açıklayıp hem de etkileşimli kabuk üzerinden çalıştırarak görelim.

    Random

    Modülün bu metodunu kullandığımız zaman 0 ile 1 arasında rastgele bir sayı üretilir. Üretilen bu sayıda dikkat edilmesi gereken bir nokta vardır. Üretilen bu sayı 0 olabilirken 1 olamaz; yani [ 0, 1 ) aralığında oluşmaktadır. Etkileşimli kabuktan gösterecek olursak
    >>>import random
    >>>random.random()
    0.8759562487514273
    
    şeklinde oldu. Burada bize üretmiş olduğu rastgele sayı olduğu için siz denediğinizde başka bir sayı oluşması muhtemeldir.

    Randint

    Random ile ürettiğimiz sayı float tipinde bir sayı idi. Biz integer tipinde bir sayı istiyorsak bu durumda randint metodunu kullanabiliriz. Bu metot kullanılırken başlangıç ve bitiş aralık değerleri verilir; ancak bu durumda bitiş değeri de rastgele sayı olarak tutabilir. Yani [başlangıç, bitiş] aralığı kullanılır.
    >>>random.randint(1, 3)
    3
    

    Choice

    Eğer önceden belirlediğimiz bir listeden rastgele bir eleman seçmek istiyorsak, bu durumda kullanacağımız metot choice metodudur.
    >>>random.choice(['sonbahar', 'kış', 'ilkbahar', 'yaz'])
    'ilkbahar'
    

    Shuffle

    Shuffle fonksiyonu ile elimizdeki bir listeyi karıştırabiliriz. Böylelikle listedeki elemanların yerleri rastgele atanmış olur.
    >>>rakamlar = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
    >>>random.shuffle(rakamlar)
    >>>rakamlar
    [1, 7, 3, 8, 9, 4, 0, 5, 6, 2]

    Randrange

    Başlangıç, bitiş ve artış miktarını belirleyerek rastgele sayı üretmek istiyorsak bu durumda kullanabileceğimiz metot ise randrange metodudur. Random metodunda bahsetmiş olduğumuz [ başlangıç, bitiş ) aralığı burada da geçerlidir.
    Kullanımı biraz esnektir. Şu şekilde:
    randrange(başlangıç, bitiş, artış) : [ başlangıç, bitiş ) aralığında başlangıçtan itibaren artış miktarının katında herhangi bir değer alır.
    randrange(başlangıç, bitiş ) : [ başlangıç, bitiş ) aralığından bir tam sayı değeri alır.
    randrange(bitiş) : [ 0, bitiş ) aralığından rastgele bir tam sayı değeri alır.
    Şimdi bu üç kullanım için örnek verelim:
    # [1,10) aralığında tek bir sayı tutulur.
    >>>random.randrange(1, 10, 2)
    7
    
    # Sadece başlangıç ve bitiş aralığını verirsek artış miktarı 1 kabul edilir.
    >>>random.randrange(1, 10)
    4
    
    # Sadece bitiş değeri verilirse [0,bitiş) aralığında değer tutulur.
    >>>random.randrange(10)
    2
    

    Alıştırmalar

    1) 0 ile 100 arasında tutulan bir sayıya göre kullanıcıyı "Aşağı", "Yukarı" diye yönlendirecek şekilde bir Sayı Tahmin Oyunu yazınız.

    2) 2 adet zar atılsın ve her iki zarın değeri de 6 olduğunda program dursun. İki zar da 6 gelene kadar kaç kez zar atıldığını bildiren programı yazınız.

    Not: Örnek olması açısından buradaki iletiyi inceleyebilirsiniz.

    Kaynaklar
    http://docs.python.org/2/library/random.html
    http://en.wikibooks.org/wiki/Choose_Your_Own_Pyventure/Random_and_PRNGs
    http://www.cs.swarthmore.edu/~adanner/cs21/f09/randomlib.php
    Mustafa Başer - Python Kitabı

    9 Aralık 2013 Pazartesi

    Dosyalama İşlemleri

    Python kullanarak geliştireceğiniz uygulamalarda, uygulamanıza ait verileri saklamak isteyebilirsiniz. Eğer çok büyük çaplı verileri saklamayı düşünmüyorsanız dosyalama sizin için ideal bir yöntemdir. Bu yöntem bilinen en ilkel saklama yöntemi olmasına rağmen verilerinizi her zaman veritabanı gibi karmaşık yapılarda saklamaya ihtiyaç duymayabilirsiniz. Şimdi gelin Python ile temel dosyalama işlemleri nasıl yapılır inceleyelim:

    Dosyalama Modları:
    Dosyalar üzerinde işlem yapmaya başlamadan önce dosyalara erişimi denetleyen okuma/yazma modları hakkında bilgi sahibi olmanız gerekir. Bu modlar;
    • r : sadece okuma modu (salt okunur)
    • w : yazma modu
    • : dosya sonuna ekleme modu
    • b : ikili (binary) erişim modu
    • t : salt metin modu (ön tanımlı)
    • + : hem okuma hem de yazma modu
    Yukarıda bahsedilen modlar birçok programlama dili için aynı şeyi ifade etmektedir. Genel olarak farklılık görebileceğiniz nokta ise okuma, yazma ve ekleme dışındaki modlardır.Yani ekstra modlar dillere göre çeşitlilik gösterebilir.

    Dosyalama modlarını inceledikten sonra Python ile bir dosyaya nasıl erişebiliriz sorusunu irdeleyelim:

        D = open('ornek.txt')
    

    Bu komutu çalıştırıldığında içerisine parametre olarak belirtilen dosyayı salt-okunur olarak açıp D isimli nesneye atar. (Dosyanın salt-okunur modda açılma sebebi, yazdığımız open metodu içerisine hangi modda açılacağını belirtmememizdir.)


    Üst kısımda yer alan komutları incelediğinizde, D.readline() dikkatinizi satırı çekmiştir. readline() metodu o an açık olan dosyadan satır satır veri okumanızı sağlar. Bu komutu ikinci bir kez daha girerseniz dosyada yer alan bir sonraki satır ekrana getirilir.

    Diyelim ki dosyayı belirli bir yerine kadar okudunuz ver işinize yarayan bilgiyi elde ettiniz. Peki dosyanın en başına nasıl geri döneceksiniz?

    Eğer bu soruya yanıt olarak "dosyayı yeniden açarım" diyorsanız, evet bu da bir yoldur ama bu kadar esnek bir programlama dilinde bunu yapmanın daha kolay bir yolu vardır değil mi?

    Kesinlikle var, bu yol "seek" metodunun ta kendisi. Dosyanın başına dönmek için;

        D.seek(0)
    

    Bu komutu çalıştırdığınızda Python o an en son karakteri işaret eden dosya imlecini dosyanızın başına yani 0. karaktere götürür.

    Dosyadaki Bütün Satırlara Erişim:
    Yukarıdaki yöntem ile sırayla dosyadaki bütün satırlara nasıl erişebileceğimizi görmüş olduk. Şimdi ise küçük birkaç satır yardımıyla bir dosya başından sonuna nasıl okunur inceleyelim:

        
        dosya_metni = open('ornek.txt').read()
        print(dosya_metni)
    


    Gördüğünüz gibi "ornek.txt" dosyası içerisindeki bütün veriyi read() metodu yardımıyla okuyup ekrana bastırdık. Şimdi ise bir dosyadaki satırları listeye aktarmayı inceleyelim:

        liste = D.readlines()
    

    Şimdiye kadar gördüğümüz kısım bir dosyadan veri okuma ile ilgiliydi. Şimdi ise "bir dosyaya nasıl veri yazılır?" sorusunu irdeleyelim. Dosyaya veri yazmak için w veya a ve + modlarının kullanabileceğimiz üç mod olduğuna yazının başında değinmiştik. Şimdi bu modlardan faydalanarak dosyaya veri yazma işlemini gerçekleyelim:

        Y = open('ornek.txt','a')
        Y.write('EKLENEN TEST VERISI')
    

    Gördüğünüz gibi open metodunu yazarken ikinci bir parametre olan "a" sayesinde dosyayı sonuna ekleme modunda açarak içeriğini güncelledik.

    Peki içerisinde veri olan bir dosyayı "a" - append yerine "w" - write modunda açsaydık ne olurdu? Varolan dosya içeriği silinir, son olarak göndermiş olduğunuz veri içeriği boşaltılmış dosyaya yazılırdı. "w" - write modu aslında dosyayı yeniden oluşturma modu olarak da düşünülebilir. Zaten open() metodunda belirttiğiniz gibi bir dosya o an içinde bulunulan dizinde yoksa "w" modu ile açılması halinde otomatik olarak oluşturulur.

    Üzerinde çalışmakta olduğunuz dosya ile işiniz bittikten sonra;

        Y.close()
    

    komutu ile bu dosyayı kapatmanız faydalı olacaktır.
    Temel olarak Python'da dosyalama işlemleri konusunu incelemiş olduk. Siz de yapacağınız uygulamalarla örnekleri çoğaltabilir, bu işlemleri ihtiyacınıza göre şekillendirebilirsiniz.

    Unutmayın, Python yeterince esnek bir dildir.
    İyi çalışmalar...

    Windows Python'ı Yol'a Eklemek

    GNU/Linux işletim sistemi kullananlar Python'ın etkileşimli kabuğuna ulaşmak için komut satırında python yazmaları yeterlidir. Bunun sebebi Linux python'u sisteme kurarken çalıştırılabilir python dosyasını /usr/bin klasörü içerisine atar. Komut satırına python yazdığımız zaman komut satırı ilk /usr/bin klasörü içerisinde arayacağı için herhangi bir sorun ile karşılaşmadan komutu çalıştıracaktır.
    Windows işletim sistemi kullananlar için cmd üzerinde python çalıştırmak biraz daha zahmetli olmaktadır. Eğer Linux'daki gibi python yazıp entera bastığınız zaman şu şekilde bir hata ile karşılaşırsınız.
    'python' is not recognized as an internal or external command,operable program or batch file.
    
    'python' iç ya da dış komut, çalıştırılabilir program ya da toplu iş dosyası olarak tanınmıyor.
    
    Windows kullanıcıları şu şekilde doğrudan Python'ı nereye kurdularsa o dizin üzerinden çalıştırmak zorundadırlar.
    c:\Python27\python.exe
    
    Bu şekilde yazıldığı zaman çalışacaktır. Fakat her seferinde bu şekilde yazmak zahmetli olacağı için Linux'daki gibi doğrudan python yazarak nasıl çalıştırabileceğimizi gösterelim. Bilgisayarıma sağ tıkladıktan sonra aşağıdaki yolu takip ederek Ortam Değişkenlerine ulaşmamız gerekir.
    Özellikler -> Gelişmiş Sistem Ayarları
    
    Bu gelen pencerede Ortam Seçenekleri butonuna tıklıyoruz.
    Gelen pencere de yapmamız gereken Sistem değişkenleri içerisinde PATH seçeneğini seçmek ve Düzenle butonuna tıklamak.
    Düzenle dedikten sonra değişken değeri kısmının sonuna ; koyduktan sonra Python'ı nereye kurduysak o dizinin yolunu ekleiyoruz. Bu işlemi yaptıktan sonra artık cmd içerisinde python yazmamız yeterli olacaktır.
    Not: Bu işlem windows 8 işletim sistemi üzerinde yapılmıştır. Diğer Windows işletim sistemlerinde yapmanız gereken işlemler aynıdır.

    22 Ağustos 2013 Perşembe

    time Modülü

    time modülü zaman değerlerini düzenlemekle ilgili birçok işlevi barındırır. Zamanı göstermek için iki standart vardır. Birisi zamanı Epoch'tan itibaren saniye olarak vermektir. Epoch Unix zaman başlangıcı olarak alınır ve takvime göre 1 Ocak 1970'e denk gelir. Eğer Epoch türünden şimdiki zamanı saniye biçiminde almak istersek, şu yöntemi kullanabiliriz.
    import time
    print time.time()
    1377097485.43
    
    Bu şekilde aldığımız çıktı bize 1 Ocak 1970'den itibaren kaç saniye geçtiğini verir. Diğer standart ise dokuz sayıdan oluşan bir tüp ile gösterimdir.
    import time
    print time.localtime()
    time.struct_time(tm_year=2013, tm_mon=8, tm_mday=21, tm_hour=18, tm_min=7, tm_sec=20, tm_wday=2, tm_yday=233, tm_isdst=1)
    
    Bu tüp bize sırası ile yıl(dört haneli),ay(1-12),gün(1-31),saat(0-23),saniye(0-59),haftanın günü(0-6),yılın kaçıncı günü olduğu(1-366) ve ileri saat uygulaması(0,1) bilgilerini bu şekilde alabiliyoruz.
    localtime() fonksiyonu Epoch türünden argüman alabilir. Eğer saniye olarak argüman verirsek. Saniyenin 1 Ocak 1970'den itibaren denk geldiği zamanın bilgilerini bize döndürür. Eğer herhangi bir argüman vermezsek o anki zamanı time.time() ile dönen değeri argüman olarak alacak ve bulunduğumuz zamanın bilgilerini geriye döndürecektir.
    Bulunduğumuz zamanın bilgilerini alabilmek için time modülünün ctime() fonksiyonunu da kullanabiliriz.
    # -*- coding: utf-8 -*-
    
    import time
    print time.ctime()
    Wed Aug 21 18:14:30 2013
    
    Eğer elimizde bulunan localtime() tipinde bir zamanı epoch tipine dönüştürmek istersek mktime() fonksiyonunu kullanabiliriz.
    import time
    print time.mktime((2011,9,18,14,55,55,4,22,0))
    1316350555.0
    
    strftime() Fonksiyonu
    strftime() fonksiyonu ile kendimize ait zaman cümlesi oluşturabiliriz.
    import time
    print time.strftime("%Y")
    2013
    
    Yıl ifadesini elde edebilmek için %Y yönergesini kullandık. Bu şekilde tüm yönergeleri listeleyelim.
    Yönerge Anlamı
    %a Kısaltılmış gün adı
    %A Gün adı
    %b Ayın kısaltılmış adı
    %B Ayın adı
    %c Tam tarih ve saat
    %d Ayın günü(01-31)
    %H saat(00-24)
    %I saat(01-12)
    %j gün(01-366)
    %m ay(00-12)
    %M dakika(00-59)
    %p öğleden önce(ÖÖ),öğleden sonra(ÖS)
    %S saniye(00-59)
    %U yılın kaçıncı haftası(00-53)
    %w haftanın kaçıncı günü(0-6)
    %y yılın son iki hanesi(15)
    %d Ayın günü(örnek:Nisan için 13)
    %Y Yıl
    Buradaki değerler sistemin yereline bağlı olarak değişmektedir. Sisteminizin yereli İngilizce ise sonuçları da İngilizce olarak alırsınız.
    import time
    print time.strftime("%d/%m/%Y")
    22/08/2013
    
    Bu şekilde kullanarak tarih veya saat ile ilgili istediğimiz çıktıları alabiliriz.
    sleep() Fonksiyonu
    time modülünün sleep() fonksiyonu programımızı istediğimiz süre kadar durdurmamızı sağlar. Aldığı argüman saniye cinsindendir.
    import time
    time.sleep(2)
    
    Bu kod programımızı 2 saniyeliğine durduracaktır.

    30 Temmuz 2013 Salı

    sys Modülü

    sys modülü Python sistemine ilişkin fonksiyonlar ve nitelikler barındırır. Yani bu modül sayesinde kullandığımız Python sürümünü yönetebiliriz.
    Modüller konusunu incelerken Python da bulunan modüllerin aslında birer Python programı olduğunu söylemiştik. Yani os modülü aslında os.py adında bir programdır. Ama bunların bazı istisnaları vardır. sys modülü de bunlardan biridir.sys modülü Python programlama dili ile değilde C programlama dili ile yazılmıştır.
    Diğer her şeyde olduğu gibi sys modülünün içeriğini öğrenmek için dir() fonksiyonunu kullanabiliriz.
    import sys
    print dir(sys)
    ['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__stderr__', '__stdin__', 
    '__stdout__', '_clear_type_cache', '_current_frames', '_getframe', '_mercurial', 'api_version', 'argv', 
    'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook',
    'dont_write_bytecode','exc_clear', 'exc_info', 'exc_type', 'excepthook', 'exec_prefix', 'executable',
    'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval', 'getdefaultencoding',
    'getdlopenflags', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof',
    'gettrace', 'hexversion', 'long_info', 'maxint', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 
    'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'py3kwarning', 'pydebug', 'setcheckinterval', 
    'setdlopenflags', 'setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 
    'version', 'version_info', 'warnoptions']
    
    Gördüğünüz gibi sys modülü içerisinde bir hayli fonksiyon ve nitelik barındırıyor. Biz bunlardan bazılarını inceleyeceğiz.
    argv Niteliği
    Python programını komut satırında çalıştırırken gönderdiğimiz argümanlar argv Niteliği'ne eleman olarak gönderilirler. Şimdi argv.py adında bir program oluşturun ve içerisine şu kodları yazın.
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    import sys
    print sys.argv[1]
    
    Şimdi bu programı komut satırında şu şekilde çalıştırın.
    python argv.py test
    test
    
    Gördüğünüz gibi ekrana test ifadesini yazdı. İşte argv niteliği komut satırında çalışırken yanında ek olarak argüman almamızı sağlar. Birden fazla argüman da gönderebiliriz.
    import sys
    print sys.argv[2]
    
    Şimdi ikinci bir argüman gönderelim.
    python argv.py test deneme
    deneme
    
    argv niteliğini tam anlayabilmek için programımızı şu hale getirelim.
    import sys
    
    print sys.argv
    
    Aynı şekilde komut satırında çalışalım ve aldığımız çıktıya bir bakalım.
    python argv.py test deneme
    ['argv.py', 'test', 'deneme']
    
    Gördüğünüz gibi çıktı olarak bir liste elde ettik. Bu listedeki ilk elemanın programımızın adı olduğunu fark etmişsinizdir. Listeler üzerinde yaptığımız tüm işlemleri bu liste üzerinde de yapabiliriz. Şimdi bir tane ac.py adında bir dosya oluşturun ve içerisine şu kodları yazın.
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    
    import sys
    import os
    
    def ac():
        if os.name == "nt":
            os.startfile(sys.argv[1]) #Eğer işletim sistemi windows ise
        elif os.name == "posix":
            os.system("xdg-open %s" %sys.argv[1]) #Eğer işletim sistemi Lünux ise
    
    if(len(sys.argv)>2)
        print "Birden fazla dosyayı açmaya çalıştınız."
    else:
        ac()
    
    
    Gördüğünüz gibi kullanıcıdan programı komut satırında çalıştırırken, açmak istediği dosyanın adını da argüman olarak istiyoruz. Girdiği programı os modülünde işlediğimiz nitelikler ile işletim sistemine göre açıyoruz. Burada gönderilen argümanları sayarken 2 sayısını kullandığımıza dikkat edin. Hatırlarsanız argv niteliğinin tuttuğu listenin ilk elemanı programın kendi adıydı. Bu yüzden bu listenin eleman sayısı zaten en az birdir.
    exit() Fonksiyonu
    exit() Fonksiyonu programın sonlanmasını sağlar.
    import sys
    
    isim = raw_input("Öğrenim:").lower()
    if isim == "üniversite":
        print "Hoşgeldiniz."
    else:
        print "Bu program size uygun değil,sonlandırılıyor."
        sys.exit()
    
    print "Program sonlanırsa bu yaazıyı kullanıcı göremez."
    Öğrenim:ilköğretim
    Bu program size uygun değil,sonlandırılıyor.
    
    Gördüğünüz gibi eğer kullanıcı üniversite öğrenimi görmüyorsa program sonlanır. exit() fonksiyonunun yaptığı ekstra bir işlem yoktur.
    getdefaultencoding() Fonksiyonu
    Python 2.x programları yazarken bildiğiniz gibi her programımızın başına şu kodu yazıyoruz.
    # -*- coding: utf-8 -*-
    
    Bu kodu yazmadan şu şekilde bir program yazmaya çalışalım.
    print "Bu yazı Türkçe karakterler bulundurmaktadır."
    SyntaxError: Non-ASCII character '\xc4' in file /home/mazlumagar/workspace/Python/sys/getdefaultencoding.py on line 3, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details
    
    Gördüğünüz gibi Python, ASCII karakterlerinden farklı karakterler kullanıldığı için, bu karakterleri tanımadı ve hata döndürdü. Şimdi getdefaultencoding() fonksiyonunun ne işe yaradığına bakalım.
    import sys
    print sys.getdefaulteimncoding()
    ascii
    
    Gördüğünüz gibi getdefaultencoding() Python'daki ön tanımlı kodlama biçimini gösteriyor. Python 2.x sürümlerinde ön tanımlı kodlama biçimi ascii olduğu için Türkçe karakter problemi yaşıyoruz. Bu problemin üstesinden gelebilmek için de yukarıda gösterdiğimiz kod parçasını programımıza ekleyerek, kodlama biçimini UTF-8 çeviriyoruz.
    Aynı programı Python 3.x sürümünde çalıştıralım.
    utf-8
    
    Gördüğünüz gibi Python 3.x sürümünde ön tanımlı kodlama biçimi olarak UTF-8 geliyor. Bu yüzden Python 2.x'de yaşadığımız Türkçe karakter problemini 3.x sürümlerinde yaşamıyoruz.
    path Niteliği
    Python bir modolü içe aktarırken Python bu modülü path Niteliği'nin gösterdiği dizinler içerisinde arar.
    import sys
    for i in sys.path:
        print i
    /home/mazlumagar/workspace/Python/sys
    /home/mazlumagar/workspace/Python
    /usr/lib/python2.7
    /usr/lib/python2.7/plat-linux2
    /usr/lib/python2.7/lib-tk
    /usr/lib/python2.7/lib-old
    /usr/lib/python2.7/lib-dynload
    /usr/local/lib/python2.7/dist-packages
    /usr/lib/python2.7/dist-packages
    /usr/lib/python2.7/dist-packages/PIL
    /usr/lib/python2.7/dist-packages/gst-0.10
    /usr/lib/python2.7/dist-packages/gtk-2.0
    /usr/lib/python2.7/dist-packages/ubuntu-sso-client
    /usr/lib/pymodules/python2.7
    
    Gördüğünüz gibi Python'ın modülleri nerede aradığını listelemiş olduk. path Niteliği geriye bir liste döndürür. Listeler üzerinde yaptığımız ekleme,çıkarma gibi işlemleri bu liste üzerinde de yapabiliriz.
    sys.path.append('/dizin/altdizin')
    
    Python artık içe modül aktarırken bizim eklediğimiz dizin içerisine de bakacaktır. Bilmeliyiz ki program sonlandıktan sonra liste eski haline geri döner. Eklediğimiz dizinler sadece çalıştığımız program için geçerlidir.
    Python bir modülü ararken bulma işlemini gerçekleştirdikten sonra arama işlemini sonlandırır. Yani bir modül iki dizinde birden varsa listenin ilk sırasında bulunan dizindeki modül içe aktarılacaktır.
    platform Niteliği
    Daha önce os Modülünü işlerken, kullanılan işletim sistemini tespit edebilmek için name niteliğini kullanabildiğimizi söylemiştik. sys Modülünün platform niteliği de aynı işlemi yapmaktadır.
    import sys
    print sys.platform
    Linux 2
    
    Linux üzerinde çalıştırdığımız için çıktı bu şekilde olacaktır.
    İşletim Sistemi Çıktı
    Linux Linux2
    Windows win32
    Mac OS darwin
    sys modülünün platform niteliği bize kullandığımız işletim sisteminin kaç bit olduğu hakkında bilgi vermez. Windows'ta çıktının win32 olduğu sizi yanıltmasın. 64 bit Windows'ta da aynı çıktıyı verecektir. Eğer kullanılan işletim sisteminin kaç bit olduğunu öğrenmek istersek platform modülünden faydalanabiliriz.
    import platform
    print platform.architecture()
    ('32bit', 'ELF')
    
    Gördüğünüz gibi 32 bit Linux işletim sisteminde çalıştığımız için bu şekilde çıktı aldık. Çıktının sözlük olduğuna dikkat edin. Sözlükler üzerinde yaptığımız işlemleri çıktı üzerinde yapabiliriz.
    İşletim Sistemi Çıktı
    32 bit Linux ('32bit', 'ELF')
    64 bit Linux ('64bit', 'ELF')
    32 bit Windows ('32bit', 'WindowsPE')
    64 bit Windows ('64bit', 'WindowsPE')
    stdout Niteliği
    Bugüne kadar ekrana yazdırma işlemi yaparken print deyiminden faydalandık. Python, print deyimi ile yazdırdıktan sonra otomatik olarak yeni satıra geçer.
    i=1
    while i<10:
        print i
        i=i+1
    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    Aynı işlemi for döngüsü ile de yapabiliriz. Burada bir alt satıra geçmesini istemezsek print deyiminden sonra virgül kullanabiliriz.
    i=1
    while i<10:
        print i,
        i=i+1
    1 2 3 4 5 6 7 8 9
    
    Gördüğünüz gibi bu sefer sayılar yan yana yazıldı. Ama bu sefer de aralarında birer boşluk bırakıldı. Eğer print deyiminden sonra virgül kullanılırsa ifadeler arasında birer boşluk bırakılır. İstediğimiz şey bu olmayabilir. Biz sadece ifadelerin yan yana yazılmasını istiyor olabiliriz. Eğer böyle bir şey istersek sys modülünün stdout niteliğinin write() fonksiyonunu kullanabiliriz.
    import sys
    i=1
    while i<10:
        sys.stdout.write(str(i))
        i=i+1
    123456789
    
    İfadeler yan yana ve istediğimiz şekilde yazıldı. write() fonksiyonuna verdiğimiz argüman karakter dizisi olmak zorundadır.
    sys.stdout.write(2)
    Traceback (most recent call last):
        sys.stdout.write(2)
    TypeError: expected a character buffer object
    
    Sayı yazdırmaya çalışınca program hata verdi. Bu hatayı almamak için önceki örnekte ifadeleri karakter dizisine dönüştüren str() fonksiyonunu kullandık.
    Biz şimdiye kadar print deyimi ile çıktıları ekrana verdik. Ama istersek bunu değiştirebiliriz. stdout niteliğini kullanarak print deyiminin nereye çıktı vereceğini belirtebiliriz.
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    import sys
    
    ac = open("stdout.txt","w")
    
    sys.stdout = ac
    print "print deyimi ile txt dosyasına yazıyoruz."
    ac.close()
    
    Burada kullandığımız sys.stdout=ac ifadesi ile print deyiminin çıktıları açtığımız dosyaya vereceğini söylüyoruz. Buradan anlıyoruz ki print deyimi varsayılan olarak çıktıları ekrana veriyor. Biz burada bunu değiştirdik. Eğer dosyayı kapattıktan sonra print ile yazmak istersek hata alırız.
    print "deneme"
    Traceback (most recent call last):
        print "deneme"
    ValueError: I/O operation on closed file
    
    Çünkü print deyimi burada açtığımız dosyayı arıyor. Biz dosyayı kapattığımız için hata ile karşılaşıyoruz. Peki print deyiminin tekrardan ekrana yazmasını nasıl sağlayacağız? Bunun için şu komutu kullanmamız yeterli.
    sys.stdout = sys.__stdout__
    print "deneme"
    deneme
    
    Artık sıkıntı olmadan ekrana çıktı verebildik. sys.__stdout__ ifadesi Python'ın öntanımlı standart çıktı komutunu tutar. Yani aslında programın kendi içinde sys.stdout ifadesi sys.__stdout__ değerine eşittir.
    Geliştiricilerin tavsiye etiği yol ise şu şekildedir.
    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    import sys
    
    varsayilan = sys.stdout
    ac = open("stdout.txt","w")
    
    sys.stdout = ac
    print "print deyimi ile txt dosyasına yazıyoruz."
    ac.close()
    
    sys.stdout = varsayilan
    print "deneme"
    deneme
    
    Bu yöntem ile herhangi bir sıkıntı olmadan ilk önce açtığımız dosyaya sonrada ekrana yazı yazdırdık.
    version_info Niteliği
    version_info niteliği kullanılan Python sürümü hakkında bilgi verir.
    import sys
    print sys.version_info
    sys.version_info(major=2, minor=7, micro=3, releaselevel='final', serial=0)
    

    27 Temmuz 2013 Cumartesi

    OS Modülü

    Python bir çok modülden oluşur. Bir programcı ihtiyaç duyacağı hemen her temel fonksiyonu hazır modüller içerisinde bulabilir. os modülü işletim sistemi tarafından sağlanan bir çok hizmeti Python içerisinde kolay bir şekilde kullanmamızı sağlayacak nesneleri barındırır. Daha önce de söylediğimiz gibi .py uzantılı her dosya bir modüldür. Buradan anlıyoruz ki os modülü os.py programından başka bir şey değildir. Bizim yazdığımız modüllerden içeriği dışından hiç bir fark yoktur. GNU/Linux sistemlerinde bu modülü /usr/lib/python2.7/ dizininde Winodws sistemlerinde ise C:/Python26/Lib dizininde bulabilirsiniz.
    Bu modülü kendi yazdığımız modüller gibi içe aktarıyoruz.
    import os
    
    Bu tarz Python ile beraber gelen modüllerin bizim yazdığımız modüllerden en önemli farkı, yazdığımız program nerede olursa olsun bu modülleri bu şekilde içe aktarabiliyoruz. Kendi yazdığımız modüllerde modül ve program yan yana olmalıydı. Bu modüller için ise bu gerekli değildir.
    Şimdi gelin daha önce bahsettiğimiz dir() fonksiyonu ile os modülü içerisindeki fonksiyonları ve nitelikleri öğrenelim.
    import os
    for i in dir(os):
        print i
    
    Bu kod parçasını çalıştırırsanız göreceksiniz ki os modülü içerisinde oldukça fazla fonksiyon ve işlev bulunmaktadır. Fazla olduğundan dolayı buraya yazmıyoruz. Şimdi en çok kullanılanlarını inceleyeceğiz.
    os.name
    Bu nitelik, kullandığımız işletim sistemi hakkında bilgi verir.
    print os.name
    posix
    
    Biz GNU/Linux işletim sistemi üzerinde çalıştırdığımız için çıktı olarak posix verdi. İşletim sistemlerine göre çıktı şu şekilde olacaktır.
    • GNU/Linux için:“posix”
    • Windows için:“nt”, “dos”, “ce”
    • Macintosh için: “mac”
    • OS/2 için:“os2”
    • Risc Os için:“riscos”
    os modülünün name niteliğini kullanarak işletim sistemlerine göre programlar yazabiliriz. Bu şekilde yazdığımız programın birden fazla işletim sistemi üzerinde çalışmasını sağlamış olur ve eğer işletim sistemi komutlarını kullanacaksak hataların önüne geçmiş oluruz.
    Basit bir örnek yapalım;
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    import os
    if os.name=="posix":
        print "Özgür yazılıma destek verdiğiniz için teşekkür ederiz."
    elif os.name=="nt":
        print "Bir an önce Özgür yazılıma geçiş yapmalısınız."
    Özgür yazılıma destek verdiğiniz için teşekkür ederiz.
    
    Not: Eğer kullandığınız işletim sistemi GNU/Linux tipinde ise os.uname ile çekirdeğe ait daha ayrıntılı bilgi elde edebilirsiniz.
    print os.uname()
    ('Linux', 'mazlumagar-Ideapad-Z570', '3.2.0-41-generic-pae', '#66-Ubuntu SMP Thu Apr 25 03:50:20 UTC 2013', 'i686')
    
    os.system()
    Bu fonksiyon işletim sistemi ait sistem komutlarını çalıştırmamızı sağlar.
    Sistem komutu: Üzerinde çalıştığımız işletim sitemine ilişkin işlemleri yerine getirmemizi sağlayan komutlardır. Örneğin; mkdir komutu Linux işletim sisteminde klasör oluşturmamızı sağlar.
    import os
    if os.system("mkdir 'Yeni Klasör'"):
        print "Klasör başarılı bir şekilde oluşturuldu."
    else:
        print "Klasör oluşturulamadı."
    Klasör başarılı bir şekilde oluşturuldu.
    
    Gördüğünüz gibi os.system() fonksiyonun kullanımı oldukça basit. Burada "Yeni Klasör" adında bir dizin oluşturduk. Yapmamız gereken sadece system("sistem komutu") şeklinde kullanmaktır.
    import os
    if os.name=="posix":
        if os.system("mkdir 'Yeni Klasör'"):
            print "Klasör başarılı bir şekilde oluşturuldu."
        else:
            print "Klasör oluşturulamadı."
    elif os.name=="nt":
        if os.system("md Yeni Klasör"):
            print "Klasör başarılı bir şekilde oluşturuldu."
        else:
            print "Klasör oluşturulamadı."
    Klasör başarılı bir şekilde oluşturuldu.
    
    Örneği biraz daha değiştirdik. Bir önceki başlıkta işlediğimiz os.name komutunu da kullanarak işletim sistemine göre işleyen bir program yazdık. Windows işletim sisteminde yeni klasör oluşturmaya yarayan sistem komutu md'dir.
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    import os
    os.system("xdg-open yazi.txt")
    
    xdg-open komutu GNU/Linux işletim sistemlerinde çalışan bir komuttur. Bu komut istenilen dosya veya klasörü varsayılan uygulama ile açmamızı sağlar. Bu işlemi şu şekilde de yapabilirdik.
    os.system("kwrite yazi.txt")
    
    Burada varsayılan uygulama ile aç değilde "kwrite" uygulaması ile aç dedik. Bu tarz kullanım eğer sistem de "kwrite" yok ise hata verecektir. Bu yüzden xdg-open komutu bizim çok işimize yarayan bir komuttur. Windows'ta bu komuta benzer işlemi os.startfile("dosyaadi") ile yapabilirsiniz.
    os.listdir()
    os.listdir() fonksiyonu bir klasördeki klasör ve dosyaların listesini almamızı sağlar.
    import os
    print os.listdir(".")
    ['faktoriyel.py', 'listdir.py', 'os.uname.py', 'ilkmodul.py', 'yazi.txt~', 'faktoriyel.pyc', 'syste2.py', 'yazi.txt', 'environ.py', 'ilkmodul.pyc', 'system.py', 'modulcagir.py', 'Yeni Klas\xc3\xb6r', 'deneme.py']
    
    Gördüğünüz gibi bize içinde bulunduğumuz dizinin içinde bulunan dosya ve klasör isimlerini bir liste şeklinde döndürdü. Burada kullandığımız "." içinde bulunduğumuz dizini temsil eder. Eğer bir üst dizine çıkmak istersek ".." kullanabiliriz. Burada tabi şu şekilde bir yolda belirtebiliriz; os.listdir("/usr/bin").
    import os
    for i,k in enumerate(os.listdir(".")):
        print i+1,k
    1 faktoriyel.py
    2 listdir.py
    3 path.py
    4 os.uname.py
    5 ilkmodul.py
    6 yazi.txt~
    7 faktoriyel.pyc
    
    Bu şekilde yazdığımız programı daha düzenli hale getirdik.
    os.path()
    Python'da klasörlere ilişkin fonksiyonları os modülünün path nesnesinde bulabilirsiniz. Bir patikanın(dosya veya klasör) var olup olmadığını os.path.exists() fonksiyonu ile kontrol edebiliriz.
    os.path.exists('dosya veya klasör adı')
    True
    
    Eğer dosya veya klasör var ise "True" değer döner. os.path.exists() sadece dosya veya klasörün var olup olmadığı ile ilgilenir. Yani dosya mı klasör mü ? Bununla ilgilenmez.
    import os 
    dosya_adi = raw_input('Okuyacağınız dosya adını girin:')
    
    if not dosya_adi:
        print "Dosya adı girmediniz.."
    else:
        if os.path.exists(dosya_adi):
            print open(dosya_adi).read()
        else:
            print 'Böyle bir dosya yok'
    Okuyacağınız dosya adını girin:yazi.txt
    www.pythondersleri.com => Python için Türkçe doküman sağlar.
    
    Bu programda kullanıcıdan bir dosya adı aldık ve var ise dosyayı okuduk. Ama burada girilen isim eğer bir dizin adı olursa program okumaya çalışır ve hata ile karşılaşırız. Eğer bir patikanın dosya mı yoksa klasör mü olduğunu kontrol etmek istiyorsak os.path.isfile() ve os.path.isdir() fonksiyonlarını kullanabiliriz. os.path.isfile() fonksiyonu dosya olup olmadığını kontrol eder. Şimdi önceki örneğimizi şu şekilde değiştirelim.
    import os 
    dosya_adi = raw_input('Okuyacağınız dosya adını girin:')
    
    if not dosya_adi:
        print "Dosya adı girmediniz.."
    else:
        if os.path.isfile(dosya_adi):
                print open(dosya_adi).read()
        else:
            print 'Böyle bir dosya yok'
    Okuyacağınız dosya adını girin:Yeni Klasör
    Böyle bir dosya yok
    
    Gördüğünüz gibi artık kullanıcı var olan bir klasör bile girse program hata ile karşılaşmayacak.
    İşlev Görev Örnek
    os.path.basename() Verilen patikanın en son bileşenini verir. os.path.basename('/usr/bin/python')
    python
    os.path.dirname() Bir dosyanın bulunduğu klasörü verir. os.path.dirname('/usr/bin/python')
    /usr/bin
    os.path.splitext() Bir dosyayı uzantısına göre ayırır. os.path.splitext('/usr/lib/python2.7/os.py')
    ('/usr/lib/python2.7/os', '.py')
    os.path.join() Verilen argümanları bir patikaya dönüştürür. os.path.join('usr','lib','python2.7','os.py')
    usr/lib/python2.7/os.py
    os.path.abspath() Verilen patikanın tam yerini verir. os.path.abspath('/usr/lib/python2.7')
    /usr/lib/python2.7
    Şimdi os.listdir() başlığında verdiğimiz örneği şu şekilde değiştirelim.
    import os
    klasor = "." 
    for i in os.listdir(klasor):
        dosya = os.path.join(klasor,i)
        if os.path.isdir(dosya):
            print 'Klasör => ',i
        elif os.path.isfile(dosya):
            print 'Dosya => ',i
    Dosya =>  faktoriyel.py
    Dosya =>  listdir.py
    Dosya =>  environ.py
    Klasör =>  Deneme
    Dosya =>  modulcagir.py
    Klasör =>  Yeni Klasör
    
    os.walk()
    Program içerisinde bir klasörün tüm alt klasörleri ile birlikte taranmasını sağlar. walk() iterasyon edilebilir bir nesnedir. İterasyon sonucunda 3 elemandan oluşan bir demet döner. İlk eleman bulunulan klasörü, ikinci eleman bu klasörde bulunan klasörlerin listesi, üçüncü eleman ise bu klasörde bulunan dosyaların bir listesidir.
    import os
    
    for i in os.walk("/home/mazlumagar/Filmler"):
        print i
    ('/home/mazlumagar/Filmler', ['Macera', 'Dram', 'Aksiyon', 'Romantik'], [])
    ('/home/mazlumagar/Filmler/Macera', [], [])
    ('/home/mazlumagar/Filmler/Dram', ['Khan'], ['Benioku.txt'])
    ('/home/mazlumagar/Filmler/Dram/Khan', [], [])
    ('/home/mazlumagar/Filmler/Aksiyon', ['Bruce'], ['BeniOku.txt'])
    ('/home/mazlumagar/Filmler/Aksiyon/Bruce', [], [])
    ('/home/mazlumagar/Filmler/Romantik', [], [])
    
    Filmler klasörünün içeriğini listelemiş olduk. Filmler klasöründe dört adet klasör var ve dosya yok. Dram klasöründe "Khan" adında başka bir klasör ve "Benioku.txt" adında dosya mevcut. walk() fonksiyonu bu şekilde bizim işimizi çok kolaylaştırarak klasörleri taramamızı sağlıyor.
    os.access()
    Sadece Unix tipi işletim sistemlerinde os.access() ile erişim denetimini kontrol edebiliriz. os.access() işlevine vereceğiniz ilk argüman patika ikinci argüman ise erişim kipidir.
    Erişim Kipleri
    • os.F_OK:Patikanın var oluş kipi
    • os.R_OK:Okuma kipi
    • os.W_OK:Yazma kipi
    • os.X_OK:Tarama kipi
    print os.access("/home/mazlumagar/workspace", os.R_OK)
    True # workspace klasörünün okuma izni bulunmaktadır
    
    print os.access("/usr", os.W_OK)
    False # usr klasörünün yazma izni bulunmamaktadır.
    
    Bu şekilde klasörlerin erişim izinlerini kontrol edebiliriz.
    os.getcwd()
    os.getcwd() fonksiyonu bize o an hangi klasör içinde çalıştığımızı döndürür.
    import os 
    print os.getcwd()
    
    /home/mazlumagar/workspace/Python/mdül # Şuanda çalıştığımız dizinin yolu
    
    os.chdir()
    Bu fonksiyon sayesinde içinde bulunduğumuz dizini değiştirebiliriz. Hemen bir örnek verelim.
    #-*- coding:utf-8 -*-
    import os 
    
    print "Dizin değiştirmeden önce=>",os.getcwd()
    os.chdir('/var')
    print "Dizin değiştirdikten sonra=>",os.getcwd()
    
    Not:Daha önceki verdiğimiz örneklerde kullanmıştık. "." işareti içinde bulunduğumuz dizini temsil ediyordu. Python'da os.curdir de aynı işlevi görür. ".." işareti gibi os.pardir de bir üst dizini temsil eder. os.mkdir() ve os.makedirs()
    os.mkdir() fonksiyonu klasör oluşturmamızı sağlar.
    import os
    os.mkdir("deneme")
    
    Biz bu işlemi os.system("mkdir","yol") yönetimi ile de yapmıştık.
    Peki iç içe birden fazla klasör oluşturmak istersek ne olacak? Bir deneyelim.
    os.mkdir("deneme/test")
    Traceback (most recent call last):
        os.mkdir("deneme/test")
    OSError: [Errno 2] No such file or directory: 'deneme/test'
    
    Burada içerisinde "test" adında bir klasör barındıran "deneme" klasörünü oluşturmaya çalıştık. Python bize hata döndürdü. Eğer bu şekilde iç içe klasörler oluşturmak istersek, os.mkdir() fonksiyonu bize yardımcı olamaz. Bunun için os.makedirs() fonksiyonunu kullanmalıyız.
    import os
    os.makedirs("deneme/test")
    
    Bu şekilde herhangi bir hata almadan, klasörleri oluşturduk.
    os.rmdir() ve os.removedirs()
    Bu fonksiyonlar içi boş mevcut dizinleri silmemizi sağlar. Hemen bir örnek verelim. Çalışma dizinimiz içerisinde bulunan "test" isimli klasörü silelim.
    import os
    
    os.rmdir("test")
    
    Başarılı bir şekilde silme işlemini gerçekleştirdik. Şimdi az önce oluşturduğumuz "deneme" klasörünü silmeye çalışalım.
    os.rmdir("deneme")
    Traceback (most recent call last):
        os.rmdir("deneme")
    OSError: [Errno 39] Directory not empty: 'deneme'
    
    Oluşturduğumuz "deneme" klasörü içerisinde "test" adında bir klasör bulundurduğu için Python bize hata döndürdü. Az önce de söylediğimiz gibi bu yöntemler boş klasörleri silmemizi sağlar. Klasör oluştururken geçerli kural burada da geçerlidir. Eğer iç içe birden fazla boş dizini silmek istersek os.removedirs() fonksiyonunu kullanmalıyız.
    os.removedirs("deneme/test")
    
    "deneme" ve içerisindeki "test" klasörlerini silmiş olduk.
    sep Niteliği
    Bu nitelik bize işletim sistemlerinin dizin ayraçları hakkında bilgi verir.
    import os
    print os.sep
    /
    
    Bu programı Linux'da çalıştırdığımız için bize "/" döndürdü. Yani Linux'da dizin ayracı olarak "/" kullanılıyor. Eğer bu programı Windows'da çalıştırırsanız şu çıktıyı alırsınız.
    \\
    
    Peki bu ne işimize yarar? Yazdığımız programın işletim sistemleri ayırt etmeden sorunsuz bir şekilde çalışmasını sağlar. Yani az önce klasör silerken dizin ayracını kendimiz yazdık. Ama aynı programı Windows'da çalıştırmak istersek sorun çıkartabilir. Bu yüzden şu şekilde kullanabiliriz.
    os.rmdir("deneme"+os.sep+"test")
    
    Bu şekilde "deneme" içersindeki "test" klasörünü silmiş olduk. Yada klasör oluştururken de aynı işlemi yapabiliriz.
    import os
    
    os.makedirs("deneme"+os.sep+"test")
    
    Bu şekilde yazdığımız programın klasör oluşturması gerekebilir. Eğer biz direk kullandığımız işletim sisteminin dizin ayracını kullanırsak. Başka bir işletim sisteminde kullanan kullanıcı sorun ile karşılaşabilir. Bu yüzden doğrudan dizin ayracını kullanmak yerine os modülünün sep niteliğini kullanmak daha sağlıklı olacaktır.

    25 Temmuz 2013 Perşembe

    Modüller

    Python modüler bir programlama dilidir. Peki burada modüler derken ne demek istiyoruz ? Python programlama dili parçalardan bütün elde etmek üzerine kurulmuş bir programlama dilidir. Bu parçalar istenildiği zaman bütüne dahil edilebilir. Böylelikle çalıştığımız ortamı sadece kullandığımız parçalardan oluşturarak gereksiz bellek tüketiminde bulunmamış oluruz.

    Modülleri biraz daha açıklayarak beynimizde oturtalım. Bir programda aynı kodları tekrar tekrar yazmamak için Fonksiyonları kullanıyorduk. Tanımladığımız bir fonksiyon sadece o an içinde bulunduğumuz programda çalışır. Peki biz bu fonksiyonu başka bir program içinde çalıştırmak istersek ne yapmalıyız? Tabi ki kopyala yapıştır yapmayacağız. Programı içe aktarmamız (import) fonksiyonu kullanmak için yeterli olacaktır.
    Python'da yazılmış her program aynı zamanda birer modüldür. Bu özellik sayesinde Python programlarında bulunan fonksiyon ve özellikler başka Python programlarında da rahatça kullanılabilirler.
    Bu bölümde kendi modülümüzü yazmayı-Aslında daha önceden yazdığımız her program bir modül olduğu için bunu biliyoruz.Burada başka Python programında kullanımıyla ilgileneceğiz.-ve en çok kullanılan bazı hazır modüllerin kullanımından bahsedeceğiz.
    Bir Modül Yazmak ve İçe Aktarmak
    Daha önce söylediğimiz gibi yazdığımız her program aynı zamanda bir modüldür. Bir modül çeşitli değişkenlerin bulunduğu, fonksiyolar barındıran, bir veya daha fazla sınıfın bulunduğu karmaşık bir yapıya sahip olabilir.
    Şimdi basit bir program(modül) oluşturalım ve "ilkmodul.py" adı ile kaydedelim.
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    
    program = "Python"
    surum = "2.x"
    
    Bu şekilde ilk modülümüzü oluşturmuş olduk. Bir modül çağrılırken sadece dosya adı kullanılır(uzantısı yazılmaz). Çağırma işlemi "import" ifadesi ile yapılır. Bildiğiniz gibi yukarıda ki programda değişkenleri şu şekilde kullanabiliyoruz.
    print program
    Python
    
    Peki başka bir programda bu değişkeni kullanmak istersek ne yapmalıyız ? Şimdi "modulcagir.py" adında başka bir program oluşturalım. Bu iki programın aynı dizinde olmasına dikkat edelim.
    import ilkmodul
    print ilkmodul.program
    Python
    
    Gördüğünüz gibi ilk modülümüzü oluşturduk ve içindeki değişkeni başka bir programda kullandık. Şimdi bir fonksiyon bulunan modül tanımlayalım. İçinde Faktoriyel hesabı yapan bir fonksiyon bulunan "faktoriyel" adında şu şekilde bir modülümüz olsun.
    #!/usr/bin/env python
    #-*- coding:utf-8 -*-
    
    def faktoriyel(sayi):
        fak = 1
        for i in range(sayi):
            fak= fak * (i+1)
        return fak
    
    Bildiğiniz gibi biz bu program içinde istediğimiz yerde faktoriyel fonksiyonunu kulanabiliyoruz. Ama artık modüller sayesinde sadece bu program içinde değil istediğimiz herhangi bir program içerisinde kullanabileceğiz. Şimdi "hesapla.py" şeklinde bir program oluşturalım. Bu program içersinde faktoriyel fonksiyonunu kullanalım.
    import faktoriyel
    hesap = faktoriyel.faktoriyel(5)
    print hesap
    120
    
    Bu şekilde faktoriyel modülü içerisinde bulunan her şeyi herhangi bir program içerisinde kullanabiliriz.
    Modülleri İçe Aktarma Yöntemleri
    Modülleri içe aktarmanın bir kaç yolu vardır. Biz sadece import modül_adi yöntemini öğrendik.
    import modül_adi
    Bu yöntem ile içeri aktarım yaptığımız zaman modül içerisinde bulunan her şeyi programımıza aktarmış oluyoruz. Verdiğimiz örneklerde kullandığımız gibi modül içerisinde bulunan değişken,fonksiyon veya herhangi bir şeyi kullanırken şu yönetimi kullanıyoruz.
    modül_adi.fonksiyon_adi
    
    Bu yöntem de doğrudan fonksiyon adını kullanırsak şu şekilde bir hata alırız.
    print adi
    Traceback (most recent call last):
      File  line 3, in 
        print adi
    NameError: name 'adi' is not defined
    
    from modül_adi import *
    Daha öncede kullandığımız ilkmodul'u bu yöntem ile içe aktaralım.
    from ilkmodul import *
    print program
    
    Gördüğünüz gibi sadece değişken adını yazarak kullanabildik. Burada kullandığımız * ifadesi içe aktardığımız modül içerisindeki tüm değerleri temsil etmektedir. Eğer biz sadece istediğimiz bir değişken veya fonksiyonu içe aktarmak istiyorsak, şu şekilde kullanabiliriz.
    from ilkmodul import surum
    print surum
    
    Bu kullanım ile sadece surum değişkenini içe aktarmış olduk.
    import modul_ismi as yeni_isim
    Eğer içe aktaracağımız modülü kendi ismi ile değilde bizim belirlediğimiz isim ile çağırmak istersek bu şekilde takma bir isim verebiliriz.
    import faktoriyel as fak
    hesap = fak.faktoriyel(5)
    print hesap
    
    Gördüğünüz gibi artık faktoriyel modülünü fak ismi ile kullanıyoruz. Bu aktarım da eğer modülün kendi adını yazarak kullanmaya çalışırsanız hata alırsınız.
    from modul_adi import nesne_adi as yeni_nesne_adi
    import modul_ismi as yeni_isim kullanımında modüle takma isim veriyorduk. Bu kullanımda ise içe aktardığımız modül içersindeki bir nesneye takma isim veriyoruz. faktoriyel modülü içerisindeki faktoriyel fonksiyonunu şu şekilde içe aktaralım.
    from faktoriyel import faktoriyel as fak
    hesap = fak(5)
    print hesap
    
    Gördüğünüz gibi artık faktoriyel fonksiyonunu önünde modül adı olmadan ve yeni ismi ile kullandık.
    Peki bu yöntemlerden hangisini kullanmalıyız? En güvenilir yöntem ilk(import modül_adi) bahsettiğimiz yöntemdir. Bu yöntem ile kullandığımız nesnelerin(örnek: modul.topla(10,5)) hangi modül içerisinde olduğunu rahat bir şekilde anlayabiliriz. İkinci(from modül_adi import *) kullanımında ise nesnenin(örnek: topla(10,5)) programın kendi içerisinde mi yoksa başka bir modülden mi içe aktarıldığını anlayamayız. Bu kullanımda eğer içe aktarılan modülde ve programda aynı isimde nesneler bulunuyorsa istemediğimiz sonuçlar ile karşılaşırız. Bu yüzden en güvenilir olan import modül_adi yöntemini kullanmak daha sağlıklıdır.
    Modüllerin İçeriğini Öğrenme
    Başkaları tarafından yazılmış olan bir modülü içe aktardığımız zaman modül içerisinde var olan nesneleri bilmeliyiz ki kullanabilelim. Bir modül içerisinde nelerin var olduğunu dir() fonksiyonu ile öğrenebiliriz.
    import faktoriyel
    print dir(faktoriyel)
    ['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'adi', 'faktoriyel']
    
    Gördüğünüz gibi faktoriyel modülü içerisinde bulunan faktoriyel fonksiyonunu görebiliyoruz. Diğerleri tüm modüller için standart nesnelerdir. Bu şekilde içe aktaracağımız bir modül içeriğini öğrenebiliriz.

    11 Temmuz 2013 Perşembe

    Bu bölümde doğrudan düzenli ifadelerin değil, düzenli ifadeler ile oluşan eşleşme nesnelerinin metotlarını göreceğiz. Gelin ilk önce hangi metotlar var, onlara bir bakalım.
    import re
    
    karakter = "Python"
    
    nesne = re.match("Python",karakter)
    for i in dir(nesne):
        if not i.startswith("__"):
            print i
    end
    endpos
    expand
    group
    groupdict
    groups
    lastgroup
    lastindex
    pos
    re
    regs
    span
    start
    string
    
    Gördüğünüz gibi oldukça metod var. Bunlardan bazılarını beraber inceleyeceğiz.
    group() Metodu
    Bu metodu daha önce de sık sık kullanmıştık. Hatırlarsınız ki group() metodu düzenli ifadeler ile eşleştirdiğimiz karakter dizilerini görmemizi sağlıyordu.
    "()" metakarakterini kullanarak group() metodu ile ilgili bir kaç örnek verelim.
    #-*-coding:utf-8-*-
    
    import re
    
    karakter = "Python programlama dilini öğreniyorum"
    
    duzenli = re.search("(Python) (programlama) (dilini) (öğreniyorum)",karakter)
    
    Bu örnekte "()" metakarakterini kullanarak birden çok eşleştirme yaptık. group() metodunu kullanarak bunları ekrana yazdırabiliriz.
    print duzenli.group()
    Python programlama dilini öğreniyorum
    
    print duzenli.group(0)
    Python programlama dilini öğreniyorum
    
    Gördüğünüz gibi group() metodunu kullanarak yaptığımız eşleştirmelerin hepsini ekrana yazdırdık. Dikkatinizi çekmiş olmalı ki group(0) şeklinde kullanım da group() ile aynı sonucu verdi. Yani group(0) şeklinde kullanım da tüm eşleştirmeleri geriye döndürür.
    print duzenli.group(1)
    Python
    
    print duzenli.group(2)
    programlama
    
    Kısacası group() metodu eşleştirmeleri gruplamamızı sağlıyor.
    groups() Metodu
    groups() metodu eşleştirme yaparken "()" metakarakterini kullanarak oluşturduğumuz bütün grupları demet olarak geriye döndürür.
    print duzenli.groups()
    karakter = "Python programlama dilini ogreniyorum"
    
    duzenli = re.search("(Python) (programlama) (dilini) (ogreniyorum)",karakter)
    
    ('Python', 'programlama', 'dilini', 'ogreniyorum')
    
    Gördüğünüz gibi groups() metodunu kullanarak oluşturduğumuz grupları demet şeklinde elde etmiş olduk. Demetlerin tüm özellikleri burada oluşturduğumuz demet içinde aynen geçerlidir.
    if duzenli.groups().count("Python"):
        print "Yapılan gruplamada 'Python' ifadesi bulunmuştur."
    Yapılan gruplamada 'Python' ifadesi bulunmuştur. 
    
    Burada demetlerin "count" özelliğini kullanarak sorgulama işlemi yaptık.
    Özel Diziler
    Bu bölümde Python'da metakarakterler dışında düzenli ifadeler ile kullanılan bazı özel ifadelere değineceğiz.
    Bu özel ifadeler:
    \s => Boşluk karakterini yakalar.
    \d => Ondalık sayıları yakalar.
    \w => Alfanümerik karakterler ve "_" karakterini yakalar.
    \s Özel Dizisi
    import re
    
    liste = ['Parker','Dünyalar Savaşı','Hangover','Hızli Ofkeli','Zor Olüm']
    
    for i in liste:
        if re.search(u"[A-Za-z]+\s[A-Za-z]+",i):
            print i
    Dünyalar Savaşı
    Hizli Ofkeli
    Zor Olüm
    
    Bu örnekte büyük veya küçük harflerden oluşan, boşluk ile devam eden, ardından tekrar büyük veya küçük harflerden oluşan liste ögelerini ayıkladık. Yani iki kelimeli film isimlerini yakalamış olduk. Burada boşluk karakterini "/s" özel dizisi ile yakaladık.
    \d Özel Dizisi
    Bugüne kadar yaptığımız örneklerde ondalık sayıları kullanmak için [0-9] ifadesini kullandık. Aynı eşleştirmeyi "\d" özel dizisi ile de yapabilmekteyiz. Bir önceki örneğimizi şu şekilde değiştirelim.
    liste = ['Parker','2 Guns','Hangover','300 Spartalı','Zor Olüm']
    
    for i in liste:
        if re.search(u"\d+\s[A-Za-z]+",i):
            print i
    2 Guns
    300 Spartalı
    
    Gördüğünüz gibi sayı ile başlayan filmleri bulmak için "\d" özel dizisini kullandık ve ardından boşluk ile devam etmesi için "\s" özel dizisini kullandık.
    \w Özel Dizisi
    ifade = "a21_?ab_%+"
    
    print re.search("\w*",ifade).group()
    a21_
    
    Burada "\w" özel dizisini kullanarak alfanümerik karakterleri ve "_" karakterini yakalamış olduk. Bu özel dizi "[A-Za-z0-9_]" ifadesi ile aynı anlama gelmektedir. Gördüğünüz gibi işimizi ne kadar da kısaltmış oluyoruz.
    Python'da bulunan bu özel dizilerin birde büyük harfli olanları vardır. Büyük harfli olanlar küçük harfli özel dizilerin yaptığı işin tam tersini yaparlar.

    %S => Boşluk olmayan karakterleri yakalar.
    %D => Ondalık sayı olmayan karakterleri yakalar.
    %W => Alfanümerik olmayan ve "_" olmayan karakterleri yakalar.

    Verdiğimiz örneklere göre bunlar da gayet net bir şekilde anlaşılıyor. Bu yüzden Ondalık dizilerin büyükleri için özel olarak örnek verilmeyecektir.
    Düzenli İfadelerin Derlenmesi
    compile() Metodu
    Düzenli ifadeler karakter dizilerine göre daha yavaştırlar. Düzenli ifadelerin daha hazlı çalışmasını sağlamak için compile() metodu kullanılabilir. compile() metodu kullanılarak düzenli ifade kalıpları kullanılmadan önce derlenerek daha hızlı çalışırlar. Bu metot küçük boyutlu projelerde çok hissedilir bir fark yaratmasa da büyük boyutlu projeler için çok faydalı olacaktır.
    import re
    
    derle = re.compile("[A-Za-z]+\s[A-Za-z]+")
     
    liste = ['Parker','Dünyalar Savaşı','Hangover','Hızli Ofkeli','Zor Olüm']
    
    for i in liste:
        if derle.search(i):
            print i
    Dünyalar Savaşı
    Hızli Ofkeli
    Zor Olüm
    
    Özel dizileri kullanırken verdiğimiz örneği biraz değiştirerek tekrardan kullandık. Dikkat ederseniz düzenli ifade kalıbını compile() metodu içerisine yazarak ilk önce derleme işlemini yerine getirdik. search() metodunu kullanırken ise artık re.search() kalıbını değil de yeni oluşturduğumuz derle değişkenini kullanarak derle.search() ifadesini kullandık. derle.search() kalıbı içerisinde ise artık düzenli ifadeye yer vermedik, sadece karakter dizisini yazmış olmamamız yeterli oldu.
    compile() ile Derleme Seçenekleri
    compile() metodu ile derleme yapmayı gördük. Şimdi compile() ile bize sunulan bazı seçeneklere bakacağız. re.IGNORECASE veya re.I
    Python programlama dili büyük küçük harflere duyarlıdır. Yani Python için "Python" ve "python" farklı karakter dizileridir. Eğer biz "Python" düzenli ifadesini bulmak istersek, bulduğumuz karakter dizileri arasında "python" karakter dizisini göremeyiz. İşte bu duyarlılığı ortadan kaldırmak için "re.IGNORECASE" veya "re.I" derleme seçeneklerini kullanabiliriz.
    #-*-coding:utf8-*-
    
    import re
    
    metin ="""Bilgisayarlar çok farklı biçimlerde karşımıza çıkabilirler. 
    20. yüzyılın ortalarındaki ilk bilgisayarlar büyük bir oda büyüklüğünde olup, 
    günümüz bilgisayarlarından yüzlerce kat daha fazla güç tüketiyorlardı. 
    21. yüzyılın başına varıldığında ise bilgisayarlar bir kol saatine sığacak ve 
    küçük bir pil ile çalışacak duruma geldiler. Bu kadar küçük imal edilebilmelerinin 
    temel nedeni 1969 yılında yarı iletkenler ile çok küçük alanlara sığdırılabilen 
    devreler yapılabilmesidir. Şu anda kullandığımız bilgisayarlar Intel'in ilk işlemci
    unvanına sahip olan 4004'den sonra bilgisayar teknolojisi hız kazanmıştır.
    Toplumumuz kişisel bilgisayarı ve onun taşınabilir eşdeğeri,
    dizüstü bilgisayarını, bilgi çağının simgeleri olarak tanıdılar ve 
    bilgisayar kavramıyla özdeşleştirdiler. Günümüzde çok yaygın kullanılmaktadırlar. 
    Bilgisayarın temel çalışma prensibi ikili sayı sistemi yani sadece 0 ve 1 den oluşan kodlamalardır."""
    
    derle = re.compile("bilgisayar",re.I)
    print derle.findall(metin)
    
    ['Bilgisayar', 'bilgisayar', 'bilgisayar', 'bilgisayar', 'bilgisayar', 'bilgisayar', 'bilgisayar', 'bilgisayar', 'bilgisayar', 'Bilgisayar']
    
    Gördüğünüz gibi elimizde bulunan bir metindeki "bilgisayar" kelimelerini büyük,küçük harf ayırt etmeden bulmuş olduk. Eğer re.I seçeneğini kullanmış olmasaydık, çıktı olarak sadece "bilgisayar" kelimesini alırdık. re.IGNORECASE de re.I seçeneği ile aynı işleve sahiptir.
    re.DOTALL veya re.S
    Metekarakterler arasında "." metakarakterini açıklaraken, yeni satır karakteri hariç herhangi bir karakterin yerini tuttuğunu söylemiştik.
    #-*-coding:utf8-*-
    
    import re
    
    metin = "Python; \ngüçlü bir programlama dilidir"
    
    print re.search("Python.*",metin).group()
    Python;
    
    Burada gördüğünüz gibi "." metakarakteri yeni satır(\n) karakterinin yerini tutmadığı için bize sadece "Python;" ifadesini geriye döndürdü. İşte biz "." metakarakterine bu özelliği de kazandırmak istersek re.DOTALL veya re.S özelliklerinden birini kullanabiliriz.
    import re
    
    metin = "Python;\ngüçlü bir programlama dilidir."
    derle = re.compile("Python.*",re.DOTALL)
    
    print derle.search(metin).group()
    Python;
    güçlü bir programlama dilidir.
    
    Artık "." metakarakteri yeni satır karakterini de algıladı ve bize istediğimiz sonucu döndürdü. re.DOTALL seçeneği ile re.S seçeneği aynı işlevi yapmaktadır.
    re.UNICODE veya re.U
    Python'da düzenli ifadeleri kullanırken Türkçe karakter problemi ile karşılaşırız. Şu örneği inceleyelim;
    #-*-coding:utf8-*-
    
    import re
    
    liste = ["otobüs","otomobil","kamyon","minibüs"]
    
    for i in liste:
        print re.search("\w*",i).group()
    otob
    otomobil
    kamyon
    minib
    
    Gördüğünüz gibi Python Türkçe karakterlerden sonraki karakterleri almadı. İşte bu tarz sorun yaşamamak için "re.UNICODE" seçeneğini kullanacağız. Bu kullanım GNU/Linux ve Windows için biraz farklılık gösterir.
    GNU/Linux işletim sistemi için;
    # -*- coding: utf-8 -*-
    
    import re
    import locale
    locale.setlocale(locale.LC_ALL,"")
    
    liste = ["otobüs","otomobil","kamyon","minibüs"]
    
    for i in liste:
        liste[liste.index(i)] = unicode(i,"utf8")
    
    derle = re.compile("\w*",re.UNICODE)
    
    for i in liste:
        print derle.search(i).group()
    otobüs
    otomobil
    kamyon
    minibüs
    
    Gördüğünüz çıktılarımızı herhangi bir sorun olmadan aldık. Burada "import locale" ifadesinden sonrasına dikkat edin. İlk önce bir döngü içinde tüm liste elemanlarını Unicode dönüştürdük. Eğer bu dönüştürme işlemini yapmazsak yine istediğimiz çıktıyı alamayız. Ve derleme işlemi yaparken Türkçe karakterlerde sorun çıkmaması için "re.UNICODE" seçeneğini kullandık. Bu şekilde herhangi bir sorun olmadan çıktılarımızı doğru bir şekilde almış olduk.
    Windows kullanıcıları için;
    #-*-coding:cp1254-*-
    
    import locale
    locale.setlocale(locale.LC_ALL,"")
    
    import re
    
    liste = ["otobüs","otomobil","kamyon","minibüs"]
    
    derle = re.compile("\w*",re.UNICODE)
    
    for i in liste:
        print derle.search(i).group()
    
    GNU/Linux ve Windows için kullanımlarda ufak farklılıklar bulunmakta. Bu farklılıklara dikkat etmemiz gerekir. Düzenli İfadeler ile Karakter Dizisi Değiştirme İşlemleri
    Şimdiye kadar düzenli ifadelerde sürekli eşleştirme işlemleri yaptık. Düzenli ifadeler sadece bu işlem için kullanılmamaktadır. Düzenli ifadeler ile bir karakter dizisini değiştirmemizi de sağlar. Bu iş için temel olarak sub() ve subn() metotları kullanılır.
    sub() Metodu
    #-*-coding:utf8-*-
    
    import re
    
    metin = "Dünyanın en popüler sporu futbol'dur.Futbol çok eğlencelidir."
    
    derle = re.compile("Futbol",re.I)
    
    print derle.sub("Basketbol",metin)
    
    Dünyanın en popüler sporu Basketbol'dur.Basketbol çok eğlencelidir.
    
    En basit haliyle sub() metodunu kullanmış olduk. "Futbol" karakter dizilerini "Basketbol" ile değiştirmiş olduk. Daha önceden görmüş olduğumuz "re.I" seçeneği ile büyük,küçük harf uyumunu ortadan kaldırdık.
    Not:sub() metodu karakter dizilerinde öğrendiğimiz replace() metoduna çok benzer. Fakat sub() metodu hem replace() metodundan daha güçlüdür hemde beraber kullanılabilen derleme seçenekleri ile daha esnektir. Ama tabi ki replace() metodu işimiz için yeterli ise onu kullanmalıyız.
    subn() Metodu
    subn() metodu sub() metodu ile neredeyse aynıdır. Tek fark olarak yapılan değişiklik sayısını da çıktı olarak vermesidir. Bu metot çıktı olarak iki ögeli bir demet vermektedir. Birinci öge değiştirilen metin ikinci öge ise yapılan değişiklik sayısıdır.
    #-*-coding:utf8-*-
    
    import re
    
    metin = "Dünyanın en popüler sporu futbol'dur.Futbol çok eğlencelidir."
    
    derle = re.compile("Futbol",re.I|re.U)
    
    degistir = derle.subn("Basketbol",metin)
    
    print "Metin üzerinden %s değişiklik yapılmıştır."%(degistir[1])
    
    Metin üzerinden 2 değişiklik yapılmıştır.
    
    Gördüğünüz gibi kaç değişiklik yaptığımıza rahat bir şekilde ulaşmış olduk.
    Not:Düzenli ifadeler konusunu bitirdik. Bu konunun sonunda şunu söylemeliyiz ki, eğer yapmak istediğimiz işlemleri karakter dizileri metotları ile yapabiliyorsak, bu metotları kullanmalıyız. Çünkü karakter dizileri metotları hem daha hızlı hemde daha basittir.

    10 Temmuz 2013 Çarşamba

    PYQT ILE PYTHON GUI GELIŞTIRME - 2

    Portalımızı takip eden yeni python geliştirici adaylarımız, pythonun ne kadar kolay ve anlaşılır bir dil olduğunu fark etmişlerdir diye düşünmekteyiz. Konu Grafiksel Kullanıcı Arayüzü geliştirme olunca durum gene farksız.

    Bu yazımızda Not Ortalaması  uygulaması yazacağız. Bu uygulamamızda basit özellikler olacaktır. Bu özellikler aşağıda listelenmiştir.



    • 1.  vize notu istenecektir.
    • 2. vize notu istenecektir.
    • Final notu istenecektir.
    • Girdilerin sadece integer değerler olması kontrol edilecektir.
    • 3 sınavın ortalaması alınıp ekrana yazılacaktır.

    from __future__ import division
    from PyQt4.QtGui import *
    from PyQt4.QtCore import *
    
    
    class ortalamaHesapla(QWidget):
        def __init__(self, parent=None):
            super(ortalamaHesapla, self).__init__(parent)
    
            self.metin = "
    Sinav Ortalamasi Hesaplama
    " self.grid = QGridLayout() self.baslik = QLabel(self.metin) self.vizeA = QLabel('1. Vize Notunuz ') self.vizeB = QLabel('2. Vize Notunuz ') self.final = QLabel('Final Notunuz ') self.vizeAdeger = QLineEdit() self.vizeBdeger = QLineEdit() self.finalDeger = QLineEdit() self.sonuc = QLabel('Ortalama ') self.sonucDeger = QLabel('0.00') self.hesapla = QPushButton('Hesapla') self.grid.addWidget(self.baslik, 0, 0, 1, 2) self.grid.addWidget(self.vizeA, 1, 0) self.grid.addWidget(self.vizeAdeger, 1, 1) self.grid.addWidget(self.vizeB, 2, 0) self.grid.addWidget(self.vizeBdeger, 2, 1) self.grid.addWidget(self.final, 3, 0) self.grid.addWidget(self.finalDeger, 3, 1) self.grid.addWidget(self.sonuc, 4, 0) self.grid.addWidget(self.sonucDeger, 4, 1) self.grid.addWidget(self.hesapla, 5, 0, 1, 2) self.connect(self.hesapla, SIGNAL('pressed()'), self.hesapYap) self.setLayout(self.grid) self.setWindowTitle("Not Hesaplama ~ PythonDersleri") def hesapYap(self): ortalama = 0 try: ilk_vize = int(self.vizeAdeger.text()) ikinci_vize = int(self.vizeBdeger.text()) final_notu = int(self.finalDeger.text()) ortalama = (ilk_vize + ikinci_vize + final_notu)/3 except: self.sonucDeger.setText('Tam sayi giriniz!') return self.sonucDeger.setText('%0.2f' % ortalama) uyg = QApplication([]) pencere=ortalamaHesapla() pencere.show() uyg.exec_()



    Şimdi sizlere kodları açıklayalım. İlk başta bölme işleminde float sonuçların çıkması için division modülü eklenmiştir. Ardından grafiksel kullanıcı arayüzü için gerekli pyqt4 modülleri eklenmiştir.

    Grafiksel Kullanıcı Arayüzü geliştirirken iç içe olan birden fazla widget'ler olmaktadır. Tüm widgetları ve pencereleri tek bir dosyada tutmak kod karmaşıklığına neden olmaktadır. Bu nedenle tüm widget'lar farklı dosyalarda sınıf olarak tanımlanarak daha sonra ana uygulamada kullanılabilir.


    QGridLayout, ızgara yerleşkesidir. Pencerenizi bir ızgara olarak düşünürseniz, sol üstte ki ilk alan 0, 0 noktasıdır. Oluşturacağımız label, buton vs görselleri bu koordinat sistemine yerleştireceğiz. Bu nedenle QGridlayout'un  addWidget metodunun parametrelerini inceleyelim.

    addWidget(eklenecek item, satir, satun, satir genişliği, sutun genişliği);

    Örnek olarak; addWidget(ders_adi, 0, 0, 1, 2)

    ders_adi  item'ini sıfırıncı  satırın  sıfırıncı  sütununa yerleştir. Bir adet satır genişliğinde olsun ama iki adet sütun genişliğinde yer kaplasın. Sadece satır ve sütun koordinatları verilirse, default olarak kapladığı satır ve sütun alanları 1 olarak atanmaktadır.

    15 ile 24. satırlar arasında gerekli Label ve LineEdit elemanlarımız tanımlanmakta. 26 ile 35. satırlar arasında ise bu elemanlarımız GridLayout'umuza eklenmekte. Eklenme sırasına ve atanan koordinatlara lütfen dikkat ediniz.

    37 ve 40. satırlarda yapılan işlemlere ilk yazımızdan aşına olduğunu düşünmekteyiz.

    hesapYap metodu incelendiğinde ise text box'lardan text() metodu ile değerlerin okunduğu. Bunların integer değerlere dönüştürüldüğü görülmektedir. Ardından bölme işlemi gerçekleşmektedir. Bu işlemler try;except blokları arasında tanımlanmıştır. Bu hata gerçekleşir ise bunun muhtemel nedeni text box'ların boş bırakılması veya string değer girilmesidir. Bu durumda sonucDeger label'ının değeri kırmızı font'ta hata yazısı yazacak şekilde değiştirilmiştir. Eğer tüm işlemler doğru şekilde gerçekleşir ise, sonuç 52.  satırda ekrana yansıtılmaktadır. %0.2f ise sonucun sadece virgülden sonra ki sadece 2 basamağın yazılmasını ifade etmektedir.




    ALIŞTIRMALAR:

     Bu uygulamaya ek özellikler ekleyebilirsiniz;
    1 -uygulama açıldığında 640x480 boyutlarında açılsın.
    2 -Boş değer veya string girişlerinde ki hataların birbirinden ayrılması. Örnek olarak ; "1. vize notuna değer girmediniz" veya "Final notu alanı sadece tam sayı içerebilir" gibi hataların yakalanması.
    3 - Küsüratı .33 olan değerlerin .50 değerine, .66 olanların iste bir üst tam sayıya yuvarlanması.
    4 - Hesapla butonunun yanına "Formu Temizle" butonunun eklenmesi ve tıklandığında formun temizlenmesi.

    Bu özellikleri eklerken yaşadığınız problemleri konu altına yorum olarak yazabilirsiniz. Ekip problemlerinize çözüm üretmeye çalışacaktır.