Açıklama satırları

Python programlama dilinde açıklamalar # işaretinden sonrası için geçerlidir. Örneğin:

#bu bir açıklama satırıdır.

Bununla birlikte çoklu açıklama satırı yapmak için """ işareti arasına alabiliriz.

""" Bu bir açıklama satırı
Bu diğer açıklama satırı
Bu son açıklama satırı """

Temel bilgiler

Python programlarının ilk satırında #!/usr/bin/python3 satırı bulunmalıdır. Bir python programını çalıştırmak için Şunları uygulamamız gereklidir.

#!/usr/bin/python3
# Çalıştırma izni vererek çalıştırabiliriz.
chmod +x dosya.py
./dosya.py
# Veya doğrudan çalıştırabiliriz.
python3 dosya.py

Python programlama dilinde satır sonuna ; koyulmaz.

Python programlarında işler işlevler üzerinden yürür. işlevlerin girdileri ve çıktıları bulunur.

cikti = islev(girdi1, girdi2)

Pythonda girintileme olayı için de { ve } kullanılmak yerine boşluklandırma kullanılır. Herhangi bir girintilemeye başlanan satırın sonunda : işareti bulunur. Örneğin:

f = 12 # f sayısını 12ye eşitledik
if f == 12: # f sayısı 12ye eşit mi diye sorguladık
    print("eşit") # ekrana yazı yazdırık

Girintileme için 4 boşluk, 2 boşluk veya tek tab kullanabilirsiniz. Bu yazıda 4 boşluğu tercih edeceğiz.

Yazı yazdırma

Pythonda ekrana yazı yazmak için print işlevini kullanıyoruz.

print("Merhaba Dünya")
-> Merhaba Dünya

Birden çok ifadeyi yazdırmak için print işlevine birden çok girdi verebilirsiniz. Bu şekilde aralarına birer boşluk koyarak yazdırır.

# Yazılar tırnak içine alınır.
# Sayılar tırnak içine alınmaz.
# True ve False doğruluk belirtir.
print("Merhaba",12,"Dünya",True)
-> Merhaba 12 Dünya True

Değişkenler

Değişkenler içerisinde veri bulunduran ve ihtiyaç durumunda bu veriyi düzenleme imkanı tanıyan kavramlardır. Değişkenler tanımlanırken degisken = deger şeklinde bir ifade kulanılır.

i = 12
yazi = "merhaba dünya"
k = 1.2
hmm = True

Değişken adları sayı ile başlayamaz, Türkçe karakter içeremez ve sadece harfler, sayılar ve - _ karakterlerinden oluşur.

Değişkenler kullanılırken başına herhangi bir işaret almasına gerek yoktur. Örneğin:

i = 12
print(i)
-> 12

Değişkenler tanımlanırken her ne kadar türlerini belirtmesek bile birer türe sahip olarak tanımlanır. Bunlar başlıca integer, float, string, boolean türleridir.

Bir değişkenin türünü öğrenmek için type işlevini kullanabiliriz.

veri = "abc123"
turu = type(veri)
print(turu)
-> <class 'str'>

Boş bir değişken tanımlamak için onun değerine None atayabiliriz. Bu sayede değişken tanımlanmış fakar değeri atanmamış olur.

veri = None
tur = type(veri)
print(tur)
-> <class 'NoneType'>

yazi1 = "merhaba"
yazi2 = 'yazım'
yazi3 = """dünya"""

yazi = "merhaba" + ' ' + """dünya"""
print(yazi)
-> merhaba dünya

yazi = "ali"*5
print(yazi)
-> alialialialiali

veri = "Merhaba"
veri2 = veri.replace("rha","123")
print(veri2)
-> Me123ba

sayi = (((24/2)+4)*2)-1
"""
24/2 = 12
12+4 = 16
16*2 = 32
32-1 = 31
"""
print(sayi)
-> 31

sayi = 2**3
print(sayi)
-> 8

print(int("12")/2)
-> 6

sayi = 1/2 # sayi = 0.5 şeklinde de tanımlanabilir.
print(sayi)
-> 0.5

sayi = 3.2
print(sayi)
sayi2 = int(3.2)
print(sayi2)
-> 3.2
-> 3

print(float("2.2")/2)
-> 1.1

bool = 12 == 13
"""
== eşit
!= eşit değil
<  küçük
>  büyük
<= küçük eşit
>= büyük eşit
"""
print(bool)
-> False

veri = not True
print(veri)
-> False

veri = "ef" in "Dünya"
veri2 = "ny" in "Dünya"
print(veri,veri2)
-> False True

veri = 12 < 6 or 4 > 2 # False or True = True
print(veri)
-> True

Klavyeden değer alma

Python programlarının kullanıcı ile etkileşime girmesi için klavye üzerinden kullanıcıdan değer alması gerekebilir. Bunun için input işlevi kullanılır. Bu işlevin çıkışı string türündendir.

a = input("Bir değer girin >")
print(a,type(a))
<- 12
-> 12 <class 'str'>

String türünden bir ifadeyi bir değişken üretmek için kullanmak istiyorsak eval işlevini kullanabiliriz.

a = eval("12/2 == 16-10") # string ifade çalıştırılır ve sonucu aktarılır.
print(a)
-> True

Not: Bu işlev tehlikelidir. Potansiyel güvenlik açığına neden olabilir! Mümkün olduğu kadar kullanmayın :D

Koşullar

Koşul tanımı yapmak için if ifadesi kullanılır. Koşul sağlanmıyorsa elif ifadesi ile yeni bir koşul tanımlanabilir veya else ifadesi ile koşulun sağlanmadığı durum tanımlanabilir.

if koşul:
    eylem
elif koşul:
    eylem
else:
    eylem

Örneğin bir integer değişkenin çift olup olmadığını bulalım.

if 13 % 2 == 0 : # % işareti bölümden kalanı bulmaya yarar.
    print("Çift sayı")
else:
    print("Tek sayı")

Değeri olmayan (None) değişkenler koşul ifadelerinde False olarak kabul edilir.

veri = None
if veri:
    print("Tanımlı")
else:
    print("Tanımsız")
-> Tanımsız

Koşul tanımlamayı alternatif olarak şu şekilde de yapabiliriz:

koşul and eylem
""" Şununla aynıdır:
if koşul:
    eylem
"""
koşul or eylem
""" Şununla aynıdır:
if not koşul:
    eylem
"""

Bu konunun daha iyi anlaşılması için:

12 == 12 and print("eşittir")
12 == 14 or print("eşit değildir")
-> eşittir
-> eşit değildir

Diziler

Diziler birden çok elemanı içerebilen değişkenlerdir. Diziler aşağıdaki gibi tanımlanır:

a = [1, 3, "merhaba", True, 1.2, None]

Dizilerin elemanlarının türü aynı olmak zorunda değildir. Hatta None bile olabilir.

Dizilerde eleman eklemek için append veya insert işlevini eleman silmek için ise remove veya pop işlevi kullanılır. Örneğin:

a = [22]
print(a)
a.append("Merhaba") # Sona ekleme yapar.
a.insert(0,12) # 0 elemanın ekleneceği yeri ifade eder.
print(a)
a.remove(22) # 22 elemanını siler
print(a)
a.pop(0) # 0. elemanı siler.
print(a)
-> [22]
-> [12, 22, 'Merhaba']
-> [12, 'Merhaba']
-> ['Merhaba']

Dizileri sıralamak için sort boşaltmak için ise clear işlevi kullanılır. Bir dizinin istenilen elemanını öğrenmek için liste[index] şeklinde bir ifade kullanılır. Index numaraları 0dan başyan integer olmalıdır. negatif değerlerde sondan saymaya başlar.

a = [1, 3, 6, 4, 7, 9, 2]
print(a[2],a[-3])
a.sort()
print(a)
a.clear()
print(a)
-> 3 7
-> [1, 2, 3, 4, 6, 7, 9]
-> []

Dizideki bir elemanın uzunluğunu bulmak için len işlevi, elemanın dizinin kaçıncısı olduğunu bulmak için ise index işlevi kullanılır.

a = [12, "hmm", 3.2]
sayi = len(a)
sayi2 = a.index(3.2)
print(sayi,sayi2)
-> 3
-> 2

Dizilerin elemanlarını + kullanarak birleştirebiliriz.

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)
-> [1, 2, 3, 4, 5, 6]

Dizilerin bir bölümünü aşağıdakine benzer yolla kesebiliriz:

a = [1, 3, 5, 7, 9, 12, 44, 31, 16]
b = a[:2] # baştan 3. elemana kadar.
c = a[4:] # 4. elemandan sonrası
d = a[3:6] # 4. elemandan 6. elemana kadar (dahil)

String türünden bir değişkeni belli bir harf veya harf öbeğine göre bölmek için split işlevini kullanırız. Ayrıca string türünden bir değişkenin başındaki ve sonundaki boşlukları temizlemek için strip işlevini kullanırız.

veri="   Bu bir yazıdır   "
veri2 = veri.strip()
print(len(veri),len(veri2))
liste = veri2.split(" ")
print(liste)
-> 20 14
-> ['Bu', 'bir', 'yazıdır']

While döngüsü

Döngüler belli bir işi koşul bağlanana kadar tekrar etmeye yarayan işlevdir. Kısaca while döngüsü ile if arasındaki fark while içerisindeki durum tamamlandığı zaman tekrar başa dönüp koşulu kontrol eder.

while koşul:
    eylem

Örneğin 1den 10a kadar olan sayıları yazalım. Bu durumda i sayısı 10 olana kadar sürekli olarak ekrana yazılıp değeri 1 arttırılacakdır.

i = 1
while i < 10:
    print(i)
    i+=1 # i = i + 1 ile aynı anlama gelir.
-> 1 2 3 4 5 6 7 8 9 (Bunu alt alta yazdığını hayal edin :D )

Bir döngüden çıkmak için break ifadesi kullanılır. Döngünün o andi adımını tamamlayıp diğer adıma geçmek için ise continue ifadesi kullanılır.

Örneğin aşyağıda siz çift sayı girene kadar sürekli olarak çalışan bir program yazalım.

while True:
    sayi = int(input("Sayı girin"))
    if sayi % 2 == 0:
        break

For döngüsü

For döngüsü while ile benzerdir fakat koşul aranmak yerine iteration yapar. Bu işlemde bir dizinin bütün elemanları tek tek işleme koyulur. Aşağıdaki gibi bir kullanımı vardır:

for eleman in dizi:
    eylem
# Şununla aynıdır
i = 0
toplam = len(dizi)
while i < toplam: # eleman yerine dizi[i] kullanabilirsiniz.
    eylem
    i += 1

Örneğin bir integer değişkenlerden oluşan dizi oluşturalım ve elemanlarını 2ye bölerek ayrı bir diziye ekleyelim.

a = [2, 4, 6, 8, 10] # dizi tanımladık
b = [] # diğer diziyi tanımladık
for i in a: # a elemanları i içine atılacak
    b.append(i/2) # b içine elemanın yarısını ekledik.
print(b)
-> [1, 2, 3, 4, 5]

Eğer dizi yerine string türünden bir değişken verirsek elemanlar bu stringin harfleri olacaktır. Aşağıdaki örnekte string içerisinde kaç tane a veya e harfi bulunduğunu hesaplayalım.

veri = "Merhaba Dünya"
toplam = 0
for i in veri:
    if i == "a" or i == "e":
        toplam += 1
print(toplam)
-> 4

Şimdiye kadarki anlatılanların daha iyi anlaşılması için asal sayı hesaplayan bir python kodu yazalım:

asallar = [2] # ilk asal sayıyı elle yazdık.
i = 3 # Şu anki sayı
while i < 60: # 60a kadar say
    hmm = True # asal sayı mı diye bakılan değişken
    for e in asallar: # asal sayılar listesi elemanları
        if i % e == 0: # tam bölünüyor mu
            hmm = False # asal sayı değildir
            break # for döngüsünden çıkmak için
    if hmm: # Asal sayıysa diziye ekleyelim
        asallar.append(i)
    i += 1 # mevcut sayımızı 1 arttıralım.
print(asallar) # 60a kadar olan asal sayılar dizisini yazalım.
-> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]

İşlevler

Python programlarken işlev tanımlayıp daha sonra bu işlevi kullanabiliriz. İşlevler aşağıdaki gibi tanımlanırlar:

def islev(girdi1,girdi2):
    eylem

işlevlerde çıktı sonucu olarak bir değişken döndürmek için return ifadesi kullanılır. Örneğin girdideki sayıları toplayan işlev yazalım.

def topla(sayi1,sayi2):
    return sayi1 + sayi2
    print("Merhaba") # bu satır çalıştırılmaz
toplam = topla(3,5)
print(toplam)
-> 8

Eğer bir değişken sadece işlevin içerisinde tanımlanırsa o değişken işlevin dışında tanımsız olur.

def yazdir():
    yazi = "Merhaba"
    print(yazi)
yazdir()
print(yazi)
-> Merhaba
-> Traceback (most recent call last):
->   File "ders.py", line 5, in <module>
->     print(yazi)
-> NameError: name 'yazi' is not defined

Bir işlevin ne işe yaradığını öğrenmek için help işlevi kullanılır. işlevin ne işe yaradığını tanımlamak için ise ilk satıra """ içerisine yazabiliriz. Bunu tanımlamak programınızı inceleyen diğer insanlar için yararlı olacaktır.

def abc(sayi):
    """Girilen sayıyı 10dan çıkartır"""
    return 10-sayi
help(abc)
->  Help on function abc in module __main__:
->
->  abc(sayi)
->      Girilen sayıyı 10dan çıkartır

Bir işlevin birden çok çıktısı olabilir. Bunun için return ifadesini virgülle ayrılmış olarak birden çok değişken ile kullanmalıyız.

def yer_degistir(a,b):
    """Girilen değişkenlerin yerini değiştirir"""
    return b,a
c = 12
d = 31
c,d = yer_degistir(c,d)
# Bunun yerine doğrudan c,d = d,c kullanılabilirdi.
print(c,d)
-> 31 12

Konunun daha iyi anlaşılabilir olması için girilen dizinin sayılarının ortalamasını alan bir fonksiyon yazalım.

def ortalama(dizi):
    toplam = 0 # toplam değişkeni tanımladık.
    for eleman in dizi: # for döngüsü oluşturduk.
        toplam += int(eleman) # elemanları topladık.
    return toplam / len(dizi) # toplamı eleman sayısına böldük.

ort = input("Dizi giriniz. aralarına , koyunuz")
print(ortalama(ort.split(",")))
<- 1,34,22,-32
-> 6.25

Sınıflar

Sınıf kavramı işlevlerin ve değişkenlerin guruplanarak nesneler haline getirilmesinden meydana gelir. Yani bir sınıf ona bağlı işlevlerden ve değişkenlerden oluşur. Sınıflar aşağıdaki gibi tanımlanırlar.

class sinif:
    def __init__(self,girdi):
        eylem
    def islev(self,girdi):
        eylem

Burada __init__ işlevi sınıfı oluştururken çalıştırılan ilk eylemleri tanımlamak için kullanılır. sınıf işlevleri tanımlanırken ilk girdi olarak self kullanılmalıdır. Bu ifade sınıfın kendisi anlamına gelir. Örneğin bir sınıf tanımlayalım ve bu sınıftaki işlevler ile girdideki sayılara toplama ve çıkartma işlemi uygulayalım.

class sayi_isle:
    def __init__(self,ilk,ikinci):
        self.sayi1 = ilk
        self.sayi2 = ikinci
    def topla():
        return self.sayi1 + self.sayi2
    def cikart():
        return self.sayi1 - self.sayi2

nesne = sayi_isle(12,3)
a = nesne.topla()
b = nesne.cikart()
print(a,b)
-> 15 9

Burada işlevlere nesne.islev() ifadesi ile erişebiliyoruz. Aynı zamanda değişkenlere de nesne.degisken ifadesi ile erişmemiz ve değiştirmemiz mümkündür. Sınıf içerisinden ise self.islev() ve self.degisken şeklinde bir ifade kullanmamız gerekmektedir.

Dosya işlemleri

Bir dosyayı açmak için open işlevi kullanılır. Açılan dosyadan satır okumak için readline işlevi, tamamını okumak için read işlevi, tüm satırları okuyup dizi haline getirmek için ise readlines işlevi kullanılır.

deneme.txt adında içeriği aşağıdaki gibi olan bir doysamız olsun:

Merhaba dünya
Selam dünya
sayı:123

Aşağıdaki örnekte bu dosyayı açıp okuyup ekrana basalım.

dosya = open("dosya.txt","r") # okumak için r kullanılır.
ilksatir = dosya.readline()
tumu = dosya.read()
satirlar = dosya.readlines()
print(len(satirlar))
-> 3

Dosyaya yazmak için ise write işlevi kullanılır. Okuma ve yazma işlemleri bittikten sonra close işlevi ile dosya kapatılmalıdır. Dosyayı kapatmadan değişiklikleri diske işletmek için flush işlevi kullanılır.

dosya = open("dosya.txt","w") # yazmak için w eklemek için a kullanılır.
dosya.write("Merhaba dünya\n")
dosya.write("Selam dünya\n")
dosya.write("sayı:123\n")
dosya.close()

Modüller

Python programlarında kodların markaşıklaşmasını önlemek ve daha kullanışlı hale getirmek amacıyla modüller bulunur. Modüller import ifadesi ile çağırılır. Modüller aslında birer Birer python kütüphanesidir ve sınıf sayılırlar. Örneğin deneme.py dosyamızda aşağıdaki kodlar bulunsun:

yazi = "Merhaba"
sayi = 12
def yazdir():
    print(yazi)
class sinif:
    def islev(self):
        print("selam")

Şimdi bu modülümüzü çağırıp içerisindeki işlevleri ve değişkenleri kullanalım.

import deneme # deneme modülünü çağırdık
print(deneme.yazi) # değişkeni kullandık
deneme.yazdir() # işlevi kullandık.
deneme.sayi = 76 # değişkeni değiştirdik
nesne = deneme.sinif() # sınıftan nesne oluşturduk
nesne.islev() # nesneyi kullandık
-> Merhaba
-> selam

Şimdiye kadar anlatılanların daha iyi anlaşılması için aşağıda ini parser örneği yapalım. Örnek bir ini dosyası aşağıdaki gibidir:

[bölüm1]
veri1=deger1
veri2=deger2
[bölüm2]
veri3=deger3
veri4=deger4

Bir adet modül yazıp bu modül ile ini dosyası okuyup istenilen bölümdeki değeri bulalım ve döndürelim.

[Merhaba]
dünya=12
selam=44
[hmm]
veri=abc123x
sayı=44

# iniparser.py içeriği
dosya = None # boş dosya nesnesi
class inidosya:
    def __init__(self,yol):
        ini = open(yol,"r") # ini dosyasını açtık
        self.icerik = ini.read() # dosya içeriğini okuduk
    def deger_al(bolum,veri):
        etkin = False # istenilen yere gelene kadar etkisiz kal
        for satir in dosya.icerik.split("\n"):
            if "[" + bolum + "]" in satir: # okunan satırda istenilen bölümün başı mı
                etkin = True # etkinleştir
            if etkin and "=" in satir: # etkinse ve satırda = bulunuyorsa
                if satir.split("=")[0] == veri: # = işaretine göre 0. eleman aranan mı
                    return satir.split("=")[0] # = işaretine göre böl . elemanı al

# main.py dosyası içeriği
import iniparser # modülü yükle
iniparser.dosya = iniparser.inidosya("dosya") # ini dosyasını yükle
deger=iniparser.deger_al("hmm","veri") # değeri al
print(deger.strip()) # değerin başında sonunda boşluk varsa sil ve yaz
-> abc123x

Bir modülü diğer bir modülün genişletilmişi olarak tanımlayabiliriz. Gelişletilen modül asıl modüldeki tüm fonksiyonlara ve değişkenlere sahip olur. Aşağıdaki örnekteki gibi super().__init__() kullanarak üst modülümüzdeki tüm tanımlamalara sahip olmasını sağlayabiliriz.

# ornek.py dosyası
class deneme:
    def __init__(self):
        self.sayi = 13
    def hmm(self,yazi):
        print(yazi)

class genis(deneme):
    def __init__(self):
        super().__init__()
        self.sayi2 = 44

# main.py dosyası
from ornek import genis as g # ornek.py dosyasındaki genis sınıfını g olarak içeri aldık.
print(g.sayi, g.sayi2)
g.hmm("abc123")
-> 13 44
-> abc123