C Programcıları İçin Python

Uyarı: Bu yazı hazırlanması devam eden bir taslak halindedir. Bilgilerin doğruluğu ve bütünlüğü tamamlanana kadar garanti edilmemektedir.

Giriş

Daha önceden kaptığınız birçok alışkanlıktan sizi uzaklaştıracak bir dil için hazır olun. Tür tanımlamaları, değişken belirtmeleri, boyut kısıtlamaları gibi kavramlarla uzun uzun süreler boyunca uğraşmayacağınız bir dil olan Python hakkında bu yazıda elimden geldiğince bir C programcısının Python’a geçişi için karşılaştırmalara, özelliklere yer vermeyi düşünüyorum. Eğer daha önce bir programlama tecrübeniz yoksa, Python başlangıç için uygun bir dildir. Ancak başlangıç kaynağı olarak bu sayfayı kullanmanız önerilmez. Python ile başlamak isterseniz İstihza‘yı kullanabilirsiniz. Bunun dışında daha az kapsamlı olan, oyun yapımının temellerini ve bilgisayar bilimlerini öğrenmek isterseniz, çevirisi yeni biten Arcade Türü Oyun Programlamayı ve Bilgisayar Bilimlerini Öğrenin linkinden faydalanabilirsiniz.

Bunların ardından, konumuza, yani C’den Python’a geçişe dönelim. Öncelikli olarak, daha önce JavaScript veya herhangi başka bir script dili ile tecrübeniz varsa, Python’un da bir script dili olduğunu bilmeniz sizi rahatlatabilir. Python kodları derlenerek çalışmaz, yorumlanarak çalışır. Ama ticari bir uygulama geliştirmek, uygulamanızı daha rahat yaymak vb. bir sebebiniz varsa derlemek için de yöntemler mevcuttur. Bu şekilde hazırlanmış birkaç uygulamayı bu blogta bulmanız mümkün. Yorumlanan bir dille çalışmanın faydası, kodunuzu satır satır yazıp test edebilmeniz, tıpkı işletim sisteminizin komut satırında işlem yapar gibi de ufak denemelerinizi gerçekleştirmeniz, ve belki de en önemlisi büyük projelerle çalışırken uzayıp gidebilecek derlenme süresinden kurtulmanız anlamına gelir. Bu kadar bilginin ardından artık biraz aksiyon görme zamanı geldi sanırım.

Genel Program Yapısı

#include <stdio.h>

int main(void){
    printf("Ilk C Programi!");
    return 0;
}

Yukarıda gördüğünüz kodu Python’da Türkçe karakter kısıtlamasına takılmaksızın şöyle yazıyoruz:

print("İlk Python Programı!")

printf fonksiyonu yerine print isimli bir fonksiyon kullandık. Python3 utf8 ile geldiği için, Türkçe karakter konusunda aklınıza gelebilecek birçok yerde kısıtlamayla veya hatayla karşılaşmayacaksınız. Ancak yine de, el alışkanlığını bozmamak adına değişken isimlerinde Türkçe karakter kullanmamanızı öneririm. İsterseniz şimdi değişkenlere bir bakalım.

Değişkenler

a = 3
b = 5.131243432
c = "Güray Yıldırım"
d = 0b01010101
ışık = 0xFF

Değişken türü tanımlamadığımıza, değişkenlerin başlarına vs. bir şey koymadığımıza dikkat edin! Ayrıca, print fonksiyonundaki gibi, satır sonunda yine noktalı virgülün olmadığına dikkat edin. Python’da satır sonlarına “;” konulmaz. Ama alışkanlıklarınızın size problem yaratacağını düşünmeyin. Şu kod da tıpkı yukardaki gibi sorunsuz çalışacaktır:

a = 3;
b = 5.131243432;
c = "Güray Yıldırım";
d = 0b01010101;
ışık = 0xFF;

C’de şöyle bir tanımlama yapmamız mümkündü:

int a = 3, b = 1;
float c = 3.2;
/* Aynı şekilde aşağıdaki de mümkündü */
int a = 3, b = 1; float c = 3.2

Bunu bazı Python kitaplarında şu şekilde görmemiz mümkün:

a = 3; b = 1; c = 3.2

Kısacası noktalı virgül kullanımında kendinizi özgür hissedin. Ama yine de, karşılaşacağınız Python kodlarının büyük kısmında onları göremeyeceğinizi ve onları kullanmanın Python geleneğine çok da uygun olmadığını bilin.

Değişken isimlendirme kuralları birçok dilde olduğu gibi Python’da da C ile aynıdır. Tek fark biraz önce bahsedildiği gibi Türkçe karakter kullanımına Python 3 itibariyle izin verilmesidir. Python ile çalışırken kodları etkileşimli kabukta(shell) şu şekilde yazmak da mümkündür:

>>> a = 2
>>> b = 323.4
>>> c = "Güray"
>>> print(a)
2
>>> print(b)
323.4

Burada, yukarıda da bahsettiğimiz gibi ufak çaplı denemeleri yapabilmek için oldukça ideal bir ortam buluyoruz. Özellikle veritabanı sorgulamalarında, url isteklerinde ve buna benzer durumlarda bunun faydasını anlayacaksınız. Değişkenlerin türlerini öğrenmek için detype() fonksiyonunu kullanabiliriz.

Uyarı: Başlarında >>> ibaresi bulunan kodlar etkileşimli kabukta çalıştırılmıştır. Bunları program dosyasına koymayın.

>>> type(3)
<class 'int'>
>>> type(3.2)
<class 'float'>
>>> type("Güray")
<class 'str'>
>>> type(0b01010101)
<class 'int'>
>>> a = "Yıldırım"
>>> type(a)
<class 'str'>

Ayrıca, Python’da tanımlanan her şey aslında birer nesne olarak tanımlanır. Python’un nesne tabanlı olduğunu da burda hatırlatmış olalım. Bir değişken, fonksiyon, nesne veya her ne olursa olsun, üzerinde kullanılabilecek metotları da dir() fonksiyonunu kullanarak şu şekilde görmemiz mümkün:

>>> dir("Güray")
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> dir(3)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

Bir kez atama yapılan değişkenin türü sabit değildir. Yani tamsayı olan değişkene, bir string atanabilir, hatta birazdan bahsedeceğimiz liste, demet ya da bir nesne bile atayabilirsiniz:

>>> a = 3.2
>>> type(a)
<class 'float'>
>>> a = "Güray"
>>> type(a)
<class 'str'>

If Yapıları (Koşullu İfadeler)

Çoğu dilde olduğu gibi Python’da da, C’ye benzer bir if yapısı kullanılır. Yapının benzer olması, Python’un etkilerinin görülmesine engel değildir. Python’da, C’de kullandığımız { } yerine girintileme sistemi kullanılmaktadır. Bu sadece if yapısı için değil, döngüler, sınıflar ve buna benzer her yerde geçerlidir. Girintileme sistemi dediğimiz, if yapısının içerisinde yer alan kodların { ve } simgelerinin arasına yazılması yerine, birer sekme (tab tuşuna basarak) boşluk bırakılarak yapılmasıdır. Burada sekme boyutu kullandığınız geliştirme ortamı (IDE) üzerinden ayarlanabilmektedir. Python’da girintilemeyi sekme ile yapma zorunluluğu da yoktur. Boşluk tuşuna bir sekme oluşturacak kadar basmak yeterlidir. Ayrıca, sekmenin 4 boşluktan oluşması da zorunlu değildir. İki boşlukla da, 8 boşlukla da bir if yapısı kurulması mümkündür. Burada önemli nokta, girintilerin programın tamamında aynı şekilde kullanılmasıdır. Yani ilk if yapısında 4 boşluk boyutunda 1 sekme kullanıldıysa devamındaki döngüde 2 boşluk bırakılması hataya yol açacaktır. Kısacası, tutarlılık önemlidir. Bu da Python kodunun okunabilirliğinin yüksek olmasının temel sebeplerinden biridir. Şimdi bu kurallara bağlı olarak, aynı işi yapan birkaç if örneği görelim:

>>> if a < 5:
...     print("a 5'ten küçüktür.")
... else:
...     print("a 5'ten küçük değildir.")
... 
a 5'ten küçüktür.

Girintileme sistemi yukarıdan anlaşılabilir. Bunun dışında, if’in ardından sadece girintileme değil, bir de iki nokta işareti (:) kullanıldığına dikkat edin. Python’da girintilemelerden önce bu işareti kullanıyoruz. C’den farklı olan bir diğer nokta ise, birçok dildeki else if yapısı yerine Python’da kısaca elif yapısının kullanılmasıdır. Bunu da şöyle örneklendirebiliriz:

>>> a = 10
>>> if a < 10:
...     print("10'dan küçük.")
... elif a == 10:
...     print("10'a eşit.")
... else:
...     print("10'dan büyük.")
... 
10'a eşit.

C’de kullandığımız || ve && yerine Python altında genellikle and ve or kelime olarak kullanılmaktadır. Ancak bu işaretler kesinlikle kullanılmak istenirse, tek bir tane ( | veya & olarak ) kullanılmaları gerekmektedir. Operatörlerin işlevleri (^ dahil) C’deki ile aynıdır.

>>> True | True
True
>>> True | False
True
>>> False | False
False
>>> 1 | 0
1
>>> 1 & 0
0
>>> 1 ^ 0
1
>>> 1 ^ 1
0
>>> 0 ^ 0
0

Son olarak, switch-case yapısı Python’da bulunmamaktadır.

Diziler

Başlıkta her ne kadar dizi yazdıysam da, Python’da array tipinde bir veri, dışarıdan bir kütüphane kullanmadığınız sürece (numpy modülünde rastladım) yoktur. Onun yerine elimizdeliste, demet ve sözlükler vardır. Burada, yaygınlığı sebebiyle liste ve demetlerden bahsetmekle yetineceğim. Sözlüklerden de kısaca bahsedeceğim.

Listeler

Öncelikle, burada listelerde ve diğer türlerde tanımlayacağımız nesnelerin C’den farklı olarak içlerinde farklı değişken türlerini aynı anda bulundurabildiklerini söylemek gerekiyor. Yani bir dizide hem integer, hem string hem de bir object(nesne) aynı anda bulunabiliyor. Listeler, arraylerden farklı olarak sabit boyutlu değillerdir. Yani içerisinde 5 öğe olan bir listeye istediğimiz kadar daha öğe eklememiz mümkündür. Ayrıca, tanımlama esnasında da boyutu belirtilmez. Listeler, [ ] işaretleri arasında tanımlanır. Boş liste tanımlamak için de [] kullanabiliriz. İndisleme sistemi ise C ile aynıdır.

>>> liste = []
>>> type(liste)
<class 'list'>
>>> liste = [1,2,3,"elma","armut",3.43423]
>>> len(liste) # Listenin uzunluğunu öğrenmeye yarar.
6
>>> len("G")
1
>>> len("Güray") # Görüldüğü üzere aslında birçok şeyin uzunluğunu verir.
5
>>> liste[2]
3
>>> liste[3]
'elma'
>>> liste[-1]
3.43423
>>> liste[-2]
'armut'
>>> liste.append("Sona eklenecek")
>>> liste
[1, 2, 3, 'elma', 'armut', 3.43423, 'Sona eklenecek']
>>> liste[2:4]
[3, 'elma']

İndisleme sisteminde, son satırda 2:4 ifadesinin 2 ve 3 indisli öğeleri verdiğine dikkat edin. Bunun anlamı, ilk sayıdan(2) başlayarak son sayıdan(4) bir önceki öğeye kadar olanları bize döndürdüğüdür. Arada belirtilen len() fonksiyonunun anlaşılır olduğunu ümit ediyorum. Arada verdiğimiz append() metodu yardımıyla listenin sonuna ekleme yapmak mümkündür. Ayrıca, listenin istenilen yerine ekleme yapmak için insert() metodunu kullanabilirsiniz (liste.insert(indis,”öğe”) şeklinde).
Listelerden yeri geldiğince bahsetmek üzere, onlara burada ara verip, demetlere geçelim.

Demetler

Demetler, listelerle aşağı yukarı aynı işlevi gören öğelerdir. Farkları ise, üzerlerinde değişiklik yapılamamasıdır. Yani bir demet tanımlandıktan sonra, ekleme, silme veya herhangi bir öğesinin içeriğini değiştirme gibi işlemleri yapmamız mümkün değildir. Avantajı ise listelere göre daha hızlı çalışmalarıdır. Ayrıca istenmeyen veri kayıplarını da engellemek için kullanılabilir. Tanımlarken listelerden farklı olarak parantezleri ( ) kullanıyoruz.

>>> demet = (1,2,3, "Güray")
>>> type(demet)
<class 'tuple'>
>>> len(demet)
4
>>> demet[2]
3
>>> demet[1] = "değişmeyecek, hata verecek."
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Sonda yapılan işlemde demetin bir elemanına yeni bir atama yapılmaya çalışılmış ve hata alınmıştır. Bu atama işlemini liste ve birazdan göreceğimiz sözlüklerde istediğimiz gibi yapabiliyoruz.

Sözlükler

Küme parantezi içerisinde tanımlanırlar. Anahtar ve değer çiftlerinden oluşurlar. Kod örneği aşağıda görülmekle birlikte, indisleme sisteminin kullanılamadığını gösterme amaçlı da bir hatalı deneme yapılmış ve sonucu da eklenmiştir.

>>> sozluk = {"Anahtar1":"Değer1","Anahtar2":"Değer2"}
>>> sozluk
{'Anahtar1': 'Değer1', 'Anahtar2': 'Değer2'}
>>> print(sozluk)
{'Anahtar1': 'Değer1', 'Anahtar2': 'Değer2'}
>>> print(sozluk[0])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 0
>>> print(sozluk['Anahtar1'])
Değer1
>>> print(sozluk['Anahtar2'])
Değer2
>>> type(sozluk)
<class 'dict'>

Sözlüklerin türünü sorguladığımızda da dictionary’den kısaltma dict‘e rastlıyoruz.
Python’da bu veri türlerine benzer olarak bir de kümeler vardır. Ancak kullanımı çok yaygın olmadığı için şu anlık ondan bahsetmiyorum.

Döngüler

Öncelikle C’de kullandığımız do-while döngüsünün Python’da olmadığını belirterek başlayayım. Python’da iki adet döngü ile haşır neşir oluyoruz; for döngüsü ve while döngüsü. Eğer işimiz sonsuz döngüye sokmaksa, birazdan farkedeceğiniz nedenlerden dolayı çözümümüz while döngüsü oluyor.

For Döngüsü

Python’da for döngüsü, elimizde iterasyona uğratabileceğimiz bir nesne yer aldığında kullanılabilir. İterasyona uğrayabilecek nesneler denince akla ilk gelenler ise listeler, demetler, sözlüklerin anahtar ve değerleri, bazı fonksiyonların verdikleri çıktılar(generator objects) olmaktadır. For döngsünün özelliği ise, bir sıralı liste ya da bu tür bir nesnenin tüm elemanlarını bir değişkene sıra ile atıp her değer için tekrar dönmesi, elemanlar bitince döngünün otomatik olarak sonlanmasıdır. Bu sebeple for döngüsünü sonsuz döngüye sokamıyoruz.

Kod örneğini görmeden önce, range fonksiyonunu da belirtmekte fayda var. Python 2 ile çalışıyorsanız range() fonksiyonu size istediğiniz aralıktaki sayıları veren bir liste döndürecektir. Python 3 altında ise bu olay biraz daha gelişmiş, ilerletilebilir nesne olayı daha netleşmiş ve bunun sonucunda da range fonksiyonu bir generator object döndürmeye başlamıştır. Bu fonksiyonun aldığı parametreler range([başlangıç,]bitiş[,artış]) olarak sıralanabilir. Yaptığı iş ise başlangıç değerinden bitiş değerinin bir eksiğine kadar olan sayıları aradaki artış kadar verir. Dilerseniz örnek üzerinde daha detaylı olarak görebilirsiniz.

>>> range(100)
range(0, 100)
>>> range(50,100)
range(50, 100)
>>> range(50,100,10) # Kullanabileceklerimiz: 50-60-..-90
range(50, 100, 10)
>>> for değişken in range(50,100,10):
...     print(değişken)
... 
50
60
70
80
90

Bunun dışında, list comprehension, tuple comprehension gibi isimlerle görebileceğiniz kavramalar ile bir liste veya demeti tek satırda istediğiniz işlemi yaptırarak ya da istediğiniz fonksiyonu çağırarak oluşturabilirsiniz:

>>> kareListesi = [i**2 for i in range(100)]
>>> kareListesi
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801]
>>> kareDemeti = (i**2 for i in range(100))
>>> kareDemeti
<generator object <genexpr> at 0x11881e0>
>>> for i in kareDemeti:
...     print(i)
... 
0
1
4
9
16
25
36
49
64
81
100
121
144
169
... # Devamı eklenmedi.

Elimizdeki bir listeye indisleme sistemi eklemek için de enum benzeri enumerate isimli bir fonksiyonumuz var:

>>> for i,j in enumerate(["Elma","Armut","Ayva","Kiraz","Muz"]):
...     print("%d. Eleman => %s" %(i,j) )
... 
0. Eleman => Elma
1. Eleman => Armut
2. Eleman => Ayva
3. Eleman => Kiraz
4. Eleman => Muz

While Döngüsü

While döngüsü, C’de bildiğimiz while döngüsünden pek de farklı değildir. If yapısında olduğu gibi Python kod dizimine uygun hale şu şekilde getirilir:

>>> a = 0
>>> while done != True:
...     a += 1
...     print("Şu anki değer: ",a)
...     if a == 10:
...             done = True
... 
Şu anki değer:  1
Şu anki değer:  2
Şu anki değer:  3
Şu anki değer:  4
Şu anki değer:  5
Şu anki değer:  6
Şu anki değer:  7
Şu anki değer:  8
Şu anki değer:  9
Şu anki değer:  10

Yaygın olmadığı için kullanmamış olsak da, break ve continue deyimlerini de Python’da kullanabilirsiniz. Sonsuz döngüye sokmak için while True yazmanız yeterlidir. Bu arada unutmadan, True ve False ifadelerinin baş harflerinin büyük olduğunu da belirtelim.

Fonksiyonlar

Python’da fonksiyon tanımlarken, dönecek verinin türünü ve fonksiyona gelecek parametrelerin türlerini belirtmeyiz. Fonksiyon tanımlarken define sözcüğünden gelen def ifadesini kullanıyoruz.return ise aynı şekilde duruyor. Ayrıca, fonksiyon çağıran fonksiyonlar, fonksiyon içerisinde tanımlanmış fonksiyonlar gibi yapıları Python’da sıkça görmek de mümkün.

>>> import math
>>> def sinus(sayi):
...     return math.sin(math.radians(sayi))
... 
>>> sinus(45)
0.7071067811865475
>>> sinus(90)
1.0
>>> sinus(30)
0.49999999999999994

Örnekte modül içeren bir fonksiyon tanımladık. Bunu birazdan göreceğiz. C’deki sinüs fonksiyonundan farklı olmadığını, sadece başında math öneki olduğuna dikkat etmeniz şu anlık yeterli. Daha sonra bu öneki kullanmadan nasıl yapacağımıza da değineceğiz. Şimdirange fonksiyonuna benzer işlev gören bir fonksiyon hazırlayalım.

>>> def menzil(değer):
...     a = 1
...     liste = []
...     while a<değer:
...             a += 1
...             liste.append(a)
...     return liste

Şunu da belirtmeden ilerlemeyelim; Python’da pointer kavramı yok. Yukarıdaki kodta fonksiyondan bir liste döndürdük. Fonksiyonlar değer olarak liste, demet, değişken, sayı, yazı, nesne vb. aklınıza gelebilecek her türlü şeyi döndürebilirler. Dönecek değişkenin türü de Python tarafından belirlenir.

Modüller

C’deki kütüphane kavramının yerini Python’da modüller almaktadır. Aslında, bu iki kavram çoğu kez birbirinin yerine kullanılabilir. Ama genel olarak, birden fazla modülün bir arada bulunması bir kütüphaneyi oluşturur. Python’da yazdığımız her program aynı zamanda bir modüldür. Bu yüzden, profesyonel kodlarda, yazılan sınıfların, fonksiyonların ve hatta değişkenlerin başka programların içerisinde de kullanılabilmesi için şöyle bir yazım şekli kullanılır:

def calistir():
    x = int(input("Lütfen İlk Sayıyı Giriniz:" ))
    print("Sonuç bu fonksiyondan döndürülecek.")
    return(x**2+3*x+5)

if __name__ == "__main__":
    calistir() # Şu haliyle çok işlevsel olmasa da, gerçekte programın 
        # olduğu fonksiyonu çalıştıracak / sınıfı örnekleyecek yapı budur.

Pek işe yararlığı olmayan bu örnekte, program çalıştırıldığı zaman aslında __main__ isimli bir fonksiyonun çalıştığını görüyorsunuz. Bu, programınızdaki kodları satır satır işliyor. C’de .h uzantılı header dosyaları yerine, programınızı kaydettiğiniz isim.py dosyasını import isim şeklinde çağırabilirsiniz. Bunu yapmadan önce isterseniz aynı işi yapan bir de C kodu yazıp karşılaştıralım. Kod:

#include <stdio.h>
#include <math.h>

int main(void){
float sayi, sonuc;
printf("Sinüsünü hesaplamak istediğiniz sayıyı girin: ");
scanf("%f",&sayi);
sonuc = sin(sayi);
printf("Sinus degeri: %f", sonuc );

return 0;
}
Sinüsünü hesaplamak istediğiniz sayıyı girin: 10
Sinus degeri: -0.544021
guray@guray-Extensa-5630 ~/C $ ./a.out
Sinüsünü hesaplamak istediğiniz sayıyı girin: M_PI
Sinus degeri: 0.000000
guray@guray-Extensa-5630 ~/C $ ./a.out
Sinüsünü hesaplamak istediğiniz sayıyı girin: 1.57
Sinus degeri: 1.000000

Aynı işi Python ile şu şekilde yapıyoruz:

import math
sayı = float(input("Sinüsü Alınacak Sayıyı Giriniz: "))
print("Sonuç: ", math.sin(sayı))

Kodun çalışması yine aynı şekilde. Ayrıca, derece cinsinden veri girmek isterseniz de şu şekilde bir işlem mümkün:

import math
sayı = float(input("Sinüsü Alınacak Sayıyı Giriniz: "))
print("Sonuç: ", math.sin(math.radians(sayı)))

Fonksiyonu, C kodunda olduğu gibi herhangi bir ön ek olmadan kullanabilmek için from modül import fonksiyon yapısını kullanabiliriz. Bu sadece modülü değil, aynı zamanda içerisindeki sınıflar, değişkenler ve herhangi başka bir şey için de kullanılması mümkün bir import şeklidir.

>>> from math import sin,cos,radians
>>> print(math.sin(math.radians(34)))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'math' is not defined
>>> print(sin(radians(34)))
0.5591929034707469
>>> print(sin(radians(45)))
0.7071067811865475
>>> from math import * # Bu, bir modülün içerisindeki her şeyi
>>> # import etmeye yarar.

Sınıflar

Sınıf yapısı aslında C’deki yapılara biraz benziyor. Ya da, onun oldukça gelişmiş bir hali diyerek başlayalım. Sonuç olarak, yapacağımız işlemler sonrasında aralarındaki farkın ne derece büyük olduğunu göreceksiniz. Sınıf tanımlarken, direk ingilizcesi olarak class yapısını kullanıyoruz. Sınıfların içerisinde de yapılarda olduğu gibi değişkenler olabilir. Çağırırken de önce onun bir örneğini oluşturup daha sonra örnek.değişken şeklinde ya da örnek.fonksiyon şeklinde çağırıyoruz. Bir örneğini görelim:

class Sınıf():
        isim = "Güray"
        soyisim = "Yıldırım"
        numara = 1

örnek = Sınıf()
print(örnek.isim)

Sınıf içerisinde fonksiyon tanımlayacaksak yapmamız gereken fonksiyona ilk parametre olarak self yazmak. Daha ayrıca sınıfın içerisindeki değişkenlere ulaşırken self.değişken yapısını da kullanmamız mümkün. Burada self bir zorunluluk değil, ancak kuvvetli bir gelenek.

class Sf(object):
        isim = "Guray"
        soyisim = "Yildirim"
        numara = 1
        def fonk(self):
                print("Merhaba dunya", self.isim)

ornek = Sf()
print(ornek.isim)
ornek.fonk()

Rastgele Sayı Üretmek

Python’da rastgele sayı üretme işlemlerini random adlı modülle gerçekleştiriyoruz. Bu modülün en güzel özelliklerinden birisi, direk aralık vererek ya da bir listenin elemanları arasından rastgele seçim yapabilmesi. Örnek bazı kullanımları şu şekilde:

>>> import random
>>> random.randint(1,150) # 1-150 arası rastgele sayı
99
>>> random.randint(1,150) # 1-150 arası rastgele sayı
76
>>> random.randint(1,150) # 1-150 arası rastgele sayı
92
>>> liste = [423, 53, 654, 653]
>>> for i in range(5):
...     print random.choice(liste) # Listeden 5 kere rastgele seçim yapacak
... 
53
423
653
53
654
>>>

Ayrıca, rastgele sayı seçme işlemini belirli bir aralıkta yapacaksak range() fonksiyonundan bizi kurtaracak randrange() fonksiyonu bir gün ciddi derecede hız katabilir. Unutmadan, bu fonksiyon en fazla 9007199254740992 aralıkta çalışabiliyor. Parametreleri range() ile aynı:

>>> random.randrange(1,100)
70
>>> random.randrange(1,100,10) # 10'ar 10'ar giden aralıktan rastgele sayı seçelim
91
>>> random.randrange(1,100,10) # 10'ar 10'ar giden aralıktan rastgele sayı seçelim
31
>>> random.randrange(1,100,10) # 10'ar 10'ar giden aralıktan rastgele sayı seçelim
1
>>> random.randrange(1,100,10) # 10'ar 10'ar giden aralıktan rastgele sayı seçelim
1
>>> random.randrange(1,100,10) # 10'ar 10'ar giden aralıktan rastgele sayı seçelim
21

Random modülü ile elimizdeki bir liste veya demetten seçim yapacaksak, random.choice() methodunu kullanabiliriz.

#-*-coding:utf-8-*-
import random
liste = []
while True:
        giris = raw_input("Sayı giriniz, çıkmak için ç: ")
        if giris == "ç":
                break
        liste.append(int(giris))

print random.choice(liste)

Örnek çıktı şu şekildedir:

Sayı giriniz, çıkmak için ç: 2
Sayı giriniz, çıkmak için ç: 5
Sayı giriniz, çıkmak için ç: 4
Sayı giriniz, çıkmak için ç: 23
Sayı giriniz, çıkmak için ç: 543653
Sayı giriniz, çıkmak için ç: ç
2

Tür Dönüşümleri

Python’da casting, class türleri arasında dönüşümle yapılıyor. Aynı zamanda atoi, atof tarzı fonksiyonları da aynı mantıkla yapabiliyoruz. Örneğin bir integer ı float olarak yorumlatmak için:

>>> a = 3
>>> float(a)
3.0

Aynı şekilde atoi benzeri, bir string i bir tamsayıya çevirirken:

>>> sayi = "123"
>>> int(sayi)
123
>>> sayi*2
'123123'
>>> int(sayi)*2
246

Soket oluşturma

Python’da soket yapısı C ile oldukça benzer. Bir server-client yani sunucu-istemci yapısını gerçekleyecek olursak, önce portun belirleme(TCP/IP mi ve Internet/Unix portu) sonra portu açarak dinlemeye başlayarak sunucu yapısını, soketi belirleyip son aşamada dinlemek yerine sunucuya bağlanarak da istemci yapısını gerçekleştirmiş oluyoruz.

 Devam edecektir.