KODLAMA
PYTHON
KİTABI
CHATGPT
SUFLE: MERT SURUL
İçindekiler Tablosu
Giriş.....................................................................................................................................................1
Bölüm 1: Python Temelleri ........................................................................................................2
Python'un temel veri tipleri: sayılar, stringler, listeler, demetler ve sözlükler ............. 3
Değişkenlerin ve veri tiplerinin kullanımı...................................................................................... 4
Temel operatörler: aritmetik, karşılaştırma ve mantıksal operatörler ............................. 6
Karar ve döngü yapıları: if ifadeleri, for ve while döngüleri................................................... 8
Bölüm 2: Python'un Gelişmiş Özellikleri ........................................................................... 10
Fonksiyonlar: fonksiyon tanımlama, argümanlar, dönüş değerleri ve kapsam ......... 11
Modüller ve kütüphaneler: Python'un standart kütüphaneleri, modül import etme,
kendi modüllerini oluşturma ............................................................................................................ 12
Dosya işlemleri: dosya okuma ve yazma, dosya konumlandırma .................................... 14
Hata yönetimi: try-except blokları, hata türleri ve hata ayıklama ................................... 15
Bölüm 3: Nesne Tabanlı Programlama (OOP) ................................................................. 18
Nesne kavramı: sınıflar, nesneler, metodlar ve örnekler ..................................................... 18
Sınıf tanımlama ve nesne oluşturma Kalıtım ve çok biçimlilik: sınıf mirası, soyut
sınıflar ve arayüzler .............................................................................................................................. 21
Özel metodlar ve operatör aşırı yüklemesi ................................................................................ 24
Bölüm 4: Veritabanları ve Web Uygulama Geliştirme .................................................. 28
SQLite ve MySQL gibi veritabanlarına giriş: veri ekleme, güncelleme, silme ve
sorgulama .................................................................................................................................................. 28
Django gibi Python web framework'leri: projeler oluşturma, model-view-template
(MVT) mimarisi, URL yönlendirme, şablonlar ve formlar ................................................... 35
Flask gibi Python web framework'leri: temel yapılandırma, HTTP istekleri ve
yanıtları ...................................................................................................................................................... 39
RESTful web servisleri......................................................................................................................... 42
Veritabanı ve web uygulama güvenliği: SQL enjeksiyonu, XSS saldırıları ve CSRF
saldırıları.................................................................................................................................................... 44
Bölüm 5: İleri Seviye Konular ................................................................................................ 46
Python'un hızlandırılması: JIT derleyiciler, Cython ve PyPy gibi araçlar ..................... 47
İleri seviye veri yapıları: çoklu bağlantılı listeler, ağaçlar, graflar ve karma tablolar
........................................................................................................................................................................ 50
Paralel ve dağıtık hesaplama: threadler, süreçler, kuyruklar ve mesajlaşma ............. 53
Python ile veri analitiği: NumPy, pandas ve matplotlib gibi popüler veri analitiği .. 56
kütüphaneleri .......................................................................................................................................... 56
Bölüm 6: Python ile Uygulama Geliştirme ........................................................................ 61
Masaüstü Uygulamaları Geliştirme ................................................................................................ 62
Web Uygulamaları Geliştirme........................................................................................................... 68
Mobil Uygulamaları Geliştirme ........................................................................................................ 76
Giriş
Python, günümüzde en popüler programlama dillerinden biri haline gelmiştir.
İşletmeler, üniversiteler, hükümetler ve geliştiriciler arasında yaygın bir şekilde
kullanılır. Python, basit sözdizimi ve okunaklı kodu sayesinde başlangıçta
öğrenmesi kolaydır. Aynı zamanda veri bilimi, yapay zeka, makine öğrenimi, web
geliştirme ve daha birçok alanda kullanılabilir.
Bu kitap, Python programlama dilinin temellerinden başlayarak ileri düzey
konulara kadar uzanan kapsamlı bir kılavuzdur. Kitap, her seviyedeki
geliştiriciler için tasarlanmıştır ve konuların karmaşıklığı seviyesi giderek
artmaktadır. Başlangıç seviyesinden başlayarak, temel veri tipleri, döngüler,
fonksiyonlar, dosya işleme, modüller, hata ayıklama ve daha birçok konuyu
kapsar. Daha sonra, veri yapıları, nesne yönelimli programlama, veritabanları,
web geliştirme, masaüstü uygulamaları, mobil uygulamaları, makine öğrenimi ve
daha pek çok konuyu ele alır.
Her konu, açıklayıcı örneklerle ve uygulamalı egzersizlerle desteklenmektedir.
Kitap ayrıca, Python ekosistemi için önemli olan popüler kütüphaneler ve araçlar
hakkında bilgi içermektedir. Bu kütüphaneler arasında NumPy, Pandas,
Matplotlib, Flask, Django, Pygame, Keras ve TensorFlow gibi popüler araçlar
bulunmaktadır.
Bu kitap, Python programlama dilini öğrenmek isteyen herkes için mükemmel
bir kaynak olacaktır. Konuların anlaşılması kolaydır ve uygulamalı örneklerle
desteklenmektedir. Aynı zamanda, Python programlama dilinin farklı alanlarda
nasıl kullanılabileceği konusunda geniş bir bakış açısı sunmaktadır. Bu kitap,
Python dilindeki becerilerinizi geliştirmek isteyen herkes için vazgeçilmez bir
kaynak olacaktır.
Bölüm 1: Python Temelleri
Bu bölümde, Python programlama dilini öğrenmek isteyenler için temel
kavramları ele alacağız. Python, son yıllarda popülerliği artan bir programlama
dilidir ve birçok alanda kullanılır. Sadece yazılım geliştirme değil, veri bilimi,
yapay zeka, otomasyon gibi alanlarda da kullanılmaktadır.
Bu bölümde Python'un temel veri tipleri, kontrol yapıları, fonksiyonlar, nesne
yönelimli programlama ve dosya işlemleri gibi konuları ele alacağız. Bunların
yanı sıra, Python kütüphaneleri ile çalışmayı da öğreneceğiz.
Eğer daha önce programlama yapmadıysanız bile bu bölüm size uygun olacaktır.
Başlangıç seviyesinden başlayarak, konuları adım adım öğreneceğiz ve
örneklerle pekiştireceğiz.
Hazırsanız, Python dünyasına adım atalım!
Python'un temel veri tipleri: sayılar, stringler, listeler, demetler ve
sözlükler
Python, günümüzün en popüler programlama dillerinden biridir ve hem
başlangıç düzeyindeki öğrenciler hem de deneyimli yazılım geliştiricileri için
ideal bir seçimdir. Bu kitap, Python programlama dilini öğrenmek isteyen herkes
için kapsamlı bir kaynak sağlamaktadır.
Kitabın ilk bölümü, Python'un temel veri tipleri ve değişkenlerin kullanımı gibi
en temel konuları kapsar. Bu bölüm, programlama temellerini kavramak için
harika bir başlangıçtır ve Python programlama dilinin genel yapılarını anlamak
için gereklidir. Bölüm 2, daha gelişmiş konulara odaklanır ve fonksiyonlar,
modüller, dosya işlemleri ve hata yönetimi gibi konuları ele alır. Bu bölüm,
Python programlama dilindeki güçlü işlevselliği anlamak için önemlidir.
Bölüm 3, nesne tabanlı programlama (OOP) konusuna girer ve sınıf tanımlama,
kalıtım ve çok biçimlilik gibi konuları kapsar. OOP, yazılım geliştirme için çok
önemli bir tekniktir ve Python, nesne tabanlı programlamayı destekleyen bir dil
olduğu için bu bölüm, Python programlama dilindeki nesne tabanlı
programlamanın anlaşılması için idealdir.
Bölüm 4, veritabanlarına ve web uygulama geliştirme konularına yönelir ve
SQLite, MySQL, Django ve Flask gibi konuları ele alır. Bu bölüm, Python
programlama dilinin uygulama geliştirme alanındaki gücünü ortaya çıkarır ve
veritabanı işlemleri, web uygulama geliştirme ve web çerçeveleri hakkında temel
bilgileri sağlar.
Bölüm 5, Python'un ileri seviye konularına girer ve hızlandırma, veri yapıları,
paralel hesaplama ve veri analitiği konularını kapsar. Bu bölüm, daha deneyimli
Python kullanıcıları için idealdir ve Python programlama dilinin daha gelişmiş
özelliklerini keşfetmek isteyenler için faydalı bir kaynak olabilir.
Son olarak, Bölüm 6, oyun geliştirme konusuna odaklanır ve Pygame gibi
konuları ele alır. Bu bölüm, Python dilinin oyun geliştirme alanındaki
potansiyelini ortaya çıkarır ve bu alanda çalışmak isteyenler için faydalı bir
kaynak sağlar.
Bu kitap, konuları özetleyerek ve örneklerle açıklayarak, konuların anlaşılmasını
kolaylaştırır ve öğrenme sürecini hızlandırır. Ayrıca, farklı uygulama alanlarına
yönelik konuların ele alınması, kitabı farklı seviyelerdeki Python kullanıcılarına
hitap eden bir kaynak haline getirir. Kitap, hem acemi Python kullanıcıları hem
de daha deneyimli kullanıcılar için faydalı bir kaynak olacaktır.
Değişkenlerin ve veri tiplerinin kullanımı
Python'da değişkenler, bir değeri saklamak veya kullanmak için kullanılan
etiketlerdir. Değişkenlerin adları, sayılar, harfler ve alt çizgi işareti (_) gibi
karakterlerden oluşabilir. Python, değişkenleri tanımlamak için herhangi bir
anahtar kelime kullanmaz, bu nedenle adları herhangi bir kelimeyle başlayabilir.
Ancak, bazı adlar Python'da önceden tanımlanmış ve anahtar kelimelerdir ve bu
nedenle değişken adı olarak kullanılamazlar.
Python'da kullanılan temel veri tipleri şunlardır:
•
•
•
•
•
Sayılar: Tamsayılar (int), ondalık sayılar (float) ve karmaşık sayılar
(complex) gibi farklı sayı tipleri vardır. Sayılar, aritmetik işlemler yapmak
için kullanılır.
Dizeler (strings): Dizeler, karakterlerin birleştirilmesiyle oluşan
metinlerdir. Dizeler, çift tırnak ("") veya tek tırnak ('') içinde tanımlanır ve
aralarında matematiksel işlemler yapılamaz.
Listeler: Listeler, bir dizi öğeden oluşan bir veri yapısıdır. Öğeler virgülle
ayrılır ve köşeli parantezlerle ([ ]) tanımlanır. Listenin her bir öğesi, bir
indeks numarası ile erişilebilir.
Demetler (tuples): Demetler, listelere benzer ancak değiştirilemezler.
Demetler normal parantezlerle (( )) tanımlanır ve indeks numarası ile
erişilebilir.
Sözlükler (dictionaries): Sözlükler, anahtar-değer çiftleri içeren bir veri
yapısıdır. Anahtarlar, değerlerle eşleştirilir ve süslü parantezlerle ({ })
tanımlanır.
Değişkenlerin kullanımı, değer atama işlemi yaparak başlar. Değişkenlere atanan
değerler, tanımlandıkları sürece bellekte saklanır ve istenildiği zaman
kullanılabilir.
Örneğin, bir tamsayı değişkeni tanımlamak ve buna bir değer atamak için şu
kodu kullanabilirsiniz:
x=5
Bu kod, "x" adında bir değişken tanımlar ve buna "5" değerini atar. Değişkenlere
atanabilecek değerler herhangi bir veri tipinde olabilir ve değişkenler istenildiği
kadar kullanılabilir. Örneğin:
y = "Merhaba dünya!"
z = [1, 2, 3, 4, 5]
Bu örnek kod, "y" adında bir dize (string) değişkeni, "z" adında bir liste (list)
değişkeni tanımlar ve bu değişkenlere sırasıyla "Merhaba dünya!" ve [1, 2, 3, 4, 5]
şeklinde kullanabilirsiniz.
Ayrıca, Python'da veri tipleri dönüştürülebilir (type casting) olduğundan, bir veri
tipini başka bir veri tipine dönüştürmek mümkündür. Örneğin, bir string veri
tipini integer'a dönüştürmek için "int()" fonksiyonu kullanılabilir.
a = "10"
b = int(a)
print(type(b)) # <class 'int'>
Bunun yanı sıra, Python'da bazı özel veri tipleri de vardır. Bunlar, None, Boolean,
ve complex veri tipleridir. "None" veri tipi, bir değişkenin değerinin
belirtilmediği veya tanımsız olduğu durumlarda kullanılır. "Boolean" veri tipi ise
sadece "True" veya "False" değerlerini alabilen bir veri tipidir. "Complex" veri
tipi ise karmaşık sayılar için kullanılır.
a = None
b = True
c = 2 + 3j
print(type(a)) # <class 'NoneType'>
print(type(b)) # <class 'bool'>
print(type(c)) # <class 'complex'>
Python'da değişkenlerin ve veri tiplerinin kullanımı, programlama dilinin temel
yapı taşlarından biridir. Bu konuların iyi anlaşılması, daha karmaşık programlar
yazmada temel bir adımdır. Bu nedenle, Python programlama dilini öğrenirken
değişkenlerin ve veri tiplerinin kullanımı üzerinde özenle durulması önerilir.
Temel operatörler: aritmetik, karşılaştırma ve mantıksal operatörler
Python programlama dilinde, matematiksel işlemler yapmak için kullanılan
aritmetik operatörler, karşılaştırma yapmak için kullanılan karşılaştırma
operatörleri ve mantıksal ifadeleri değerlendirmek için kullanılan mantıksal
operatörler bulunur.
Aritmetik Operatörler:
•
•
•
•
•
•
•
Toplama: “+”
Çıkarma: “-”
Çarpma: “*”
Bölme: “/”
Mod Alma: “%”
Üs Alma: “**”
Bölümü Tam Sayıya Yuvarlama: “//”
Örnek kullanım:
x=5
y=3
print(x + y) # 8
print(x - y) # 2
print(x * y) # 15
print(x / y) # 1.6666666666666667
print(x % y) # 2
print(x ** y) # 125
print(x // y) # 1
Karşılaştırma Operatörleri:
•
•
•
•
•
•
Eşitlik: ==
Eşit Değil: !=
Küçük: <
Küçük veya Eşit: <=
Büyük: >
Büyük veya Eşit: >=
Örnek kullanım:
x=5
y=3
print(x == y) # False
print(x != y) # True
print(x < y) # False
print(x <= y) # False
print(x > y) # True
print(x >= y) # True
Mantıksal Operatörler:
•
•
•
Ve: and
Veya: or
Değil: not
Örnek kullanım:
x = True
y = False
print(x and y) # False
print(x or y) # True
print(not x) # False
Bu temel operatörler, Python programlama dilinde birçok farklı durumda
kullanılır ve kod yazarken sık sık karşımıza çıkar. İyi bir programcı, bu
operatörleri doğru bir şekilde kullanarak, kodunun işlevini doğru bir şekilde
yerine getirmesini sağlar.
Karar ve döngü yapıları: if ifadeleri, for ve while döngüleri
Karar ve döngü yapıları, Python programlama dilinde oldukça önemlidir ve bu
yapılar sayesinde programlarımızın farklı senaryolara uygun davranışlar
sergilemesini sağlayabiliriz. Bu bölümde, if ifadeleri, for ve while döngüleri gibi
temel karar ve döngü yapılarını inceleyeceğiz.
If İfadeleri
If ifadeleri, programın belirli koşulların sağlanıp sağlanmadığını kontrol ederek,
farklı davranışlar sergilemesini sağlar. If ifadesi, koşul sağlandığı takdirde belirli
bir kod bloğunu çalıştırır. Örneğin, bir programda belirli bir sayının çift veya tek
olduğunu kontrol edebiliriz:
sayi = 7
if sayi % 2 == 0:
print("Sayı çifttir.")
else:
print("Sayı tektir.")
Bu örnekte, sayı değişkeninin 2'ye bölümünden kalan 0 ise, sayının çift olduğunu
belirtmek için "Sayı çifttir." yazdırılır. Aksi takdirde, sayının tek olduğunu
belirtmek için "Sayı tektir." yazdırılır.
For Döngüsü
For döngüsü, belirli bir listedeki her elemanı döngüye alarak belirli işlemler
yapmamızı sağlar. Örneğin, bir liste içindeki her bir öğenin karesini almak
istediğimizi varsayalım:
liste = [2, 4, 6, 8, 10]
for eleman in liste:
kare = eleman ** 2
print(kare)
Bu örnekte, "liste" adlı bir liste tanımlanır ve her elemanın karesi "for" döngüsü
içinde hesaplanarak ekrana yazdırılır.
While Döngüsü
While döngüsü, belirli bir koşul sağlandığı sürece bir kod bloğunu tekrar tekrar
çalıştırmamızı sağlar. Örneğin, bir sayının faktöriyelini hesaplamak istediğimizi
varsayalım:
sayi = 5
faktoriyel = 1
i=1
while i <= sayi:
faktoriyel *= i
i += 1
print("Faktöriyel:", faktoriyel)
Bu örnekte, "sayi" adlı bir sayı tanımlanır ve "faktoriyel" değişkeni 1'e eşitlenir.
Ardından, "i" değişkeni 1'e eşitlenir ve "while" döngüsü içinde "i" sayısı "sayi"
sayısına eşit olana kadar "faktoriyel" değişkeni "i" sayısı ile çarpılır ve "i" sayısı 1
arttırılır. Sonuç olarak, "faktori
Bir diğer kontrol yapısı ise "while" döngüsüdür. Bu döngü, belirtilen bir koşul
doğru olduğu sürece tekrar eder. Koşul yanlış olduğunda döngü sona erer.
Aşağıdaki örnekte, kullanıcının girdiği sayıların toplamı hesaplanırken "while"
döngüsü kullanılmıştır:
toplam = 0
sayi = 0
while sayi >= 0:
sayi = int(input("Bir sayı girin: "))
if sayi >= 0:
toplam += sayi
print("Girilen sayıların toplamı:", toplam)
Bu örnekte, kullanıcı 0'dan büyük sayılar girdiği sürece döngü devam eder ve
girilen sayıların toplamı hesaplanır. Kullanıcı negatif bir sayı girdiğinde döngü
sona erer ve toplam değeri ekrana yazdırılır.
Bu bölümde "if" ifadeleri, "for" ve "while" döngüleri gibi karar ve döngü yapıları
ele alındı. Bu yapılar, programların belirli koşullara göre farklı işlemler
yapmasına ve tekrarlayan işlemleri kolayca gerçekleştirmesine olanak tanır.
Bölüm 2: Python'un Gelişmiş Özellikleri
Python, programcılara gelişmiş özellikler sunan bir programlama dilidir. Bu
özellikler sayesinde Python, sadece basit programlar değil, aynı zamanda daha
karmaşık programlar da yazmak için kullanılabilir. Bölüm 2, Python
programlama dilinin gelişmiş özelliklerini ele alır ve programcıların bu
özellikleri nasıl kullanacaklarını öğrenmelerine yardımcı olur.
Bu bölüm, Python programlama dilinde kullanılan farklı veri yapılarından ve
bunların nasıl kullanılacağından bahseder. Ayrıca, operatörlerin, karar ve döngü
yapılarının, fonksiyonların ve modüllerin kullanımı da bu bölümde ele alınır.
Hata yönetimi de bu bölümün önemli bir parçasıdır ve programcıların hataları
nasıl yakalayacaklarını ve yöneteceklerini öğrenmelerine yardımcı olur.
Bu bölüm ayrıca nesne tabanlı programlamaya (OOP) da değinir. OOP,
programcıların programlarını daha modüler hale getirmelerine, kod tekrarını
önlemelerine ve programları daha okunaklı hale getirmelerine yardımcı olan bir
programlama paradigmasıdır. Bu bölüm, programcıların OOP kavramlarını
anlamalarına ve uygulamalarına yardımcı olur.
Fonksiyonlar: fonksiyon tanımlama, argümanlar, dönüş değerleri ve
kapsam
Python'da fonksiyonlar, tekrar tekrar kullanılan kod bloklarını bir araya
getirerek programcılara zaman ve emek kazandıran bir özelliktir. Bir fonksiyon,
belirli bir görevi yerine getiren bir kod bloğudur ve başka bir kod bloğu içinde
çağrılabilir. Bu sayede, aynı işlemleri birkaç kez tekrarlamak yerine, kod bloğunu
bir fonksiyon içinde tanımlayarak, fonksiyonu çağırdığımız her yerde bu
işlemleri gerçekleştirebiliriz.
Fonksiyonlar, Python'da şu şekilde tanımlanır:
def fonksiyon_adı(argümanlar):
fonksiyon gövdesi
return dönüş_değeri
Burada “def” anahtar kelimesi, bir fonksiyon tanımlamak için kullanılır.
“fonksiyon_adı”, tanımladığımız fonksiyonun ismidir. “argümanlar”, fonksiyonun
çalışması için gerekli olan değişkenlerdir ve isteğe bağlıdır. “fonksiyon gövdesi”,
fonksiyonun gerçekleştireceği işlemlerin yazıldığı koddur. “Return" anahtar
kelimesi, fonksiyondan döndürülecek olan değeri belirtir ve isteğe bağlıdır.
Örneğin, aşağıdaki kod bloğu, iki sayının toplamını hesaplayan bir fonksiyon
tanımlar:
def toplama(sayı1, sayı2):
toplam = sayı1 + sayı2
return toplam
Bu fonksiyonu çağırmak için, “fonksiyon_adı(argümanlar)” formatını
kullanabiliriz. Örneğin:
sonuç = toplama(5, 7)
print(sonuç)
Bu kod, “toplama” fonksiyonunu çağırarak 5 ve 7 sayılarının toplamını hesaplar
ve sonucu ekrana yazdırır.
Fonksiyonların bir diğer önemli özelliği, kapsam (scope) konseptidir. Kapsam,
bir değişkenin ne kadar görünür olduğunu ve hangi kod bloklarında
kullanılabileceğini belirler. Python'da, fonksiyonlar kapsamları belirler. Yani,
fonksiyonlar içinde tanımlanan değişkenler, fonksiyon dışında kullanılamazlar.
Bu, değişkenlerin farklı yerlerde farklı değerler almasını önler ve programcıların
karışıklık yaşamasını engeller.
Fonksiyonlar aynı zamanda, kodun daha modüler hale getirilmesine de yardımcı
olur. Büyük projelerde, kodu daha modüler hale getirmek, daha yönetilebilir bir
kod tabanı oluşturmak için önemlidir. Fonksiyonlar, kodu daha küçük parçalara
ayırarak, her parçanın daha kolay yönetilmesini ve geliştirilmesini sağlar.
Sonuç olarak, fonksiyonlar programlamada önemli bir yapı taşıdır ve Python'da
da oldukça kullanışlıdır. Fonksiyonlar, kodun daha okunaklı, yönetilebilir ve
daha az yazılmasını sağlar. Ayrıca, kapsam konsepti sayesinde, değişkenlerin
farklı yerlerde farklı değerler almasını engelleyerek, programcıların karışıklık
yaşamasını önler.
Modüller ve kütüphaneler: Python'un standart kütüphaneleri, modül
import etme, kendi modüllerini oluşturma
Python, çok sayıda önceden yazılmış modül ve kütüphaneyle birlikte gelir. Bu
modüller, çeşitli işlevler için kullanılabilen önceden yazılmış kod bloklarıdır.
Örneğin, “math” modülü matematiksel işlemler için kullanılırken, “random”
modülü rastgele sayı üretmek için kullanılır.
Python'da, modül ve kütüphaneler “import” anahtar kelimesi kullanılarak
yüklenir. Bu, başka bir modülde tanımlanmış işlevleri veya değişkenleri
kullanmanızı sağlar. Aşağıdaki örnekte, “math” modülü içindeki “sqrt” işlevini
kullanarak bir sayının karekökünü alıyoruz:
import math
x = 25
y = math.sqrt(x)
print(y) # output: 5.0
Bir modülün tamamını yüklemek yerine, sadece belirli bir işlevi veya değişkeni
yükleyebilirsiniz. Bunu yapmak için, “from” anahtar kelimesini kullanın.
Aşağıdaki örnekte, “math” modülündeki sadece “sqrt” işlevini yüklüyoruz:
from math import sqrt
x = 25
y = sqrt(x)
print(y) # output: 5.0
Ayrıca, kendi modüllerinizi de oluşturabilirsiniz. Bunun için, kodunuzu bir .py
dosyasına kaydedin ve başka bir Python programında import anahtar kelimesini
kullanarak yükleyin. Örneğin; “my_module.py” adında bir dosyada aşağıdaki
kodu yazabilirsiniz:
def say_hello():
print("Hello from my module!")
Daha sonra, başka bir Python programında bu modülü yükleyebilirsiniz:
import my_module
my_module.say_hello() # output: "Hello from my module!"
Bu, kodunuzu modüler hale getirerek daha okunaklı ve yönetilebilir hale
getirmenize olanak tanır.
Dosya işlemleri: dosya okuma ve yazma, dosya konumlandırma
Python'da dosya işlemleri oldukça kolaydır ve işletim sistemiyle bağımsızdır.
Dosya işlemleri, verileri kalıcı olarak saklamak ve programlar arasında veri
paylaşmak için kullanılır.
Python'da dosya işlemleri yapmak için open() fonksiyonu kullanılır. Bu
fonksiyon, dosyayı açmak ve dosya üzerinde işlem yapmak için kullanılır. open()
fonksiyonu, iki parametre alır: dosya adı ve dosya modu.
Dosya modları şunlardır:
•
•
•
•
•
•
"r": dosyayı okumak için açar (varsayılan mod)
"w": dosyayı yazmak için açar, dosya yoksa oluşturur, varsa üzerine yazar
"a": dosyayı yazmak için açar, dosya yoksa oluşturur, varsa dosyanın
sonuna ekleme yapar
"x": dosyayı yazmak için açar, dosya yoksa oluşturur, varsa hata verir
"b": dosya işlemlerinin ikili (binary) modda yapılmasını sağlar
Dosya açıldıktan sonra, “read()” metodu dosyadaki tüm verileri okur ve bir
string olarak döndürür. “readline()” metodu ise dosyadaki verileri satır satır
okur.
Dosya yazmak için ise “write()” metodu kullanılır. Bu metot, dosyaya bir string
yazar ve geriye yazılan karakter sayısını döndürür.
Dosya işlemleri yaparken, dosyanın konumunu (yani okunacak veya yazılacak
verinin nereden başlayacağı) belirlemek önemlidir. Bunun için, dosya
konumlandırma işlemi yapılabilir. “seek()” metodu, dosya konumlandırıcısını
belirli bir pozisyona taşır ve bu pozisyondan itibaren dosya işlemine devam
edilir.
Örneğin, aşağıdaki kod, "ornek.txt" adlı dosyayı okur ve dosyanın her bir satırını
ekrana yazdırır:
with open("ornek.txt", "r") as f:
for line in f:
print(line)
Aşağıdaki örnek ise, "ornek.txt" adlı dosyaya "Hello, World!" yazarak dosyayı
kapatır:
with open("ornek.txt", "w") as f:
f.write("Hello, World!")
Bu örneklerde, “with” bloğu kullanılmıştır. “with” bloğu, dosya işlemleri
bittiğinde dosyanın otomatik olarak kapatılmasını sağlar ve bu nedenle bellek
sızıntısı olasılığını en aza indirir.
Hata yönetimi: try-except blokları, hata türleri ve hata ayıklama
Hata yönetimi, yazılım geliştirme sürecinde önemli bir konudur. Hata yönetimi,
bir programda meydana gelebilecek hataların tespit edilmesi ve ele alınması ile
ilgilidir. Python'da, hata yönetimi try-except blokları kullanılarak sağlanır.
try-except blokları, kod bloklarında meydana gelebilecek hataların tespit
edilmesi ve ele alınması için kullanılır. try bloğu içindeki kodlar çalıştırılır ve
eğer herhangi bir hata meydana gelirse, kodun çalışması try bloğundan çıkar ve
except bloğuna geçer. except bloğunda, hata türüne göre farklı işlemler
yapılabilir.
Örneğin, aşağıdaki kod parçası, kullanıcıdan alınan iki sayının toplamını
hesaplar. Ancak, kullanıcı yanlışlıkla sayı yerine bir metin girerse, ValueError
hatası meydana gelir ve program çöker. Bu durumda, try-except blokları
kullanarak hatanın ele alınması ve kullanıcıya uygun bir hata mesajı gösterilmesi
gerekir.
try:
sayi1 = int(input("Bir sayı girin: "))
sayi2 = int(input("Başka bir sayı girin: "))
toplam = sayi1 + sayi2
print("Sayıların toplamı:", toplam)
except ValueError:
print("Lütfen sadece sayı girin!")
Bu örnekte, kullanıcı yanlışlıkla sayı yerine bir metin girdiği zaman, ValueError
hatası oluşur. except bloğunda bu hatanın ele alınması için, "Lütfen sadece sayı
girin!" şeklinde bir hata mesajı gösterilir.
Hata yönetiminde, hataların türüne göre farklı except blokları da kullanılabilir.
Örneğin, ZeroDivisionError hatası, bir sayının sıfıra bölünmesi durumunda
meydana gelir. Bu hatayı ele almak için, şu şekilde bir kod yazılabilir:
try:
sayi1 = int(input("Bir sayı girin: "))
sayi2 = int(input("Başka bir sayı girin: "))
bolum = sayi1 / sayi2
print("Bölüm:", bolum)
except ValueError:
print("Lütfen sadece sayı girin!")
except ZeroDivisionError:
print("Bir sayı sıfıra bölünemez!")
Bu örnekte, kullanıcının sadece sayı girdiğinden emin olmak için ValueError
hatası ele alınırken, ZeroDivisionError hatası da sıfıra bölme durumunda ele
alınmıştır.
Ayrıca, hata ayıklama (debugging) da hata yönetiminin önemli bir parçasıdır.
Hata ayıklama, programın çalışma sürecinde oluşabilecek hataların tespiti ve
düzeltilmesidir. Python, hata ayıklama işlemleri için çeşitli araçlar sunar.
Bir programda hata ayıklama yapmak için, öncelikle hangi hatanın oluştuğunu
tespit etmek gerekir. Hata mesajları, programcılara hatanın türünü ve hangi kod
satırında oluştuğunu gösterir. Bu nedenle, hata mesajlarını dikkatlice okumak
önemlidir.
Python'da, hata ayıklama için pdb (Python Debugger) modülü kullanılır. Bu
modül, programın çalışma sürecinde, belirlenen bir noktada çalışmayı
durdurarak, programcılara hata ayıklama işlemi yapma imkanı sağlar.
pdb modülünü kullanmak için, kodun belirli bir noktasında, hata ayıklama
modunu aktif hale getirmek gerekiyor. Bunun için import pdb komutu kullanılır
ve hata ayıklama modu, pdb.set_trace() komutu ile başlatılır. Bu komut,
programın belirli bir noktasında, hata ayıklama modunu aktif hale getirir ve
programı duraklatır. Program, bu noktada durduğu için, programcı, değişken
değerlerini inceleyebilir, hata ayıklama işlemlerini yapabilir veya kodu adım
adım (step-by-step) çalıştırabilir.
Örneğin, aşağıdaki kodda, hata ayıklama modu kullanılarak pdb modülü ile hata
ayıklama işlemi yapılabilir:
import pdb
def divide(a, b):
try:
return a / b
except ZeroDivisionError:
pdb.set_trace()
return None
result = divide(5, 0)
print(result)
Bu kod, divide() fonksiyonu ile 5'i 0'a bölmeye çalışır. Bu işlem geçersizdir ve bir
hata mesajı oluşur. Ancak, pdb.set_trace() komutu sayesinde, program bu
noktada durur ve hata ayıklama moduna geçer. Programcı, a ve b değişkenlerinin
değerlerini inceleyebilir ve kodu adım adım çalıştırarak hangi satırda hata
olduğunu bulabilir.
Hata ayıklama işlemleri, programcıların kodları daha iyi anlamalarını ve hataları
daha hızlı bulup düzeltmelerini sağlar. Bu nedenle, hata ayıklama, programlama
sürecinde önemli bir adımdır.
Bölüm 3: Nesne Tabanlı Programlama (OOP)
Nesne tabanlı programlama (OOP), günümüzde en yaygın kullanılan
programlama paradigmalardan biridir. Bu paradigma, programlama
problemlerini nesneler ve sınıflar şeklinde ele alır ve bu nesnelerin birbirleriyle
olan ilişkileri ve etkileşimleri üzerine odaklanır. OOP, programlama kodlarını
daha modüler ve yönetilebilir hale getirir ve bu sayede büyük ölçekli projelerin
geliştirilmesini kolaylaştırır.
Bu bölümde, Python'da nesne tabanlı programlamanın temellerini
öğreneceksiniz. Sınıf tanımlama, miras alma, çok biçimlilik gibi konulara
değinecek ve örneklerle destekleyeceğiz. Ayrıca, Python'un OOP özellikleri
hakkında detaylı bir inceleme yaparak, bu paradigmaya olan hakimiyetinizi
artırmayı hedefliyoruz.
Nesne kavramı: sınıflar, nesneler, metodlar ve örnekler
Nesne yönelimli programlama (OOP), bir programlama paradigmalarından biridir. OOP,
nesneleri programlama dünyasında merkezi bir konuma getirir ve bu nesneler
aracılığıyla programlama yapar. Python, nesne yönelimli bir programlama dili olarak
tasarlanmıştır. Bu bölümde, Python'da nesne kavramı, sınıflar, nesneler, metodlar ve
örnekler hakkında daha ayrıntılı bilgi verilecektir.
Sınıflar
Python'da, bir sınıf, nesnelerin taslağıdır. Sınıflar, nesnelerin özelliklerini ve
davranışlarını tanımlarlar. Sınıflar, birçok nesneyi oluşturmak için kullanılabilen bir
kalıptır. Bir sınıfı tanımlamak için, class anahtar kelimesi kullanılır. Aşağıdaki örnek,
basit bir Person sınıfını göstermektedir:
class Person:
pass
Bu sınıf, sadece pass ifadesi içerir. Bu ifade, bir bloğu geçersiz kılmak için kullanılır. Yani,
Person sınıfı hiçbir özellik veya davranış içermemektedir.
Nesneler
Bir sınıf, nesnelerin taslağıdır. Yani, bir sınıftan bir nesne oluşturmak, o sınıfın bir örneği
(instance) oluşturmak demektir. Nesneler, bir sınıfın özelliklerine ve davranışlarına
sahip olan öğelerdir. Python'da, bir nesne oluşturmak için sınıfın adını kullanarak bir
nesne oluşturucu (constructor) çağrılır. Aşağıdaki örnek, Person sınıfından bir nesne
oluşturur:
class Person:
pass
p = Person()
Bu örnekte, Person sınıfından bir nesne olan p oluşturulur.
Metodlar
Bir sınıfın davranışları, metodlar tarafından tanımlanır. Metodlar, bir sınıftaki
işlevlerdir. Bir metodun tanımlanması, bir işlevin tanımlanmasına benzer. Ancak,
metodlar sınıfın özelliklerine ve diğer metodlarına erişebilirler. Bir metodun ilk
argümanı her zaman self olmalıdır. Bu argüman, metodun hangi nesneye bağlı olduğunu
belirtir. Aşağıdaki örnek, Person sınıfına say_hello adlı bir metod ekler:
class Person:
def say_hello(self):
print("Hello, World!")
p = Person()
p.say_hello()
Bu örnekte, Person sınıfına say_hello adlı bir metod eklenir. Bu metod, sınıfın bir özelliği
olarak tanımlanır ve sınıfın tüm örnekleri tarafından kullanılabilir hale gelir.
class Person:
def _init_(self, name, age):
self.name = name
self.age = age
def say_hello(self):
print(f"Hello, my name is {self.name} and I am {self.age} years old.")
Yukarıdaki kodda, Person sınıfına say_hello adlı bir metod eklenir. Bu metod, self
parametresi ile başlar ve sınıfın diğer özelliklerine (name ve age) erişebilir. Bu metod,
"Hello, my name is ..." şeklinde bir çıktı verir ve sınıfın herhangi bir örneği tarafından
çağrılabilir.
Aşağıdaki örnek, Person sınıfının bir örneğini oluşturur ve say_hello metodunu çağırır:
person1 = Person("John", 25)
person1.say_hello()
Bu kod, "Hello, my name is John and I am 25 years old." şeklinde bir çıktı üretir.
Sınıf örneklerine erişim, nokta (.) notasyonu kullanılarak yapılır. Örneğin, person1
nesnesinin yaşını almak için şu kod kullanılabilir:
age = person1.age
Benzer şekilde, sınıf özelliklerine de nokta (.) notasyonu kullanılarak erişilebilir.
Örneğin, Person sınıfına yeni bir özellik (örneğin city) eklemek için şu kod kullanılabilir:
class Person:
def _init_(self, name, age, city):
self.name = name
self.age = age
self.city = city
def say_hello(self):
print(f"Hello, my name is {self.name} and I am {self.age} years old.")
Yukarıdaki kod, Person sınıfına city adlı bir özellik ekler. Bu özellik, sınıfın diğer
özellikleri gibi self parametresi ile başlar ve sınıfın diğer özellikleri ile birlikte
kullanılabilir hale gelir.
Nesne tabanlı programlama, programların daha organize ve modüler olmasını sağlar.
Sınıflar, nesneler ve metodlar gibi nesne tabanlı programlama özellikleri, programcılara
kodlarını daha düzenli ve okunabilir hale getirme imkanı sunar.
Sınıf tanımlama ve nesne oluşturma Kalıtım ve çok biçimlilik: sınıf mirası,
soyut sınıflar ve arayüzler
Sınıflar, Python'da nesne tabanlı programlamanın temel yapı taşlarından biridir.
Sınıflar, nesnelerin özelliklerini ve metodlarını tanımlamak için kullanılır. Bir
sınıfın özellikleri, o sınıfın nesnelerine özgü niteliklerdir ve metodları, o nesneler
üzerinde yapılabilecek işlemlerdir. Python'da, sınıfların tanımlanması için class
anahtar kelimesi kullanılır.
Sınıfların oluşturulması, öncelikle bir sınıf adının belirlenmesiyle başlar.
Ardından, sınıfın nitelikleri (özellikleri) ve metodları tanımlanır. Sınıf nitelikleri,
sınıfın tüm nesnelerine özgüdür ve özellik değerleri, nesne oluşturulduğunda
atanır. Sınıf metodları, sınıfın nesneleri üzerinde çalıştırılabilecek işlemleri içerir.
class Person:
# sınıf nitelikleri
species = "human"
# _init_ metodu: nesne özelliklerini tanımlamak için kullanılır
def _init_(self, name, age):
self.name = name
self.age = age
# sınıf metodu
def say_hello(self):
print(f"Hello, my name is {self.name}. I am {self.age} years old.")
Yukarıdaki örnekte, Person adlı bir sınıf tanımlanmıştır. Bu sınıf, species adlı bir
nitelik ve _init_ adlı bir metoda sahiptir. _init_ metodu, sınıfın nesnelerine özgü
nitelikleri (name ve age) tanımlamak için kullanılır. say_hello adlı bir metot da
sınıfın özelliklerini kullanarak bir metin çıktısı oluşturur.
Sınıf oluşturduktan sonra, sınıfın nesneleri oluşturulabilir. Sınıfın nesneleri, sınıf
adının bir fonksiyon gibi çağrılmasıyla oluşturulur. Örneğin, yukarıda tanımlanan
Person sınıfı için bir örnek oluşturmak için şu şekilde yapılabilir:
person1 = Person("Alice", 25)
Bu kod, Person sınıfından bir nesne oluşturur ve person1 adlı bir değişkene atar.
_init_ metodu, nesne özelliklerini tanımlamak için kullanılır ve burada name ve
age nitelikleri Alice ve 25 değerleriyle atanır.
Sınıf mirası, OOP'nin temel kavramlarından biridir ve bir sınıfın diğer sınıflardan
özelliklerini miras alabilmesini sağlar. Bir sınıfın diğer bir sınıftan özelliklerini
alabilmesi için, miras alınacak sınıfın üst sınıf (parent class) olarak belirtilmesi
gerekir. Miras alan sınıf ise alt sınıf (child class) olarak adlandırılır.
Sınıf mirası, kodun yeniden kullanımını artırır ve kodun daha okunaklı hale
gelmesini sağlar. Üst sınıf, alt sınıflar tarafından ortak olarak kullanılan
özellikleri ve metodları içerebilir. Alt sınıflar, üst sınıftan miras aldıkları
özellikleri ve metodları kullanarak kendi özelliklerini ve metodlarını
tanımlayabilirler.
Bir sınıfın miras alabileceği özellikler ikiye ayrılır: nitelikler (attributes) ve
metodlar (methods). Nitelikler, sınıfın özelliklerini tanımlayan değişkenlerdir.
Metodlar ise sınıfın davranışlarını tanımlayan fonksiyonlardır.
Bir sınıfın miras aldığı üst sınıfın nitelikleri ve metodları, alt sınıfın nesneleri
tarafından kullanılabilir. Eğer alt sınıf, üst sınıfta tanımlanmış bir niteliği veya
metodu aynı isimle tanımlarsa, alt sınıfın bu niteliği veya metodunu kullanılır.
Örnek olarak, bir hayvan sınıfı oluşturabiliriz. Bu sınıfın nitelikleri tür, yaşam
alanı ve beslenme şekli olabilir. Hayvan sınıfına beslenme metodu da eklenebilir.
Bu metot, hayvanların nasıl beslendiğini tanımlayabilir. Sonrasında, bu hayvan
sınıfından türeyen bir kedi sınıfı oluşturabiliriz. Kedi sınıfı, hayvan sınıfından
miras aldığı özelliklerin yanı sıra kendine özgü niteliklere (örneğin tüy rengi)
sahip olabilir. Kedi sınıfına, hayvan sınıfından miras alınan beslenme metodu
kullanılabilir veya bu metot kedi sınıfına özgü bir şekilde tanımlanabilir.
Sınıf mirası aynı zamanda çok biçimlilik (polymorphism) kavramını da içerir.
Çok biçimlilik, aynı isimdeki metotların farklı alt sınıflar tarafından farklı
şekillerde uygulanabilmesini ifade eder. Bu, programcılara daha esnek bir kod
yazma olanağı sağlar.
Sınıf mirası için Python'da kullanılan syntax şu şekildedir:
class ParentClass:
# ParentClass nitelikleri ve metodları
pass
class ChildClass(ParentClass):
# ChildClass nitelikleri ve metodları
pass
Burada ParentClass, miras veren (base) sınıf olarak adlandırılırken, ChildClass
ise miras alan (derived) sınıf olarak adlandırılır. ChildClass sınıfı, ParentClass
sınıfının niteliklerini ve metodlarını miras alacaktır.
Örnek bir sınıf mirası yapalım:
class Animal:
def _init_(self, name, age):
self.name = name
self.age = age
def eat(self, food):
print(f"{self.name} is eating {food}")
class Dog(Animal):
def _init_(self, name, age, breed):
super()._init_(name, age)
self.breed = breed
def bark(self):
print("Woof! Woof!")
Bu örnekte Animal adında bir sınıf tanımladık ve Dog adında bir sınıf oluşturduk.
Dog, Animal sınıfından miras aldığı için Animal sınıfının nitelikleri ve metodları
Dog sınıfına da geçerlidir. Dog sınıfı ayrıca bark adında bir metod da içerir.
Dog sınıfının örneğini oluşturalım:
my_dog = Dog("Rex", 3, "German Shepherd")
print(my_dog.name) # Rex
print(my_dog.age) # 3
my_dog.eat("meat") # Rex is eating meat
my_dog.bark() # Woof! Woof!
Burada my_dog adında bir Dog sınıfı örneği oluşturduk. my_dog örneği, Dog
sınıfının niteliklerini ve metodlarını içerir ve ayrıca Animal sınıfının niteliklerini
ve metodlarını da miras almıştır. Bu nedenle my_dog örneği name, age, eat ve
bark metodlarını içerir.
Sınıf mirası, nesne tabanlı programlamada kod tekrarını önler ve kodun daha
okunaklı ve yeniden kullanılabilir olmasını sağlar. Ayrıca, bir sınıfın birçok farklı
alt sınıfı olabileceği için, bu yöntem kodun ölçeklenebilirliğini artırır.
Özel metodlar ve operatör aşırı yüklemesi
Python'da, nesnelerin davranışları ve işlemleri özel metodlar (special methods)
aracılığıyla tanımlanır. Bu metodlar, nesnelerin Python'da yer alan özel
operatörlerle (örneğin +, -, *, /, == vb.) çalışmasını sağlar. Bu işleme operatör
aşırı yüklemesi (operator overloading) denir.
Örneğin, iki nesneyi toplamak için "+" operatörü kullanılabilir. Ancak, bu
operatörün iki farklı sınıftaki nesneler için farklı davranması gerekebilir. Bu
durumda, her sınıfın kendine özel "+" metodunu tanımlaması gerekir. Özel
metodların isimleri, "__" (iki alt çizgi) ile başlayıp biten özel bir isimle tanımlanır.
Ayrıca, nesnelerin özelliklerine ve metodlarına erişmek için kullanılan bazı özel
metodlar da vardır. Bunlar, "init" (nesne oluşturma), "str" (nesneyi metin olarak
temsil etme), "len" (nesnenin uzunluğu) gibi metodlardır.
Özel metodların kullanımı, nesne tabanlı programlamada çok önemlidir. Bu
metodlar sayesinde, Python'daki yerleşik veri tipleri gibi kendi özel veri
tiplerimizi ve işlevlerimizi oluşturabiliriz.
İşte bir örnek:
class Rectangle:
def _init_(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def _add_(self, other):
return Rectangle(self.width + other.width, self.height + other.height)
def _str_(self):
return f"Rectangle ({self.width}, {self.height})"
def _eq_(self, other):
return self.width == other.width and self.height == other.height
r1 = Rectangle(2, 3)
r2 = Rectangle(4, 5)
print(r1 + r2) # outputs: Rectangle (6, 8)
print(r1 == r2) # outputs: False
Bu örnekte, "Rectangle" adlı bir sınıf tanımlanmıştır. Sınıfın iki özelliği vardır:
"width" ve "height". Ayrıca, "area" adlı bir metod tanımlanmıştır. Bu metod,
dikdörtgenin alanını hesaplar ve döndürür.
Daha sonra, "+" metodunu aşırı yüklemek için "add" adlı bir özel metod
tanımlanmıştır. Bu metod, iki dikdörtgeni toplar ve yeni bir dikdörtgen
döndürür.
Yukarıdaki örnekte, "Dikdortgen" sınıfı "str" ve "eq" adlı özel metodları aşırı
yüklemektedir. "str" metodu, bir nesnenin metin temsilini döndürür. "eq"
metodu, iki nesnenin eşit olup olmadığını kontrol eder.
"Dikdortgen" sınıfından türetilen "Kare" sınıfı, "Dikdortgen" sınıfının özelliklerini
miras alır ve "Dikdortgen" sınıfında tanımlanmış olan "str" ve "eq" metotlarını
kullanabilir.
Aşağıdaki örnekte, "Kare" sınıfı, "Dikdortgen" sınıfından türetilmiştir ve
"Dikdortgen" sınıfında tanımlanmış olan "str" ve "eq" metotlarını kullanır:
class Kare(Dikdortgen):
def _init_(self, kenar):
super()._init_(kenar, kenar)
Yukarıdaki kodda, "Kare" sınıfı, "Dikdortgen" sınıfından türetilmiştir. "Kare"
sınıfının yapıcı metodunda, "Dikdortgen" sınıfının yapıcı metoduna "kenar"
parametresi iki kez geçilerek çağrılmıştır. Böylece, "Kare" nesnesi, iki kenarı da
aynı uzunlukta olan bir dikdörtgene benzer.
Bu örnekte, "Kare" sınıfı, "Dikdortgen" sınıfından özellikleri miras alır ve
"Dikdortgen" sınıfındaki "str" ve "eq" metotlarını kullanabilir. Ayrıca, "Kare"
sınıfı, kendi özel metodlarını da tanımlayabilir. Örneğin, "alan" adlı bir metot
tanımlanabilir:
class Kare(Dikdortgen):
def _init_(self, kenar):
super()._init_(kenar, kenar)
def alan(self):
return self.kenar1 * self.kenar2
Yukarıdaki kodda, "alan" adlı bir metot tanımlanmıştır. Bu metot, karenin alanını
hesaplar ve döndürür. Bu metot, "Dikdortgen" sınıfında tanımlanmamıştır ve
"Kare" sınıfına özgüdür.
Herhangi bir nesne için özel metodlar tanımlayabiliriz. Bazı yaygın kullanılan özel
metodlar şunlardır:
•
•
•
•
•
•
_init_(): Bir sınıf örneği oluşturulduğunda otomatik olarak çağrılır ve
örneği başlatmak için kullanılır.
_str_(): Bir nesnenin metin temsili için kullanılır. print() fonksiyonu gibi
bazı fonksiyonlar tarafından çağrılır.
_repr_(): Bir nesnenin tanımlayıcı bir temsilini döndürür.
_len_(): Bir nesnenin uzunluğunu döndürür.
_eq_(): İki nesne arasındaki eşitliği karşılaştırır.
_lt(), __gt(), __le(), __ge_(): Karşılaştırma operatörlerini aşırı yüklemek için
kullanılır.
•
Özel metodların kullanımı, nesne yönelimli programlama için önemlidir. Bu
yöntemler, nesnelerin uygun şekilde kullanılmasını sağlamak için çağrılır ve
nesnelerin davranışını belirler.
Özel metodlar ve operatör aşırı yüklemesi, Python'da nesne yönelimli
programlamanın temel özelliklerinden biridir. Bu özellik sayesinde, Python
programcıları, Python dilinde önceden tanımlanmış operatörlerin üzerine
yazılmış özel metodları kullanarak kendi veri türlerini tanımlayabilirler. Bu
sayede, Python'un dil özelliklerini ve operatörlerini kullanarak, kendi veri türleri
üzerinde işlemler yapabilirler.
Özel metodlar, bir sınıfın özelliklerini kontrol etmek ve işlemler yapmak için
kullanılır. Örneğin, "init" metodunu kullanarak, bir sınıfın özelliklerini
başlatılabilir. "str" metodunu kullanarak, bir nesneyi bir metin olarak temsil
edebiliriz. "eq" metodunu kullanarak, iki nesnenin eşitliğini kontrol edebiliriz.
Operatör aşırı yüklemesi, bir sınıfın özelliklerini standart Python operatörleriyle
kontrol etmek için kullanılır. Örneğin, "+" operatörü, sayıları toplarken kullanılır,
ancak bir sınıfın özel bir kullanımı için de aşırı yüklenebilir. Bu sayede, sınıfın
özelliklerini kullanarak toplama işlemi yapabiliriz.
Özel metodlar ve operatör aşırı yüklemesi, Python dilinde çok güçlü bir özelliktir.
Bu sayede, Python programcıları kendi veri türlerini tanımlayarak, Python
dilinin tüm özelliklerini kullanabilirler. Bu da, Python'un gücünü ve esnekliğini
artırır ve Python programcılarının daha verimli ve etkili kod yazmalarını sağlar.
Bölüm 4: Veritabanları ve Web Uygulama Geliştirme
Python, veritabanlarına erişim ve web uygulama geliştirme konularında oldukça
güçlü bir araçtır. Veritabanları, büyük miktarda veri depolamanın yanı sıra, bu
verilere erişmek, güncellemek ve işlemek için birçok farklı yöntem sunar. Web
uygulama geliştirme ise günümüzde oldukça yaygın bir ihtiyaç haline gelmiştir
ve Python, Django, Flask ve Pyramid gibi birçok popüler web framework'üne
sahiptir.
Bu bölümde, Python ile veritabanlarına erişim ve web uygulama geliştirme
konularını ele alacağız. Veritabanlarına erişim konusunda, Python'un sqlite3,
MySQL, PostgreSQL gibi farklı veritabanı sürücüleri ve ORM (Object-Relational
Mapping) araçlarından bahsedeceğiz. Web uygulama geliştirme konusunda ise,
Django, Flask ve Pyramid gibi popüler web framework'lerine bir giriş yapacağız
ve temel yapılandırmaları, view'ları, template'leri ve model'leri öğreneceğiz.
Bu bölüm, veritabanları ve web uygulama geliştirme konularına ilgi duyan
herkes için faydalı olacaktır.
SQLite ve MySQL gibi veritabanlarına giriş: veri ekleme, güncelleme, silme ve
sorgulama
Veritabanları, verilerin saklandığı ve düzenlendiği yapılandırılmış depolama
sistemleridir. Python, SQLite ve MySQL gibi birçok veritabanı yönetim sistemini
destekler ve bu veritabanlarına erişmek için bir dizi modül sağlar.
SQLite Veritabanı
SQLite, yerel depolama için kullanılan küçük bir veritabanı yönetim sistemidir.
Python, SQLite veritabanına erişmek için sqlite3 modülünü sağlar.
Veritabanı Oluşturma ve Bağlantı Kurma
import sqlite3
# Veritabanına bağlanma
conn = sqlite3.connect('example.db')
# Bağlantıyı kapatma
conn.close()
Yukarıdaki kodda, sqlite3 modülü kullanılarak example.db adlı bir SQLite
veritabanına bağlanılmış ve bağlantı kapatılmıştır.
Tablo Oluşturma
SQLite veritabanında, veriler tablolar halinde saklanır. Bir tablo oluşturmak için,
CREATE TABLE ifadesi kullanılır. Aşağıdaki örnekte, students adlı bir tablo
oluşturulmuştur:
import sqlite3
# Veritabanına bağlanma
conn = sqlite3.connect('example.db')
# Tablo oluşturma
conn.execute('''CREATE TABLE students
(id INT PRIMARY KEY NOT NULL,
name TEXT NOT NULL,
age INT NOT NULL);''')
# Bağlantıyı kaydetme ve kapatma
conn.commit()
conn.close()
Yukarıdaki örnekte, students adlı bir tablo oluşturulmuştur. Tablo, id, name ve
age adlı üç sütundan oluşmaktadır. id sütunu, birincil anahtar (primary key)
olarak işaretlenmiştir.
Veri Ekleme
Veri eklemek için, INSERT INTO ifadesi kullanılır. Aşağıdaki örnekte, students
tablosuna birkaç öğrenci eklenmiştir:
import sqlite3
# Veritabanına bağlanma
conn = sqlite3.connect('example.db')
# Veri ekleme
conn.execute("INSERT INTO students (id, name, age) \
VALUES (1, 'Alice', 20)")
conn.execute("INSERT INTO students (id, name, age) \
VALUES (2, 'Bob', 22)")
conn.execute("INSERT INTO students (id, name, age) \
VALUES (3, 'Charlie', 21)")
# Bağlantıyı kaydetme ve kapatma
conn.commit()
conn.close()
Yukarıdaki örnekte, INSERT INTO ifadesi kullanılarak students tablosuna
öğrenciler eklenmiştir.
Veri Güncelleme
Veri güncellemek için, UPDATE ifadesi kullanılır. Aşağıdaki örnekte, Alice adlı
öğrencinin yaşı güncellenmiştir:
import sqlite3
# Veritabanına bağlanma
conn = sqlite3.connect('okul.db')
c = conn.cursor()
# Veri güncelleme
c.execute("UPDATE ogrenciler SET yas = 22 WHERE ad = 'Alice'")
# Değişiklikleri kaydetme
conn.commit()
# Veritabanı bağlantısını kapatma
conn.close()
Bu örnekte, UPDATE ifadesi kullanılarak ogrenciler tablosunda ad sütunu Alice
olan öğrencinin yas sütunu 22 olarak güncellenmiştir. Değişiklikler, commit()
yöntemi kullanılarak kaydedilir ve veritabanı bağlantısı close() yöntemi
kullanılarak kapatılır.
Python'da MySQL veritabanı işlemleri için kullanabileceğimiz birçok kütüphane
var. Bunlar arasında en popüler olanları şunlardır:
•
•
•
PyMySQL: Pure-Python MySQL istemci kütüphanesi
mysql-connector-python: MySQL için resmi Python istemci kütüphanesi
SQLAlchemy: ORM kütüphanesi (Object-Relational Mapping), birden fazla
veritabanı yönetimi için kullanılabilir
Örneğin, mysql-connector-python kütüphanesi kullanarak bir MySQL
veritabanına bağlanıp sorgu çalıştırabiliriz:
import mysql.connector
# Veritabanına bağlanma
conn = mysql.connector.connect(
host="localhost",
user="username",
password="password",
database="mydatabase"
)
# Veri ekleme
cursor = conn.cursor()
sql = "INSERT INTO customers (name, address) VALUES (%s, %s)"
val = ("John", "Highway 21")
cursor.execute(sql, val)
conn.commit()
# Veri güncelleme
cursor = conn.cursor()
sql = "UPDATE customers SET address = 'Park Lane 38' WHERE name = 'John'"
cursor.execute(sql)
conn.commit()
# Veri silme
cursor = conn.cursor()
sql = "DELETE FROM customers WHERE name = 'John'"
cursor.execute(sql)
conn.commit()
# Sorgulama
cursor = conn.cursor()
sql = "SELECT * FROM customers WHERE address ='Park Lane 38'"
cursor.execute(sql)
result = cursor.fetchall()
for row in result:
print(row)
# Bağlantıyı kapatma
conn.close()
Bu örnekte, bir MySQL veritabanına bağlanmak için mysql.connector
kütüphanesi kullanılmıştır. Ardından, veri ekleme, güncelleme, silme ve
sorgulama işlemleri gerçekleştirilmiştir. Son olarak, bağlantı kapatılmıştır.
MySQL veritabanına veri güncelleme işlemi için UPDATE ifadesi kullanılır.
Yukarıdaki örnekte, customers tablosundaki name sütunu "John" olan kaydın
address değeri "Park Lane 38" olarak güncellenmiştir. execute() metoduna
güncelleme sorgusu verilip commit() metodu ile işlem veritabanına
uygulanmıştır.
Veri Silme:
MySQL veritabanından veri silmek için DELETE ifadesi kullanılır. Yukarıdaki
örnekte, customers tablosundan name sütunu "John" olan kaydı silmek için
DELETE ifadesi kullanılmıştır. execute() metoduna silme sorgusu verilip
commit() metodu ile işlem veritabanına uygulanmıştır.
Sorgulama:
MySQL veritabanından veri sorgulamak için SELECT ifadesi kullanılır. Yukarıdaki
örnekte, customers tablosundan address değeri "Park Lane 38" olan kayıtları
sorgulamak için SELECT ifadesi kullanılmıştır. execute() metoduna sorgu verilip,
fetchall() metodu ile sorgu sonuçları alınmıştır. Sonuçlar ekrana yazdırılmıştır.
MySQL ve SQLite gibi veritabanlarına veri ekleme, güncelleme, silme ve
sorgulama gibi işlemler, veri tabanının yapılandırmasına ve kullanılan
kütüphaneye göre değişebilir. Her veritabanı sistemi kendi syntax ve kurallarına
sahiptir, dolayısıyla ilgili belgeleri ve kütüphane dokümantasyonunu incelemek
önemlidir.
Veritabanlarına ek olarak, web uygulama geliştirme de önemli bir konudur. Web
uygulamaları, internet tarayıcıları üzerinden çalışan yazılımlardır ve kullanıcılar
tarafından web sayfaları aracılığıyla erişilebilirler.
Web uygulama geliştirme için çeşitli web çerçeveleri ve araçları bulunmaktadır.
Python için en popüler web çerçeveleri arasında Django, Flask ve Pyramid
bulunmaktadır. Bu çerçeveler, veritabanı entegrasyonu, şablon motorları, URL
yönlendirmesi ve HTTP işleme gibi web uygulamalarında sıkça kullanılan
özellikleri sağlamaktadır.
Örneğin, Django web çerçevesi, veritabanı modelleri oluşturmak için özel bir
ORM (Object-Relational Mapping) sistemi sağlar. Bu, veritabanı işlemlerinin
Python kodunda yapılmasına olanak tanır ve uygulamanın veritabanı
bağlantısını ve sorgularını yönetmesine yardımcı olur. Flask ve Pyramid gibi
diğer web çerçeveleri de benzer şekilde, veritabanı entegrasyonu için
kütüphaneler sağlarlar.
Ayrıca, web uygulama geliştirme sürecinde, tarayıcıların gönderdiği HTTP
isteklerini işlemek için de çeşitli kütüphaneler ve araçlar bulunmaktadır.
Örneğin, Django'nun temel HTTP işleme mekanizması, görünümler (views) adı
verilen Python fonksiyonlarıdır. Bu görünümler, tarayıcının gönderdiği istekleri
işleyip, veritabanından veri çekerek ve şablonlarla birleştirerek, sonuç olarak bir
HTTP yanıtı oluştururlar.
Sonuç olarak, veritabanları ve web uygulama geliştirme, modern yazılım
geliştirme için önemli bir konudur ve Python, bu alanlarda kullanımı kolay, esnek
ve güçlü bir dizi kütüphane ve araç sağlar.
Django gibi Python web framework'leri: projeler oluşturma, model-viewtemplate (MVT) mimarisi, URL yönlendirme, şablonlar ve formlar
Django, Python programlama dili için popüler bir web framework'üdür. Django,
web uygulamaları geliştirme sürecini hızlandırmak ve kolaylaştırmak için
tasarlanmıştır. Bu bölümde, Django kullanarak web uygulamaları geliştirme
sürecinde kullanılan temel kavramları öğreneceksiniz.
Django Projesi Oluşturma
Django projeleri, bir dizi uygulamayı içerebilir ve her uygulama, bir dizi
fonksiyonelliği yerine getirebilir. Django'da bir proje oluşturmak için, djangoadmin aracını kullanabilirsiniz. Aşağıdaki komut, myproject adlı bir Django
projesi oluşturacaktır:
$ django-admin startproject myproject
Bu komut, myproject adlı bir dizin oluşturacak ve bu dizinde birkaç dosya
içerecektir. Projenin yapılandırmasını değiştirmek isterseniz, settings.py
dosyasını düzenleyebilirsiniz.
Model-View-Template (MVT) Mimarisi
Django, Model-View-Template (MVT) adlı bir mimari kullanır. Bu, uygulamaların
verileri (model), kullanıcı arayüzü (template) ve işlevselliği (view) birbirinden
ayrı tutmasını sağlar. Bu, Django uygulamalarının kolay bir şekilde ölçeklenebilir
ve bakımı kolay hale getirir.
Model: Veritabanında depolanan verileri temsil eder.
View: Kullanıcının veriye erişebilmesini sağlar.
Template: Kullanıcının veriyi görüntülemesini sağlar.
Django Uygulaması Oluşturma
Django'da bir uygulama oluşturmak için, manage.py aracını kullanabilirsiniz.
Aşağıdaki komut, myapp adlı bir Django uygulaması oluşturacaktır:
$ python manage.py startapp myapp
Bu komut, myapp adlı bir dizin oluşturacak ve bu dizinde birkaç dosya
içerecektir. Uygulamanın işlevselliğini eklemek için, views.py dosyasını
düzenleyebilirsiniz.
URL Yönlendirme
Django'da URL yönlendirmesi, urls.py dosyasında yapılandırılır. Bu dosya, bir
URL isteği geldiğinde hangi view'ın cevap vereceğini belirler. Aşağıdaki örnek,
myapp/views.py dosyasındaki hello_world view'ını, http://localhost:8000/
URL'siyle eşleştirir:
# myapp/urls.py
from django.urls import path
from . import views
urlpatterns = [
path('', views.hello_world, name='hello_world'),
]
Şablonlar
Django şablonları, kullanıcı arayüzünü oluşturmak için kullanılan HTML
dosyalarıdır. Şablonlar, dinamik verileri göstermek için özel etiketler içerir.
Django şablonları, tamamen HTML syntax'ı ile uyumlu olduğundan, HTML, CSS
ve JavaScript ile birlikte kullanılabilir.
Django, şablonları oluşturmak ve yönetmek için birkaç araç sağlar. Şablonlar,
proje dizini içindeki bir klasörde (genellikle "templates" olarak adlandırılır)
saklanır ve Django, bu klasörü projeye ekledikten sonra şablonları kullanmak
için hazırdır.
Şablon etiketleri, süslü parantezler içinde tanımlanır ve {% %} işaretleriyle
başlar. En sık kullanılan şablon etiketleri şunlardır:
{% extends %}: Başka bir şablondan türetilen şablonları tanımlar.
{% block %}: Diğer şablonlar tarafından genişletilebilen şablon bloklarını
tanımlar.
{% include %}: Başka bir şablonu mevcut şablonun içine dahil etmek için
kullanılır.
{% if %}: Koşullu ifadeler tanımlar.
{% for %}: Döngüleri tanımlar.
{% url %}: URL'lerin yönlendirilmesi için kullanılır.
{{ }}: Şablon içindeki değişkenleri ifade eder.
Aşağıdaki örnek, views.py dosyasında tanımlanan bir veri kümesini index.html
adlı bir şablona aktarıyor ve bu şablonda verileri görüntülüyor:
# views.py
from django.shortcuts import render
def index(request):
data = {'name': 'John', 'age': 30}
return render(request, 'index.html', data)
<!-- index.html -->
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>My Website</title>
</head>
<body>
<h1>Welcome, {{ name }}!</h1>
{% if age %}
<p>You are {{ age }} years old.</p>
{% endif %}
</body>
</html>
Bu örnekte, index adlı bir fonksiyon, data adlı bir sözlük oluşturur. Bu sözlük,
name ve age anahtarlarına sahip iki öğe içerir. render fonksiyonu, request
nesnesi, şablon adı (index.html) ve veri sözlüğü (data) parametreleri alır ve bu
verileri index.html şablonuna gönderir. Şablon, {{ name }} ve {% if age %} gibi
şablon etiketlerini kullanarak verileri gösterir.
Django şablonları, web uygulamalarının arayüzlerinin oluşturulmasında
kullanılan temel yapı taşlarından biridir. Şablonlar, web uygulamasında
görüntülenen HTML kodunu oluşturmak için kullanılır ve Django'nun ModelView-Template (MVT) mimarisinde "Template" kısmını temsil ederler.
Django şablonları, HTML kodunu içeren dosyalardır ve bir dizi şablon dilini
(Template Language) kullanarak Python kodu ve verileri HTML koduna
dönüştürürler. Şablon dilinde, Python kodu genellikle süslü parantezler içinde
yer alır ve verileri çekmek, döngüler oluşturmak veya karar yapıları oluşturmak
için kullanılır.
Örneğin, bir web uygulamasında bir blog yazısı listesi görüntülenmek
istendiğinde, bu liste verileri bir veritabanından çekilir ve bir döngü kullanarak
her bir blog yazısı için bir HTML bloğu oluşturulur. Bu HTML bloğu, şablon
dosyasındaki belirli bir yere yerleştirilerek, sonuçta görüntülenen web
sayfasının oluşturulmasına yardımcı olur.
Django, şablonların yönetimini kolaylaştırmak için bazı özellikler sunar. Örneğin,
Django şablon motoru, şablonların yüksek performanslı bir şekilde önbelleğe
alınmasına olanak tanır ve böylece daha hızlı bir web uygulaması
oluşturulmasını sağlar. Django ayrıca, tekrar kullanılabilir şablon blokları ve
etiketleri gibi bazı önceden tanımlanmış şablon elemanlarını içerir, böylece kod
tekrarının önüne geçilir ve uygulamanın bakımı kolaylaşır.
Şablonlar, Django'nun Model-View-Template (MVT) mimarisinde, "Template"
kısmını temsil ederler. Bu mimari, verilerin yönetimini ve işlenmesini, kullanıcı
arayüzünün ayrı tutulmasını sağlar ve böylece web uygulamalarının
geliştirilmesini daha kolay ve esnek hale getirir.
Django'nun şablon özelliği, web uygulamalarının daha modüler ve ölçeklenebilir
olmasını sağlar. Şablonlar, kullanıcı arayüzü oluşturmak için kullanılan HTML,
CSS ve JavaScript gibi teknolojileri içerir ve kullanıcı arayüzü değiştirildiğinde
kod tekrar yazmaktan kaçınmak için kullanışlıdır.
Ayrıca, Django'nun şablon özelliği, veritabanından gelen verilerin HTML
şablonlarında dinamik olarak görüntülenmesini sağlar. Bu, web uygulamalarının
verimli bir şekilde çalışmasını sağlar ve tekrarlayan kod yazmaktan kaçınır.
Sonuç olarak, Django gibi Python web framework'leri, web uygulamalarının hızlı
ve verimli bir şekilde geliştirilmesini sağlar. Django'nun model-view-template
(MVT) mimarisi, URL yönlendirme, şablonlar ve formlar gibi özellikleri, web
uygulamalarını yapılandırmayı, kullanıcı arayüzünü oluşturmayı ve veritabanı
işlemlerini yönetmeyi kolaylaştırır.
Flask gibi Python web framework'leri: temel yapılandırma, HTTP istekleri
ve yanıtları
Flask, Python dilinde yazılmış bir web uygulama çatısıdır. Django'nun aksine
daha minimalist bir yapıya sahiptir ve geliştiricilere daha çok özgürlük sağlar.
Flask, basit web uygulamaları için idealdir ve özellikle küçük veya orta ölçekli
projelerde kullanılmaktadır.
Flask temel olarak, HTTP istekleri ve yanıtları üzerinde çalışır. HTTP istekleri,
kullanıcının web tarayıcısı aracılığıyla bir sayfaya erişmek istediği zaman
gönderdiği isteklerdir. Flask, bu isteklere yanıt vermek için belirli kodları
çalıştırır ve sonuç olarak kullanıcıya bir yanıt gönderir.
Flask uygulamalarının oluşturulması için, temel olarak şu adımlar takip edilir:
Flask yükleme: Flask, Python paket yöneticisi olan pip aracılığıyla yüklenir.
Flask'ı yükledikten sonra, uygulamanızda kullanmak için Flask modülünü içeri
aktarmanız gerekir.
Uygulama oluşturma: Flask, bir uygulama objesi oluşturmanıza olanak tanır. Bu
obje, uygulamanın ana bileşenidir ve HTTP isteklerini yönetir. Uygulama objesi,
Flask sınıfının bir örneği olarak oluşturulur.
URL yönlendirme: Flask, HTTP isteklerini yönetmek için URL yönlendirme
sistemini kullanır. Bu sistem, bir URL isteği aldığında hangi işlevin çalışacağını
belirler. Flask, bir URL isteği aldığında ilgili işlevi çalıştırmak için bir dekoratör
fonksiyonu olan @app.route() sağlar.
İstek ve yanıt: Flask, HTTP isteklerine yanıt olarak HTML sayfaları, JSON verileri
veya diğer veri türlerini döndürebilir. Flask, istekleri ve yanıtları yönetmek için
request ve response nesneleri sağlar.
İşte Flask kullanarak basit bir "Merhaba Dünya" uygulaması örneği:
from flask import Flask
# Flask uygulaması oluşturma
app = Flask(_name_)
# URL yönlendirmesi
@app.route("/")
def hello():
return "Merhaba Dünya!"
# Uygulamayı çalıştırma
if _name_ == "_main_":
app.run()
Bu uygulama, web tarayıcısından http://localhost:5000 adresine gidildiğinde
"Merhaba Dünya!" mesajını gösterir.
Flask, Django'ya göre daha minimalist bir yapıya sahip olduğundan, daha fazla
özelleştirme seçeneği sağlar. Bu nedenle Flask, özellikle küçük ve orta ölçekli
projelerde tercih edilen bir web uygulama çatısıdır.
Flask, Python ile yazılmış popüler bir web framework'üdür ve web uygulamaları
geliştirmek için kullanılır. Flask, küçük ölçekli uygulamaların hızlı bir şekilde
geliştirilmesine olanak tanır ve düşük bir öğrenme eşiğiyle birlikte gelir.
Flask, basit ve minimal bir yapıya sahip olmasıyla dikkat çeker. Flask, MVC
(Model-View-Controller) gibi karmaşık bir yapıya sahip değildir ve genellikle
mikro framework olarak adlandırılır. Bu nedenle, Flask, yeni başlayanlar için
web uygulamaları geliştirmeye başlamak için ideal bir seçenektir.
Flask'da temel yapılandırma, uygulamanın temel ayarlarının yapılandırıldığı
kısımdır. Flask uygulamanızın temel yapılandırmasını app.config objesi
üzerinden yapabilirsiniz. Örneğin, veritabanı bağlantı bilgileri, oturum yönetimi
ayarları, gizli anahtar gibi konfigürasyonları burada ayarlayabilirsiniz.
HTTP istekleri ve yanıtları Flask ile kolayca işlenebilir. Flask, HTTP isteklerini ve
yanıtlarını yönetmek için birçok yardımcı fonksiyon ve sınıf sağlar. route
dekoratörü kullanarak URL yönlendirmelerini belirleyebilirsiniz. Örneğin, belirli
bir URL'ye yapılan GET veya POST isteklerini işlemek için Flask ile kolayca bir
route belirleyebilirsiniz.
Flask ayrıca dinamik URL yönlendirmesi sağlar, yani URL'lerde değişkenler
kullanabilirsiniz. Örneğin, /users/1 URL'sindeki 1 değeri kullanıcı kimlik
numarasını temsil edebilir ve bu değeri Flask ile kolayca yakalayabilir ve
kullanabilirsiniz.
Özelleştirilmiş hata sayfaları Flask ile kolayca oluşturulabilir. Flask,
uygulamanızda meydana gelen hatalara özelleştirilmiş bir şekilde yanıt
vermenize olanak tanır. errorhandler dekoratörünü kullanarak farklı hata
durumlarını yakalayabilir ve hata sayfalarını özelleştirebilirsiniz.
Sonuç olarak, Flask web framework'ü, hızlı ve küçük ölçekli web uygulamaları
geliştirmek için mükemmel bir seçenektir. Flask, basit ve minimal yapısıyla
geliştiricilere esneklik sağlar ve Python programlama dili ile uyumlu olması
nedeniyle Python geliştiricileri için tercih edilen bir seçenektir. Flask, temel
yapılandırma, HTTP istekleri ve yanıtları, dinamik URL yönlendirmesi ve
özelleştirilmiş hata sayfaları gibi temel web geliştirme konseptlerini kolayca
kullanmanıza
Flask web framework'ü, hızlı ve küçük ölçekli web uygulamaları geliştirmek için
mükemmel bir seçenektir. Flask, düşük bir öğrenme eşiğiyle birlikte gelir ve
kolayca yapılandırılabilir. Flask, Python programlama diliyle uyumlu olduğu için,
geliştiricilerin aşina oldukları dilde web uygulamaları geliştirmelerini
kolaylaştırır. Ayrıca, Flask, HTTP istekleri ve yanıtları, dinamik URL
yönlendirmesi ve özelleştirilmiş hata sayfaları oluşturma gibi temel web
uygulaması geliştirme ihtiyaçlarını karşılamak için özellikler sunar. Flask, Python
programlama dili ve web geliştirme konusunda deneyimli olan veya yeni
başlayan geliştiriciler için uygun bir seçenektir.
RESTful web servisleri
REST (Representational State Transfer), modern web uygulamalarında sıklıkla
kullanılan bir mimaridir. RESTful web servisleri, REST mimarisine uygun olarak
tasarlanmış ve uygulanmış web servisleridir. Bu servisler, farklı platformlar ve
programlama dilleri arasında veri alışverişini sağlayarak, uygulama geliştirme
sürecini kolaylaştırır.
REST, birçok standart HTTP metodu (GET, POST, PUT, DELETE vb.) ve HTTP
durum kodlarını kullanarak, sunucu ile istemci arasında iletişim kurar. RESTful
web servisleri, bu HTTP metotları ve durum kodları kullanılarak tasarlanmıştır.
Örneğin, GET metodu, sunucudan belirtilen kaynağın okunmasını sağlar. POST
metodu, belirtilen kaynağa yeni bir kaynak eklenmesini sağlar.
RESTful web servisleri, kaynakların benzersiz bir tanımlayıcıya sahip olduğu bir
URI (Uniform Resource Identifier) üzerinden erişilebilir. Bu kaynaklar, XML veya
JSON gibi formatta temsil edilir ve istemci ile sunucu arasında değiş tokuş edilir.
Bu formatta verilerin taşınması, platformlar arası uyumluluk sağlar.
RESTful web servisleri, modüler bir yapıya sahiptir ve farklı bileşenlerin
birleştirilmesiyle oluşur. Bu bileşenler, sunucu tarafındaki kaynaklar, HTTP
metotları, durum kodları, URI yapıları ve veri formatlarıdır. Bu bileşenler,
uygulama geliştiricilerine RESTful web servislerini kolayca tasarlama ve
uygulama imkanı sağlar.
Sonuç olarak, RESTful web servisleri, modern web uygulamalarında vazgeçilmez
bir bileşendir. REST mimarisi, farklı platformlar ve programlama dilleri arasında
veri alışverişi yapmak için standart bir yol sağlar. RESTful web servisleri,
kaynakları benzersiz bir tanımlayıcıya sahip URI üzerinden erişilebilir hale
getirir ve modüler bir yapıya sahiptir.
RESTful web servislerinin birçok avantajı vardır. İşletmelerin ve geliştiricilerin
RESTful web servislerini tercih etmelerinin nedenleri arasında şunlar yer alır:
Esneklik: RESTful web servisleri, farklı platformlar ve cihazlar arasında veri
paylaşımını kolaylaştırır. Bu, uygulamaların herhangi bir cihazda çalışmasına
olanak tanır ve işletmelerin kullanıcılarına herhangi bir cihazda hizmet
sunmalarına izin verir.
Ölçeklenebilirlik: RESTful web servisleri, birden fazla sunucu veya veritabanı
arasında veri alışverişini kolaylaştırır. Bu, büyük ölçekli uygulamaların
ölçeklendirilmesine olanak tanır ve daha fazla kullanıcı veya veri trafiği ile başa
çıkmak için altyapıyı genişletmeyi kolaylaştırır.
Güvenlik: RESTful web servisleri, HTTPS protokolü üzerinden güvenli bir şekilde
çalışabilir. Bu, verilerin güvenliğini sağlar ve yetkilendirilmemiş erişimi engeller.
Yeniden Kullanılabilirlik: RESTful web servisleri, kaynaklar ve kaynaklar
arasındaki bağımlılıkları azaltarak yeniden kullanılabilir kod yazmayı
kolaylaştırır. Bu, kodun daha az tekrarlanmasına ve daha az hata olasılığına yol
açar.
Erişilebilirlik: RESTful web servisleri, web standardı HTTP protokolünü kullanır.
Bu, web tarayıcıları ve diğer uygulamalar tarafından kolayca erişilebilir
olmalarını sağlar. Bu da uygulamaların yaygın olarak kullanılabilmesine olanak
tanır.
RESTful web servisleri modern web uygulamalarının temel taşlarından biridir.
RESTful web servisleri, uygulamaların esnek, ölçeklenebilir, güvenli, yeniden
kullanılabilir ve erişilebilir olmasını sağlar. Bu nedenle, işletmelerin ve
geliştiricilerin RESTful web servisleri geliştirmeyi tercih etmeleri son derece
yaygındır.
Sonuç olarak, RESTful web servisleri, modern web uygulamalarında yaygın
olarak kullanılan bir arayüz standardıdır. REST prensiplerine uygun olarak
tasarlanmış bir web servisi, kullanıcıların verileri kaynaklara göre almasını,
oluşturmasını, güncellemesini ve silmesini sağlar. RESTful web servisleri,
istemcilerin uygulama sunucusuyla konuşabilmesini sağlayan birçok protokol ve
teknoloji üzerine inşa edilebilir. Bu nedenle, birçok programlama dili ve
framework'ü RESTful web servisleri oluşturmak için kullanılabilir. RESTful web
servisleri, uygulama geliştiricilerine, uygulama geliştirme sürecinde verilerin
nasıl işleneceği ve aktarılacağına ilişkin bir standart sunar. Bu, farklı
uygulamaların, farklı platformlarda ve dillerde yazılmış olmalarına rağmen,
birbirleriyle etkileşim kurabilmelerini kolaylaştırır.
Veritabanı ve web uygulama güvenliği: SQL enjeksiyonu, XSS saldırıları ve CSRF
saldırıları
Web uygulamalarının güvenliği, günümüzde giderek daha önemli hale
gelmektedir. Veritabanı ve web uygulama güvenliği, birçok farklı güvenlik
tehdidi ile karşı karşıya kalmaktadır. Bu tehditlerden bazıları SQL enjeksiyonu,
XSS saldırıları ve CSRF saldırılarıdır. Bu bölümde, bu tehditleri daha detaylı
inceleyeceğiz.
SQL enjeksiyonu, web uygulamalarındaki en yaygın güvenlik tehditlerinden
biridir. Bu saldırı türü, kötü niyetli kullanıcıların, bir web uygulamasındaki SQL
sorgularını manipüle ederek, veritabanından gizli bilgileri çalmalarına veya
veritabanını bozmalarına olanak tanır. SQL enjeksiyonu saldırıları, web
uygulamasında SQL sorgularının doğru şekilde işlenmediği durumlarda
gerçekleşir. Bu nedenle, web uygulamalarının güvenliği için, SQL sorgularının
doğru şekilde işlenmesi ve doğrulanması önemlidir.
XSS (Cross-site scripting) saldırıları, web uygulamalarının kullanıcı
arayüzündeki açıklar nedeniyle ortaya çıkan bir güvenlik tehdididir. Bu saldırı
türünde, kötü niyetli kullanıcılar, web uygulamasının kullanıcı arayüzüne zararlı
kodlar enjekte ederek, kullanıcının tarayıcısında çalıştırırlar. Bu nedenle, XSS
saldırıları, kullanıcılara zararlı kodların bulaşmasına neden olabilir. Web
uygulaması geliştiricileri, XSS saldırılarını önlemek için, kullanıcı girişleri ve
çıkışları için doğru filtreleme yöntemlerini kullanmalıdır.
CSRF (Cross-site request forgery) saldırıları, web uygulamalarının kullanıcı
oturumlarını ele geçirmeye yönelik bir saldırı türüdür. Bu saldırıda, kötü niyetli
kullanıcılar, kullanıcının kimliğiyle yetkilendirilmiş bir istek oluşturarak,
kullanıcının isteği dışında işlemler gerçekleştirebilirler. Örneğin, kullanıcının
hesabından para transferi yapabilirler. Web uygulamalarının geliştiricileri, CSRF
saldırılarını önlemek için, kullanıcı kimliği doğrulama, özel jetonlar ve diğer
güvenlik önlemlerini kullanmalıdır.
Sonuç olarak, veritabanı ve web uygulama güvenliği, günümüzde web
uygulamaları geliştirirken en önemli konulardan biridir. SQL enjeksiyonu, XSS
saldırıları ve CSRF saldırıları, web uygulamalarının güvenliği için önemli
adımlardan bazılarıdır. Web uygulamaları, kullanıcı verilerini veritabanlarında
depoladığı için SQL enjeksiyonu saldırılarına karşı savunmasızdır. Bu nedenle,
geliştiricilerin verileri doğru bir şekilde temizleyerek, hazırlayarak ve doğru bir
şekilde sorgulayarak SQL enjeksiyonu saldırılarına karşı koruma sağlamaları
önemlidir.
Ayrıca, XSS saldırıları, kullanıcının tarayıcısına zararlı kod enjekte ederek
uygulamayı ele geçirme ve kullanıcının bilgilerine erişme amacını taşır.
Geliştiricilerin kullanıcı verilerini doğru bir şekilde filtreleyerek ve encode
ederek, XSS saldırılarına karşı koruma sağlamaları önemlidir.
Son olarak, CSRF saldırıları, web uygulamalarının işlevlerinin kullanıcının isteği
dışında çalışmasına neden olur. Bu saldırıların engellenmesi için, web
uygulamalarının her işlevine token eklenerek, token'ların her istekte kontrol
edilmesi sağlanmalıdır.
Tüm bu güvenlik tehditleriyle başa çıkmak için, geliştiricilerin web
uygulamalarının güvenliğini sağlamak için doğru kodlama tekniklerini
uygulamaları ve düzenli olarak güvenlik kontrolleri yapmaları önemlidir.
Bununla birlikte, kullanıcıların da güçlü parolalar kullanarak ve güvenli bir
internet bağlantısı kullanarak web uygulamalarının güvenliğini artırması
gerekmektedir.
Sonuç olarak, web uygulama güvenliği, herhangi bir web uygulamasının başarısı
ve sürdürülebilirliği için kritik öneme sahiptir. SQL enjeksiyonu, XSS saldırıları
ve CSRF saldırıları, web uygulamalarının karşılaşabileceği en yaygın güvenlik
zafiyetleri arasındadır.
SQL enjeksiyonu, veritabanı güvenliği açısından çok ciddi bir tehdit
oluştururken, XSS saldırıları ve CSRF saldırıları, kullanıcı verilerinin çalınması
veya kötü amaçlı kullanımı için kullanılabilir. Bu nedenle, web uygulamalarının
geliştirilmesi sırasında, güvenlik ihtiyaçları düşünülerek tasarlanması ve
geliştirilmesi gerekmektedir.
Web uygulama güvenliği için, birçok çözüm bulunmaktadır. Örneğin, güvenli
kodlama tekniklerinin kullanılması, doğru veri doğrulama işlemlerinin yapılması,
kimlik doğrulama ve yetkilendirme sistemlerinin kurulması, güvenlik testleri
yapılması ve güvenlik açıkları bulunması durumunda hızlıca düzeltme
işlemlerinin yapılması gerekmektedir.
Sonuç olarak, web uygulama güvenliği, web uygulamalarının başarısı ve
sürdürülebilirliği için hayati önem taşır ve her zaman göz önünde
bulundurulmalıdır.
Bölüm 5: İleri Seviye Konular
Web uygulama geliştirmenin ileri seviye konuları, daha karmaşık ve sofistike
web uygulamaları inşa etme süreçlerini içerir. Bu bölümde, Flask gibi popüler
web framework'leri kullanarak ileri seviye konulara odaklanacağız. Bu konular,
geliştiricilere daha karmaşık web uygulamaları geliştirmek için gerekli olan
becerileri sağlar ve daha karmaşık gereksinimlere uygun çözümler sunar.
Bu bölümde, web uygulama geliştirme sürecinde ihtiyaç duyulan daha ileri
düzeyde konuları ele alacağız. Özellikle, veritabanı yönetimi, kullanıcı
yetkilendirme ve kimlik doğrulama, API geliştirme ve test etme, performans
optimizasyonu ve güvenlik gibi konulara değineceğiz.
Veritabanı yönetimi, web uygulamalarının karmaşıklığı arttıkça önemli bir konu
haline gelir. Veritabanı kullanımı, veri depolama, sorgulama ve güncelleme
işlemlerinin yönetilmesini içerir. Flask gibi web framework'leri ile birlikte
kullanılan ORM (Object Relational Mapping) kütüphaneleri, veritabanı
yönetimini daha kolay ve etkili hale getirir.
Kullanıcı yetkilendirme ve kimlik doğrulama, web uygulamalarının güvenliği
açısından hayati öneme sahiptir. Kullanıcıların kimlik doğrulaması,
yetkilendirme işlemleri ve erişim kontrolü gibi güvenlik önlemleri, kullanıcı
verilerini ve web uygulamasını koruma açısından önemlidir.
API (Application Programming Interface) geliştirme, modern web
uygulamalarında yaygın olarak kullanılan bir konudur. API'ler, web
uygulamalarının diğer uygulamalarla iletişim kurmasını sağlar. Flask gibi web
framework'leri, API geliştirme için kolayca kullanılabilir ve esnek yapılar sunar.
Performans optimizasyonu, web uygulamalarının hızını, ölçeklenebilirliğini ve
kullanılabilirliğini artırmak için önemlidir. Web uygulamalarının performansını
optimize etmek, kullanıcı deneyimini artırabilir ve web uygulamasının rekabetçi
olmasına yardımcı olabilir.
Son olarak, güvenlik, herhangi bir web uygulaması için kritik bir konudur. Web
uygulamalarının güvenlik açıklarını tespit etme, güvenlik testleri yapma ve
güvenlik önlemlerini uygulama, web uygulamalarının güvenliğini artırmak için
gereklidir.
Bu bölümde, Flask gibi popüler bir web framework'ü kullanarak ileri seviye
konuları daha ayrıntılı bir şekilde ele
alacağız. İleri seviye konular, web uygulamalarının daha karmaşık işlevlerini
yerine getirmek için kullanılabilir. Bu bölümde, Flask web framework'ü
kullanarak güvenli oturum yönetimi, veritabanı ilişkileri, API geliştirme ve test
otomasyonu gibi konuları ele alacağız alacağız. İleri seviye konular, web
uygulamalarının daha karmaşık işlevlerini yerine getirmek için kullanılabilir. Bu
bölümde, Flask web framework'ü kullanarak güvenli oturum yönetimi,
veritabanı ilişkileri, API geliştirme ve test otomasyonu gibi konuları ele alacağız.
Güvenli oturum yönetimi, web uygulamalarının temel gerekliliklerinden biridir
ve saldırganların hassas verilere erişmesini engellemek için tasarlanmıştır.
Veritabanı ilişkileri, veritabanı tabloları arasındaki ilişkileri belirlemek ve bu
ilişkileri kullanarak veri manipülasyonunu yapmak için kullanılır. API geliştirme,
web uygulamalarının veri paylaşımı yapmasına olanak tanır ve farklı
platformlarda kullanılabilen verileri sunar. Test otomasyonu ise, yazılım
testlerini otomatikleştirmek ve hızlandırmak için kullanılır.
Bu bölümde, Flask web framework'ü kullanarak güvenli oturum yönetimi,
veritabanı ilişkileri, API geliştirme ve test otomasyonu konularını ayrıntılı bir
şekilde ele alacağız. Bu konuların her biri, web uygulamaları geliştirme sürecinde
farklı zorluklarla karşılaşabileceğiniz alanlardır. Ancak, Flask gibi güçlü bir web
framework'ü kullanarak, bu konuları ele almak daha kolay ve verimli hale
gelebilir.
Python'un hızlandırılması: JIT derleyiciler, Cython ve PyPy gibi araçlar
Python, kolay okunabilir ve anlaşılır bir dil olduğu için, birçok geliştiricinin tercih
ettiği bir programlama dilidir. Ancak, Python'un performansı, büyük veri işleme,
bilimsel hesaplama veya yüksek trafikli web siteleri gibi yoğun hesaplama
gerektiren alanlarda yetersiz kalabilir. Bu nedenle, Python'un performansını
artırmak için farklı yöntemler kullanılmaktadır.
Bu bölümde, Python'un performansını artırmak için kullanılabilecek JIT
derleyiciler, Cython ve PyPy gibi araçlar hakkında detaylı bilgi vereceğiz.
JIT Derleyiciler
Just-In-Time (JIT) derleyiciler, Python kodunu çalıştırırken, kodun çalıştığı sırada
doğrudan makine koduna derlemeye izin verirler. JIT derleyiciler, kodun
performansını artırır ve bazı durumlarda C gibi daha hızlı dillere yakın hızlar
elde edilmesine olanak tanır.
JIT derleyiciler arasında en popüler olanları PyPy, Numba ve Jython'dur.
PyPy
PyPy, Python kodunu hızlandıran popüler bir JIT derleyicisidir. PyPy, Python
kodunu çevrilmiş kod olarak çalıştırır ve bu sayede Python kodunun
hızlanmasını sağlar. PyPy, Python dilinin tüm sürümlerinde uyumlu olacak
şekilde tasarlanmıştır ve CPython'den daha hızlı performans gösterir.
Numba
Numba, bilimsel hesaplama uygulamaları için kullanılan bir JIT derleyicisidir.
Numba, NumPy, SciPy ve diğer bilimsel kütüphaneleri kullanarak Python
kodunun hızlandırılmasına olanak tanır. Numba, fonksiyonları otomatik olarak
JIT derleyerek, performansı artırır.
Jython
Jython, Python kodunu JVM (Java Virtual Machine) üzerinde çalıştıran bir JIT
derleyicisidir. Bu nedenle, Jython, Python kodunun performansını artırır ve aynı
zamanda Java ile entegrasyonu kolaylaştırır.
Cython
Cython, Python dilinin C diline çevrilmesini sağlayan bir araçtır. Cython, Python
kodunu daha hızlı hale getirmek için, Python kodunu C koduna dönüştürerek,
hızlandırır. Cython, CPython ile uyumlu olduğu için, CPython'de çalıştırılabilen
Python modülleri ve kütüphaneleriyle birlikte kullanılabilir.
Sonuç
Python, kolay anlaşılır bir dildir ancak büyük veri işleme, bilimsel hesaplama
veya yüksek trafikli web siteleri gibi yoğun hesaplama gerektiren alanlarda
yetersiz kalabilir. JIT derleyiciler, Cython ve PyPy gibi araçlar, Python kodunun
performansını artırır ve daha hızlı çalışmasına olanak sağlar. Bu araçlar,
Python'un diğer dillere göre dezavantajlı yönlerini azaltarak, dilin popülerliğini
arttırmaktadır.
JIT derleyiciler, Python kodunu çalışma zamanında derleyerek performans artışı
sağlarlar. JIT derleyicileri kullanan popüler Python uygulamaları arasında PyPy,
Numba ve Pyjion yer alır.
Cython, C diline benzer bir Python türevidir ve Python kodunu C koduna
dönüştürerek performans artışı sağlar. Cython, Python'un yavaşlığından
kaynaklanan performans sorunlarını çözmek için sıklıkla kullanılır.
PyPy, Python kodunu JIT derleyicisiyle çalıştırarak performans artışı sağlar.
PyPy, CPython ile uyumlu olduğu için, mevcut Python kodlarının kolayca
yükseltilmesine olanak tanır.
Sonuç olarak, Python, kolay öğrenilebilirliği, okunabilirliği ve yüksek üretkenliği
sayesinde birçok uygulama için tercih edilen bir programlama dilidir. Ancak
büyük veri işleme, bilimsel hesaplama veya yüksek trafikli web siteleri gibi
yoğun hesaplama gerektiren alanlarda performansı yetersiz kalabilir. JIT
derleyiciler, Cython ve PyPy gibi araçlar, Python kodunun performansını
artırarak, Python'u diğer dillere karşı rekabetçi hale getirir.
Bu bölümde, Python'un performansını artırmak için kullanılan çeşitli araçlar ve
teknikler hakkında bilgi edindik. JIT derleyiciler, Cython ve PyPy, Python
kodunun daha hızlı çalışmasına olanak tanır ve büyük veri işleme, bilimsel
hesaplama ve yüksek trafikli web siteleri gibi yoğun hesaplama gerektiren
alanlarda Python'u daha etkili hale getirir.
JIT derleyiciler, Python kodunu çalışma zamanında derler ve optimize eder. Bu,
Python kodunun C gibi düşük seviyeli bir dilde derlenmiş bir programa benzer
şekilde çalışmasına olanak tanır. PyPy, Python kodunu JIT derleyici kullanarak
optimize eder ve CPython'dan daha hızlı çalışır.
Cython, Python kodunu C veya C++ koduna dönüştürmenizi sağlar. Bu, Python
kodunun daha hızlı çalışmasına olanak tanır. Cython, CPython ile birlikte
kullanılabilir ve birçok popüler Python kütüphanesi, Cython tarafından
desteklenir.
Bu araçlar, Python kodunun performansını artırmak için kullanılabilecek
seçenekler arasındadır. Ancak, performans artışı, programlama dilinin doğası
gereği mümkün olan en yüksek hızda çalışmasını garanti etmez. Python'un hızlı
olmayan bölümlerini optimize etmek ve daha hızlı çalışmasını sağlamak için
diğer teknikler de kullanılabilir.
Sonuç olarak, JIT derleyiciler, Cython ve PyPy gibi araçlar, Python kodunun
performansını artırır ve Python'u büyük veri işleme, bilimsel hesaplama ve
yüksek trafikli web siteleri gibi yoğun hesaplama gerektiren alanlarda
kullanılabilir hale getirir. Ancak, Python'un doğası gereği, performans artışı
garanti edilemez ve daha hızlı çalışmasını sağlamak için diğer teknikler de
kullanılabilir.
İleri seviye veri yapıları: çoklu bağlantılı listeler, ağaçlar, graflar ve karma
tablolar
İleri seviye veri yapıları, programlamada karmaşık sorunların çözümüne
yardımcı olan ve daha etkili veri işleme yöntemleri sunan araçlardır. Bu
bölümde, çoklu bağlantılı listeler, ağaçlar, graflar ve karma tablolar gibi ileri
seviye veri yapılarını inceleyeceğiz.
1. Çoklu Bağlantılı Listeler
Çoklu bağlantılı listeler, her bir düğümün bir önceki ve bir sonraki düğümle
bağlantılı olduğu bir veri yapısıdır. Her bir düğümün bir veri parçası içerdiği ve
listelerdeki öğelerin ekleme, çıkarma ve değiştirme işlemlerinin yapılabilmesini
sağlayan bağlantıları vardır. Çoklu bağlantılı listeler, verilerin bağlantılı ve sıralı
olarak depolanması gerektiği birçok durumda kullanılabilir.
2. Ağaçlar:
Ağaçlar, hiyerarşik bir yapı oluşturmak için kullanılan veri yapılarıdır. Bu yapı,
bir kök düğüm (root node) ve ondan türetilen dallar ve yapraklar (leaves) gibi
çeşitli düğümlerden oluşur. Her bir düğüm, bir değer veya bir veri parçası ile
ilişkilendirilebilir.
Ağaçlar, birçok algoritma ve veri yapısı tasarımında kullanılır. Örneğin, bir dosya
sistemi ağacı, bir XML belgesi ağacı veya bir işlemci işlemleri ağacı gibi. Ağaçların
temel özellikleri arasında, bir düğümün bir veya birden çok alt düğüme sahip
olabileceği ve bir alt düğümün birden çok üst düğüme bağlanabileceği bulunur.
3. Graflar:
Graflar, birçok bağımsız nesnenin birbirine bağlı olduğu bir veri yapısıdır. Bir
graf, düğümler (nodes) veya noktalar ve bunları birbirine bağlayan kenarlar
(edges) olarak tanımlanır. Graflar, özellikle iletişim ağlarının tasarımı ve analizi,
yol planlama, programlama dilleri derleyicileri ve çizge teorisi gibi birçok alanda
kullanılır.
Graflar, yönlü (directed) ve yönsüz (undirected) olarak ikiye ayrılır. Yönlü bir
graf, kenarların belirli bir yönde hareket ettiği bir grafi ifade ederken, yönsüz bir
graf, kenarların hareketinin belirli bir yönde olmadığı bir grafi ifade eder.
4. Karma Tablolar:
Karma tablolar, anahtar-değer (key-value) çiftleri için bir depolama yapısıdır. Bu
tablolar, bir anahtar (key) ile eşleştirilmiş bir değer (value) içerir. Anahtar-değer
çiftleri, bir öğeyi kolayca bulmak için kullanılabilir ve birçok alanda kullanılır.
Örneğin, bir kelime sözlüğü, bir programlama dilindeki değişkenlerin
depolanması veya bir e-ticaret sitesindeki ürünlerin depolanması için
kullanılabilir.
Karma tabloların arama işlemleri, çoğu durumda hızlıdır. Bunun nedeni, her
anahtarın, bir değere karşılık geldiği sabit bir konuma sahip olmasıdır. Bu, arama
işleminin doğrudan bu konumdan yapılabilmesi anlamına gelir.
Sonuç olarak, ileri seviye veri yapıları, daha karmaşık programlar oluşturmak
için kullanışlıdır. Çoklu bağlantılı listeler, ağaçlar, graflar ve karma tablolar, veri
depolama ve yönetiminde farklı amaçlar için kullanılır. Bu veri yapıları, verileri
organize etmek, aramak, ekleme ve çıkarma gibi işlemleri daha hızlı ve verimli
bir şekilde gerçekleştirmek için kullanışlıdır.
Çoklu bağlantılı listeler, tek yönlü bağlantılı listelere ek olarak daha fazla
bağlantıya sahiptir ve verileri depolamak için daha fazla esneklik sağlar. Çoklu
bağlantılı listeler, verileri ekleme, çıkarma ve arama işlemlerini gerçekleştirmek
için hızlı ve verimlidir.
Ağaçlar, hiyerarşik verileri depolamak için kullanılır ve verilerin okunması,
ekleme ve çıkarma işlemleri için idealdir. Ağaçlar, ayrıca algoritma tasarımında
da yaygın olarak kullanılır.
Graflar, noktalar ve kenarlarla birbirine bağlı veri yapılarıdır. Graflar, sosyal
ağlar, yol ağları ve iletişim ağları gibi birçok alanda kullanılır. Graflar, veriye hızlı
erişim sağlar ve verilerin analiz edilmesi ve keşfedilmesi için kullanılır.
Karma tablolar, öğeleri bir anahtarla birleştiren bir veri yapısıdır. Anahtarlar,
öğelerin depolanması ve okunması için kullanılır. Karma tablolar, verileri hızlı
bir şekilde aramak ve okumak için kullanılır.
Bu ileri seviye veri yapıları, farklı senaryolarda verileri organize etmek ve
yönetmek için kullanılır. Geliştiriciler, uygun veri yapısını seçerek veri yönetimi
sorunlarını çözebilirler ve daha iyi bir performans elde edebilirler.
Bununla birlikte, her veri yapısının kendi avantajları ve dezavantajları vardır ve
bu, kullanım durumuna göre belirlenmelidir. Örneğin, çoklu bağlantılı listeler,
düğüm ekleme veya silme işlemleri için mükemmeldir, ancak belli bir düğüme
erişmek için arama işlemleri yavaş olabilir. Ağaçlar, özellikle arama veya
sıralama gibi işlemler için mükemmel bir seçenek olabilir, ancak çok fazla bellek
kullanabilirler. Graf veri yapıları, özellikle ilişkili verileri temsil etmek için
kullanılır ve genellikle sosyal ağ analizi, harita yönlendirmesi, otomatik öneri
sistemleri gibi uygulamalarda kullanılır. Karma tablolar, hızlı arama ve ekleme
işlemleri için mükemmel bir seçenek olabilir, ancak bu işlemlerin yapısı ve
karma değerleri doğru seçmek önemlidir.
İleri seviye veri yapıları, programlama dünyasında önemli bir role sahiptir.
Programlama dili ne olursa olsun, bu veri yapılarını öğrenmek ve kullanmak,
daha verimli ve optimize edilmiş programlar oluşturmak için önemlidir.
Sonuç olarak, Python dilinin güçlü yönlerinden biri, kullanıcıların kolayca veri
yapıları oluşturabilmesidir. Bu bölümde, çoklu bağlantılı listeler, ağaçlar, graflar
ve karma tablolar gibi ileri seviye veri yapılarına ayrıntılı bir şekilde bakmıştık.
Bu veri yapıları, programcılara daha büyük ve daha karmaşık veri yapılarına
yönelik problemleri ele almalarına olanak tanır. Bununla birlikte, her veri yapısı,
farklı bir amaç için kullanılır ve programcıların bir veri yapısını diğerlerinden
ayırt etmek için kullanabilecekleri bazı temel özelliklere sahiptir. İleri seviye veri
yapıları, veri yönetimi ve işleme konusunda programcılara daha fazla esneklik ve
verimlilik sağlar.
Paralel ve dağıtık hesaplama: threadler, süreçler, kuyruklar ve
mesajlaşma
Paralel ve dağıtık hesaplama, günümüzde çoğu uygulamanın vazgeçilmez bir
parçası haline gelmiştir. Bu yaklaşımlar, uygulamaların performansını artırmak,
hızlarını ve ölçeklenebilirliklerini iyileştirmek için kullanılır. Python, bu alanda
da birçok araç ve modülle birlikte gelir.
Python, birden fazla işlemi aynı anda yürütmek için birkaç yol sunar. Bunlardan
bazıları şunlardır:
Threadler
Threadler, bir Python programındaki en hafif parçalardan biridir. Her bir thread,
programda ayrı bir işlem yürüten bir parçadır. Threadler, aynı anda birden fazla
görevi gerçekleştirmek için kullanılır. Python, threading modülü ile birlikte gelir
ve bu modül, threadlerin oluşturulması, kontrolü ve yönetimi için bir dizi işlev
sağlar.
Süreçler
Süreçler, programın işletim sistemi tarafından ayrılmış bir parçasıdır. Python,
multiprocessing modülü ile süreçlerin oluşturulması, kontrolü ve yönetimi için
bir dizi işlev sağlar. Süreçler, özellikle CPU yoğun uygulamalarda kullanışlıdır.
Kuyruklar
Kuyruklar, birden fazla işlemi sıraya koyarak, önceliklerini belirleyerek ve
işlemleri yürütmek için uygun bir zamanda çalıştırmak için kullanılır. Python,
queue modülü ile kuyrukların oluşturulması, kontrolü ve yönetimi için bir dizi
işlev sağlar.
Mesajlaşma
Mesajlaşma, birbirinden ayrı çalışan işlemler veya makineler arasındaki iletişimi
sağlar. Python, multiprocessing modülü ile mesajlaşmanın oluşturulması,
kontrolü ve yönetimi için bir dizi işlev sağlar. Bu modül, işlemler arasında veri
paylaşımı yapmak için Queue, Pipe ve Value gibi araçlar sağlar.
Python ayrıca, paralel hesaplama için diğer araçlar da sağlar:
asyncio
Python, 3.4 sürümünden itibaren asyncio adlı bir modül ile asenkron
programlama desteği sağlar. Bu modül, aynı anda birden fazla işlemi aynı
zamanda yürütmek için bir dizi araç sağlar.
Celery
Celery, Python ile birlikte kullanılan bir açık kaynaklı dağıtık görev kuyruğu
sistemidir. Bu sistem, dağıtık işlemler, süreçler veya makineler arasında iş
yükünü dengelemek için kullanılır.
Dask
Dask, birden fazla işlemi aynı anda yürütmek için özel olarak tasarlanmıştır.
Dask, NumPy ve Pandas gibi yaygın veri bilimi kütüphanelerinin işlemlerini daha
hızlı hale getirebilir. Dask, paralel işlemler için thread ve süreçlerin yanı sıra,
dağıtık hesaplama için farklı araçlar da sunar. Dask'ın kullanımı, paralel
hesaplamaları kolaylaştırır ve kodun daha verimli çalışmasına olanak tanır.
Celery
Celery, Python için açık kaynaklı bir dağıtık kuyruk sistemidir. Celery, iş yükünü
paralel olarak işleyen dağıtık bir mimariye sahiptir. Celery, çok sayıda işi
yönetmek için bir kuyruk yapısı kullanır ve bir işin sonucu, başka bir işe
bağlanabilir. Bu, özellikle büyük ölçekli web uygulamalarında, asenkron işlemleri
yönetmek için kullanışlıdır.
Apache Spark
Apache Spark, açık kaynaklı bir büyük veri işleme platformudur. Apache Spark,
veri analizi ve büyük veri işleme için tasarlanmıştır ve Hadoop MapReduce
modeline dayalıdır. Spark, işlemleri hızlandırmak için birçok optimizasyon
teknikleri ve veri paralelleştirme teknikleri kullanır. Spark, Python, Java, Scala ve
R gibi farklı programlama dillerini destekler ve birçok farklı veri kaynağına
erişebilir.
Paralel ve dağıtık hesaplama, büyük veri işleme, yapay zeka, makine öğrenmesi
ve diğer yoğun hesaplama işleri için hayati önem taşır. Threadler, süreçler,
kuyruklar ve mesajlaşma, paralel hesaplama için kullanılan yaygın araçlardır.
Dask, Celery ve Apache Spark gibi kütüphaneler ve platformlar, Python için
paralel ve dağıtık hesaplama için kullanılabilir. Bu araçlar, verimlilik artırır,
hesaplama sürelerini kısaltır ve büyük ölçekli projelerde iş akışını kolaylaştırır.
Ayrıca, paralel ve dağıtık hesaplamanın kullanımı, büyük veri setlerinin, yoğun
hesaplamaların ve dağıtık sistemlerin yönetiminin gerektiği alanlarda önemlidir.
Bu teknikler, Python kullanıcılarına büyük veri işleme, veri analitiği, model
eğitimi ve çeşitli iş yüklerini hızlandırma gibi avantajlar sunar.
Threadler, Python'daki concurrent.futures ve threading modülleri gibi yerleşik
kütüphanelerle kullanılabilir. Threadler, aynı süreç içinde birden fazla görevi
aynı anda yürütmek için kullanılabilir ve paylaşılan belleğe erişebilirler. Bununla
birlikte, Python'daki Global Interpreter Lock (GIL) kısıtlamaları nedeniyle,
threadler, işlemci üzerinde gerçek paralel işlem yapamazlar ve performans
açısından sınırlamaları vardır.
Süreçler, Python'daki multiprocessing modülü ile kullanılabilir. Süreçler, her biri
kendi işlemci hafızası alanına sahip ayrı ayrı çalışan bağımsız işlemlerdir. Bu
nedenle, süreçler, threadlerden farklı olarak gerçek paralel işlem yapabilir ve
Python'daki GIL kısıtlamalarından bağımsızdır. Süreçler, çok çekirdekli
işlemcilerde büyük veri işleme ve yoğun hesaplamalar için kullanılabilir.
Kuyruklar, dağıtık hesaplama için kullanılan bir diğer yaygın yöntemdir. Kuyruk
tabanlı sistemlerde, işler kuyruğa eklenir ve farklı işçiler (işlemler veya
makinalar) tarafından işlenir. Kuyruklar, dağıtık sistemlerde iş yükünü
dengelemek ve paralel işlemleri yönetmek için kullanılır.
Mesajlaşma, dağıtık sistemlerde iletişim kurmak için kullanılan bir diğer
yöntemdir. Mesajlaşma, farklı bileşenlerin, işçilerin veya makinelerin
birbirleriyle iletişim kurmasını sağlar. Python'da RabbitMQ, Apache Kafka ve
ZeroMQ gibi mesajlaşma kütüphaneleri kullanılabilir.
Sonuç olarak, paralel ve dağıtık hesaplama teknikleri, Python kullanıcılarına
büyük veri işleme, yoğun hesaplamalar ve dağıtık sistemlerde iş yükünü
yönetme konusunda çeşitli avantajlar sunar. Threadler, süreçler, kuyruklar ve
mesajlaşma, Python için kullanılabilir araçlar arasında yer almaktadır ve
karmaşık hesaplamaların, veri analitiğinin ve model eğitiminin
hızlandırılmasında kullanılabilir.
Python ile veri analitiği: NumPy, pandas ve matplotlib gibi popüler veri
analitiği
kütüphaneleri
Python, veri analizi ve bilimsel hesaplama alanında çok popüler bir dil haline
gelmiştir. Bu alanda kullanılan kütüphaneler, NumPy, pandas ve matplotlib gibi
önde gelen araçlardır. Bu bölümde, bu kütüphaneleri ayrıntılı bir şekilde ele
alacağız.
NumPy
NumPy, Python'da bilimsel hesaplama ve veri analizi için kullanılan bir
kütüphanedir. NumPy, çok boyutlu diziler ve matrisler gibi yüksek performanslı
veri yapıları ve fonksiyonları içerir. NumPy, MATLAB'daki matris işleme
işlevselliğine benzer bir arayüze sahiptir.
NumPy'nin temel özellikleri şunlardır:
•
•
•
Çok boyutlu dizi nesneleri için verimli işlemler yapar.
Yaygın matematik fonksiyonları ve işlemleri içerir.
Veri analizi için yararlı olan rastgele sayı üretimi, Fourier dönüşümleri,
lineer cebir işlemleri ve diğer matematiksel işlevler de içerir.
Örnek bir NumPy kodu:
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)
Bu kod, iki NumPy dizisini toplar ve sonucu ekrana yazdırır.
pandas
pandas, veri analizi ve manipülasyonu için kullanılan bir Python kütüphanesidir.
pandas, veri analizi için çok sayıda veri yapıları ve işlevler sunar. Verileri içe
aktarma, sıralama, filtreleme, gruplama ve dönüştürme gibi çeşitli işlemler
yapabilirsiniz.
pandas'ın temel özellikleri şunlardır:
•
•
•
•
Yüksek performanslı veri analizi işlemleri yapar.
Veri okuma ve yazma işlemleri için birçok format desteği sunar.
Veri sıralama, filtreleme, dönüştürme ve gruplama işlemleri yapabilir.
Veri analizi sonuçlarını grafiklerle görselleştirmek için matplotlib ile
kolayca entegre edilebilir.
Örnek bir pandas kodu:
import pandas as pd
data = {'name': ['John', 'Mary', 'Tom'],
'age': [25, 30, 35],
'city': ['New York', 'Paris', 'London']}
df = pd.DataFrame(data)
print(df)
Bu kod, bir veri çerçevesi oluşturur ve ekrana yazdırır.
matplotlib
matplotlib, veri görselleştirme için kullanılan bir Python kütüphanesidir.
matplotlib, çizgi grafikleri, dağılım grafikleri, histogramlar, bar grafikleri, yüzey
grafikleri ve daha fazlasını oluşturmak için kullanılabilir.
matplotlib'in temel özellikleri şunlardır:
•
Çeşitli grafik türleri: matplotlib, birçok grafik türü oluşturma yeteneği
sağlar. Bu grafikler arasında çizgi grafikleri, bar grafikleri, pasta grafikleri,
dağılım grafikleri, kontur grafikleri, polar grafikler, yüzey grafikleri ve
daha birçok grafik türü bulunur.
•
Özelleştirme: matplotlib, grafiklerinizi özelleştirmenize olanak tanır.
Grafiklerin rengini, fontunu, boyutunu ve daha birçok özelliğini kontrol
edebilirsiniz. Grafiklerinizi istediğiniz gibi stilize edebilirsiniz.
•
Kolay kullanım: matplotlib, kullanımı kolay bir API sunar. Grafiklerinizi
hızlı ve kolay bir şekilde oluşturabilirsiniz. Basit bir çizgi grafiğinin
oluşturulması için sadece birkaç satır kod yazmanız yeterli olabilir.
•
Çoklu platform desteği: matplotlib, Windows, macOS ve Linux gibi birçok
işletim sistemi üzerinde çalışır. Ayrıca, Jupyter Notebook, IPython ve
Spyder gibi birçok entegre geliştirme ortamında da kullanılabilir.
•
Veri entegrasyonu: matplotlib, NumPy, pandas ve diğer birçok Python
veri analizi kütüphanesiyle uyumludur. Bu, verilerinizi kolayca grafiklere
dönüştürebileceğiniz anlamına gelir.
•
Interaktif grafikler: matplotlib'in interaktif modu sayesinde grafiklerinizi
interaktif hale getirebilirsiniz. Kullanıcıların grafikleri etkileşimli bir
şekilde keşfetmesine olanak tanıyan interaktif grafikler oluşturabilirsiniz.
•
Genişletilebilirlik: matplotlib, kullanıcıların kendi özel grafik türlerini ve
özelliklerini oluşturmalarına olanak tanır. Ayrıca, matplotlib'in çeşitli
eklentileri ve üçüncü taraf paketleri de mevcuttur.
Bu özellikler sayesinde, matplotlib, veri analitiği için popüler bir seçim haline
gelmiştir ve birçok araştırmacı, mühendis ve veri analisti tarafından
kullanılmaktadır.
Matplotlib kod örneği:
Tablo grafikleri oluşturmak için matplotlib kullanarak bir örnek yazalım:
import matplotlib.pyplot as plt
# Veri setimiz
dersler = ['Matematik', 'Fizik', 'Kimya', 'Biyoloji']
ogrenci_sayisi = [50, 30, 70, 45]
# Grafik oluşturma
fig, ax = plt.subplots()
# Çubuk grafik oluşturma
ax.bar(dersler, ogrenci_sayisi)
# Eksen etiketlerini ayarlama
ax.set_xlabel('Dersler')
ax.set_ylabel('Öğrenci Sayısı')
ax.set_title('Derslere Göre Öğrenci Sayısı')
# Grafiği gösterme
plt.show()
Bu örnekte, dört ders için öğrenci sayısını içeren bir veri setimiz var.
plt.subplots() kullanarak bir figür ve eksen objesi oluşturuyoruz. ax.bar()
yöntemi ile, her ders için bir çubuk grafik oluşturuyoruz. ax.set_xlabel(),
ax.set_ylabel() ve ax.set_title() ile eksen etiketlerini ve başlığı ayarlıyoruz.
plt.show() çağrısı, grafiği görüntülemek için kullanılır.
Matplotlib, farklı grafik türleri oluşturmanıza izin verir. Bazı temel grafik türleri
şunlardır:
Çizgi grafiği: Verilerin zamana veya diğer değişkenlere göre nasıl değiştiğini
göstermek için kullanılır.
Scatter plot: İki değişken arasındaki ilişkiyi göstermek için kullanılır.
Bar plot: Kategorik verileri göstermek için kullanılır. Örneğin, bir ürünün
satışlarının farklı bölgelerdeki performansını göstermek için kullanılabilir.
Histogram: Verilerin dağılımını göstermek için kullanılır.
Box plot: Verilerin dağılımını göstermek için kullanılır. Ortalama, medyan ve
çeyrekler gibi istatistiksel özellikleri gösterir.
Matplotlib ayrıca, grafiklerin boyutu, renkleri, etiketleri ve diğer özellikleri gibi
birçok özelleştirme seçeneği sunar. Ayrıca, birden fazla grafiği tek bir görüntüde
birleştirmek veya farklı grafikleri bir arada göstermek için alt grafikler
oluşturmanıza izin verir.
Pandas ise, veri manipülasyonu ve analizi için kullanılan bir kütüphanedir.
Pandas, verileri okumanızı, yazmanızı, temizlemenizi ve filtrelemenizi sağlar.
Ayrıca, verileri birleştirmek, gruplamak ve istatistiksel hesaplamalar yapmak
gibi işlemler yapmanızı da sağlar.
Pandas, iki ana veri yapısı olan Series ve DataFrame'i kullanır. Series, tek boyutlu
etiketlenmiş bir veri dizisidir. DataFrame, iki boyutlu bir veri yapısıdır ve satırlar
ve sütunlar şeklinde etiketlenmiş verileri içerir.
NumPy ise, bilimsel hesaplama için kullanılan bir kütüphanedir. NumPy, çok
boyutlu diziler ve matrisler üzerinde işlem yapmak için kullanılır. NumPy,
matematiksel, mantıksal, şekil ve sıralama gibi işlemleri yapmanıza izin verir.
Ayrıca, rastgele sayılar üretmek veya Fourier dönüşümleri yapmak gibi diğer
matematiksel işlemler için de kullanılabilir. Pandas ve Matplotlib gibi diğer
kütüphanelerle birlikte kullanılarak, veri analitiği için güçlü bir araç seti sunar.
Numpy, veriler üzerinde hızlı ve etkili hesaplama yapmak için tasarlanmış bir
kütüphanedir. Numpy'nin ana veri yapısı, çok boyutlu dizilerdir. Numpy dizileri,
tek tip veri tiplerini içerir ve bu sayede hızlı ve bellek açısından verimlidirler. Bu
özellikleri sayesinde, Numpy, veri analitiği, bilimsel hesaplama, makine
öğrenmesi ve diğer pek çok alanda yaygın olarak kullanılmaktadır.
Pandas, verileri işlemek ve analiz etmek için kullanılan bir Python
kütüphanesidir. Pandas, iki ana veri yapısı olan Seriler ve DataFrame'ler kullanır.
Seriler, tek boyutlu etiketli bir dizi olarak tanımlanırken, DataFrame'ler, iki
boyutlu bir tablo olarak tanımlanır ve sütunları ve satırları olan bir yapıya
sahiptir. Pandas, veri işleme, veri temizleme, veri dönüştürme, veri birleştirme
ve veri analizi gibi işlemleri kolaylaştırır.
Matplotlib, verileri grafikler, çizimler ve görselleştirmelerle sunmak için
kullanılan bir Python kütüphanesidir. Matplotlib, bar grafikleri, dağılım
grafikleri, çizgi grafikleri, pasta grafikleri, 3D grafikler ve diğer birçok grafik türü
oluşturmak için kullanılabilir. Matplotlib, Python programlarına görsel öğeler
eklemek için de sıklıkla kullanılır.
Bu kütüphaneler, birlikte kullanıldığında, Python ile veri analitiği yapmak için
güçlü bir araç seti sağlarlar. NumPy, verilerin yüksek hızda hesaplanmasına ve
manipüle edilmesine olanak tanırken, pandas verilerin organize edilmesini,
temizlenmesini ve analiz edilmesini kolaylaştırır. Matplotlib, verilerin
görselleştirilmesini ve sunumunu kolaylaştırır ve sonuçları daha anlaşılır hale
getirir.
Sonuç olarak, NumPy, pandas ve Matplotlib gibi popüler veri analitiği
kütüphaneleri, Python dilinin gücünü kullanarak veri analitiği ve veri bilimi
alanlarında etkili çözümler sunar. NumPy, hızlı ve etkili hesaplamalar için çok
boyutlu dizilere olanak tanırken, pandas, veri işleme, temizleme, dönüştürme ve
analiz için kullanıcı dostu bir arayüz sunar. Matplotlib ise verileri görsel olarak
anlaşılır hale getirerek, sonuçların sunumunu kolaylaştırır. Bu kütüphaneler,
Python kullanıcılarına veri analitiği ve veri bilimi projelerinde güçlü bir araç seti
sağlar ve Python'u yaygın olarak tercih edilen bir dil haline getirir.
Bölüm 6: Python ile Uygulama Geliştirme
Python, son yıllarda hızlı bir şekilde popüler hale gelen bir programlama dili
haline geldi. Sadece web uygulamaları geliştirmekle sınırlı kalmayıp, masaüstü
uygulamaları ve mobil uygulamalar da dahil olmak üzere birçok alanda
kullanılıyor. Bu nedenle, Python'u öğrenmek, modern yazılım geliştirme
dünyasında gerekli bir beceri haline geldi.
Bu bölümde, Python ile uygulama geliştirme konusuna odaklanacağız. İlk olarak,
PyQt5 ve Tkinter gibi popüler araçları kullanarak masaüstü uygulamaları nasıl
geliştirebileceğinizi öğreneceksiniz. Daha sonra, Flask, Bottle ve CherryPy gibi
web çerçeveleri kullanarak web uygulamaları geliştirmeyi ve son olarak, Kivy
kullanarak mobil uygulamalar geliştirmeyi öğreneceksiniz.
Her bir aracın kullanımını örneklerle açıklayarak, konuları adım adım ele
alacağız. Bu bölüm, Python'u öğrenmek isteyen ve modern yazılım geliştirme
dünyasında yer almak isteyen herkes için faydalı olacaktır.
Masaüstü Uygulamaları Geliştirme
Python uygulama geliştirme yöntemlerinden birisi de masaüstü uygulamaları
geliştirmektir. Masaüstü uygulamaları, kullanıcıların bilgisayarlarında çalışan ve
web tabanlı uygulamaların aksine internet bağlantısına ihtiyaç duymayan
uygulamalardır.
Python ile masaüstü uygulama geliştirme için birkaç seçenek vardır. En popüler
olanları PyQt, wxPython ve tkinter'dir. Bu kütüphaneler, çeşitli arayüz öğeleri
(pencere, düğme, menü, liste kutusu vb.) sağlar ve bu öğeleri kullanarak kullanıcı
arayüzü tasarlanabilir.
Örneğin GUI programlama ile ilgili bir örnek verebilirim. Örneğin, PyQt5
kütüphanesi kullanarak basit bir hesap makinesi uygulaması yapabiliriz.
İlk adım olarak, PyQt5'ı yüklememiz gerekiyor. Eğer yüklü değilse, aşağıdaki
komutu kullanarak PyQt5'ı yükleyebilirsiniz:
pip install PyQt5
Ardından, aşağıdaki kodu yazarak basit bir hesap makinesi oluşturabiliriz:
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout,
QHBoxLayout, QPushButton, QLineEdit, QLabel
class Calculator(QWidget):
def _init_(self):
super()._init_()
self.initUI()
def initUI(self):
# Sayılar için QLineEdit widgetları oluşturuyoruz.
self.num1 = QLineEdit(self)
self.num2 = QLineEdit(self)
# Toplama ve Çıkarma işlemleri için QPushButton widgetları oluşturuyoruz.
self.add_btn = QPushButton('+', self)
self.sub_btn = QPushButton('-', self)
# Sonuçları göstereceğimiz QLabel widgetı oluşturuyoruz.
self.result = QLabel(self)
# Vertical Box Layout oluşturuyoruz.
vbox = QVBoxLayout()
# Horizontal Box Layout oluşturuyoruz.
hbox1 = QHBoxLayout()
hbox2 = QHBoxLayout()
# Horizontal Box Layoutlar içinde QLineEdit ve QPushButton widgetlarını
ekliyoruz.
hbox1.addWidget(self.num1)
hbox1.addWidget(self.num2)
hbox2.addWidget(self.add_btn)
hbox2.addWidget(self.sub_btn)
# Vertical Box Layout'a Horizontal Box Layoutları ekliyoruz.
vbox.addLayout(hbox1)
vbox.addLayout(hbox2)
# Sonuç QLabel'ını Vertical Box Layout'a ekliyoruz.
vbox.addWidget(self.result)
# Widget'ımız için Vertical Box Layout'u set ediyoruz.
self.setLayout(vbox)
# PushButton'ların tıklama eventlerine fonksiyonlarımızı bağlıyoruz.
self.add_btn.clicked.connect(self.addition)
self.sub_btn.clicked.connect(self.subtraction)
# Widget ayarları.
self.setGeometry(300, 300, 300, 150)
self.setWindowTitle('Calculator')
self.show()
def addition(self):
try:
num1 = int(self.num1.text())
num2 = int(self.num2.text())
result = num1 + num2
self.result.setText(f"Result: {result}")
except:
self.result.setText("Invalid Input")
def subtraction(self):
try:
num1 = int(self.num1.text())
num2 = int(self.num2.text())
result = num1 - num2
self.result.setText(f"Result: {result}")
except:
self.result.setText("Invalid Input")
if _name_ == '_main_':
app = QApplication(sys.argv)
calc = Calculator()
sys.exit(app.exec_())
Bu kod, basit bir hesap makinesi oluşturmak için PyQt5 kütüphanesini kullanır.
Uygulama, iki sayı girmek için QLineEdit widgetları, toplama ve çıkarma için
QPushButton widgetları ve sonucu göstermek için QLabel widgetı gösterir:
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit,
QPushButton, QVBoxLayout
class Calculator(QWidget):
def _init_(self):
super()._init_()
# Arayüz elemanlarını tanımla
self.first_number = QLineEdit()
self.second_number = QLineEdit()
self.add_button = QPushButton("Topla")
self.subtract_button = QPushButton("Çıkar")
self.result_label = QLabel()
# Layout tanımla
layout = QVBoxLayout()
layout.addWidget(self.first_number)
layout.addWidget(self.second_number)
layout.addWidget(self.add_button)
layout.addWidget(self.subtract_button)
layout.addWidget(self.result_label)
self.setLayout(layout)
# Sinyal bağlantılarını tanımla
self.add_button.clicked.connect(self.add)
self.subtract_button.clicked.connect(self.subtract)
def add(self):
# Toplama işlemini yap
try:
num1 = float(self.first_number.text())
num2 = float(self.second_number.text())
result = num1 + num2
self.result_label.setText(f"Sonuç: {result}")
except ValueError:
self.result_label.setText("Lütfen sayı girin")
def subtract(self):
# Çıkarma işlemini yap
try:
num1 = float(self.first_number.text())
num2 = float(self.second_number.text())
result = num1 - num2
self.result_label.setText(f"Sonuç: {result}")
except ValueError:
self.result_label.setText("Lütfen sayı girin")
if _name_ == "_main_":
# Uygulamayı başlat
app = QApplication(sys.argv)
calculator = Calculator()
calculator.show()
sys.exit(app.exec_())
Bu kod, PyQt5 kütüphanesi kullanarak basit bir hesap makinesi oluşturur.
Kullanıcılar, iki sayıyı QLineEdit widget'larına girebilir ve toplama veya çıkarma
işlemini yapmak için ilgili QPushButton widget'ını tıklayabilir. Sonuç, QLabel
widget'ı kullanılarak gösterilir.
Ayrıca, bu hesap makinesi uygulaması, PyQt5'in sinyal ve slot mekanizmasını
kullanarak butonlara tıklama gibi olayları yakalar ve sonucu QLabel widgetına
yazdırır.
Örneğin, toplama işlemi yapmak için "Toplama" düğmesine tıkladığımızda,
"clicked" sinyali "calculate" adlı bir işlevi tetikler. Bu işlev, QLineEdit
widgetlarından sayıları alır, toplama işlemini yapar ve sonucu QLabel widgetına
yazar.
Bu hesap makinesi örneği, PyQt5 kullanarak basit bir masaüstü uygulaması
geliştirmek için temel bir şablon sunar. Bu şablonu kullanarak daha karmaşık
hesaplamalar veya farklı arayüz öğeleri ekleyebilirsiniz.
QPushButton'lar üzerinde tıklama olaylarına bağlı olarak işlevler tanımlanmıştır.
Toplama işlemini gerçekleştiren topla() işlevi ve çıkarma işlemini gerçekleştiren
cikar() işlevi, girdilerin alınması ve sonucun QLabel'da gösterilmesi için
tanımlanmıştır. Bu işlevler, matematiksel işlemlerin yapılması için basit bir yapı
sağlar.
Bu örnek, PyQt5'in temel özelliklerinden birkaçını gösterir. PyQt5, masaüstü
uygulamaları geliştirmek için çok sayıda widget sağlar ve bunların
birleştirilmesiyle daha karmaşık arayüzler oluşturabilirsiniz. Widget'lar,
kullanıcının etkileşimde bulunabileceği nesnelerdir ve geniş bir yelpazede
kullanılabilirler. PyQt5 ayrıca, widget'lar üzerinde olaylara bağlı olarak işlevler
tanımlamak için bir sinyal ve slot mekanizması sağlar. Bu mekanizma,
kullanıcının widget'lar üzerinde etkileşimde bulunduğunda ne yapılacağını
belirlemenize olanak tanır.
Masaüstü uygulamaları, PyQt5 gibi araçlar kullanarak oluşturulabilir. Bu tür
uygulamalar, özellikle işletme yazılımı veya masaüstü uygulamalarında kullanıcı
etkileşimini sağlamak için kullanışlıdır.
Bu bölümde, Python programlama dilinde uygulama geliştirme konularına
odaklandık. Masaüstü uygulama geliştirme için PyQt5 kütüphanesini ve bir
hesap makinesi uygulaması örneğini inceledik. Ayrıca web uygulamaları
geliştirme konusunda Flask, Bottle ve CherryPy gibi Python mikro çerçevelerini
ele aldık. Flask ile bir "Kelime Sayacı" uygulaması örneği de sunduk.
Uygulama geliştirme konusunda, Python ile birçok farklı türde uygulama
geliştirilebileceğini gördük. PyQt5 ve Flask gibi kütüphaneler, farklı
gereksinimler için kullanılabilecek kullanışlı araçlardır. Bu bölümde verilen
örnekler, uygulama geliştirme konusunda iyi bir başlangıç noktası olabilir ve
uygulama geliştirme konusunda daha fazla bilgi edinmek isteyenlere yol
gösterici olabilir.
PyQt5, Qt kütüphanesinin Python için bir arayüzüdür ve Qt Creator gibi bir
arayüz oluşturma aracı kullanarak daha karmaşık arayüzler oluşturmak
mümkündür. Bu örnek, PyQt5 kullanımına temel bir giriş yapmak için
tasarlanmıştır.
Web Uygulamaları Geliştirme
Python, web uygulamaları geliştirmek için yaygın olarak kullanılan bir dildir.
Python ile web uygulamaları geliştirmek için birçok araç ve çerçeve
bulunmaktadır. Bu araçlar ve çerçeveler, web uygulamalarını hızlı bir şekilde
geliştirmek için hazır yapılar ve fonksiyonlar sağlar.
Python ile web uygulamaları geliştirmek için en popüler araçlar ve çerçeveler
şunlardır:
•
•
Django
Flask
•
•
•
Pyramid
Bottle
CherryPy
Bu araçlar ve çerçeveler, web uygulamaları geliştirirken kullanabileceğiniz
birçok özellik ve işlevsellik sunarlar. Bu özellikler ve işlevsellikler şunları
içerebilir:
•
•
•
•
•
•
•
Veritabanı yönetimi
Şablon sistemleri
Oturum yönetimi
URL yönlendirme
Form yönetimi
API desteği
Django
Django
Python ile web uygulamaları geliştirmek için en popüler çerçevelerdendir.
Django, veritabanı yönetimi, oturum yönetimi, URL yönlendirme, form yönetimi
ve şablon sistemleri gibi birçok özelliği içerir.
Django, bir MVC (Model-View-Controller) mimarisine dayanır. Bu mimari, web
uygulamalarının farklı katmanlarının ayrılmasına olanak sağlar. Bu sayede,
uygulamanın farklı bölümlerinde yapılan değişikliklerin diğer bölümleri
etkilemesi engellenir.
Flask
Flask, Python ile web uygulamaları geliştirmek için hafif ve esnek bir çerçevedir.
Flask, temel olarak bir mikro çerçevedir. Bu da, Flask'ın diğer çerçevelere göre
daha az özellik sunmasına rağmen, daha az karmaşık ve daha hızlı bir uygulama
geliştirme süreci sunmasını sağlar.
Flask, birçok özellik sunan eklentileri ile genişletilebilir. Bu eklentiler, veritabanı
yönetimi, form yönetimi, oturum yönetimi ve diğer özellikleri içerebilir.
Pyramid
Pyramid, Python ile web uygulamaları geliştirmek için bir çerçevedir. Pyramid,
esnek bir çerçeve olmasının yanı sıra, büyük ölçekli web uygulamaları için uygun
bir seçenektir. Pyramid, veritabanı yönetimi, URL yönlendirme, oturum yönetimi,
form yönetimi ve diğer özellikleri içerir.
Bottle
Bottle, Python ile web uygulamaları geliştirmek için kullanılan basit bir
çerçevedir. Flask gibi bir mikro çerçeve olarak kullanılabilir. Bottle, tek dosyadan
oluşur ve küçük ölçekli projeler için idealdir. Flask'tan daha az özellik sunar
ancak daha hızlı ve hafiftir.
Cherypy
CherryPy, Python ile web uygulamaları geliştirmek için bir çerçevedir. Basit ve
esnek bir yapıya sahiptir ve yüksek performans sunar. CherryPy, ölçeklenebilir
ve güvenilir web uygulamaları geliştirmek için kullanılabilir.
Web uygulamaları geliştirme, Python programlama dilinde oldukça popülerdir.
Flask, Django ve Pyramid gibi Python web çerçeveleri, web uygulamaları
geliştirme işlemini kolaylaştırmak için kullanılır. Bu çerçeveler, web
uygulamasının oluşturulması için temel bir yapı sağlar ve HTTP istekleri,
veritabanı bağlantıları, şablon motorları, form işleme, kimlik doğrulama ve daha
pek çok işlemi kolaylaştırır.
Örneğin, bir web uygulaması oluşturabiliriz ki bu uygulama, kullanıcının girdiği
bir metnin içindeki kelime sayısını sayar ve sonucu gösterir. Bu uygulama Flask
web framework kullanılarak oluşturulabilir.
İlk önce Flask kurulumunu yaparak başlayabiliriz. Aşağıdaki komutu kullanarak
Flask'ı yükleyebiliriz:
pip install Flask
Ardından, Flask uygulamamızın ana dosyasını oluşturalım. Bu dosyanın adını
app.py olarak belirleyelim. Şimdi, Flask'ın Flask sınıfından bir nesne oluşturalım
ve bu nesne üzerinden bir route (yönlendirme) tanımlayalım. Bu örnekte, ana
sayfamızı temsil eden / adresine yönlendireceğiz ve burada kullanıcının bir
metin girmesi için bir form oluşturacağız.
from flask import Flask, request, render_template
app = Flask(_name_)
@app.route('/', methods=['GET', 'POST'])
def index():
if request.method == 'POST':
text = request.form['text']
words = text.split()
word_count = len(words)
return render_template('index.html', word_count=word_count)
else:
return render_template('index.html')
Burada, Flask sınıfından bir nesne oluşturduk ve @app.route decorator'ı ile bir
yönlendirme belirttik. Bu yönlendirmede, hem GET hem de POST yöntemleri
kullanılabilir. index() fonksiyonu, bir GET isteği gönderildiğinde, index.html
dosyasının render edilmesini sağlar. POST yöntemi kullanıldığında, kullanıcının
gönderdiği formdaki metin alınır, kelimelere ayrılır ve kelime sayısı hesaplanır.
Sonrasında, index.html dosyasında word_count değişkeni kullanılarak sonucun
gösterilmesi sağlanır.
Son olarak, templates klasörü altında index.html adında bir dosya oluşturacağız.
Bu dosyada, kullanıcıdan metin girmesi istenir ve metnin içindeki kelime sayısı
gösterilir.
<!DOCTYPE html>
<html>
<head>
<title>Word Count</title>
</head>
<body>
<h1>Word Count</h1>
<form method="POST">
<label for="text">Enter some text:</label><br>
<textarea name="text" id="text" cols="30" rows="10"></textarea><br>
<input type="submit" value="Count Words">
</form>
{% if word_count is defined %}
<p>There are {{ word_count }} words in the text.</p>
{% endif %}
</body>
</html>
Bu HTML dosyası, kullanıcının metin girmesi için bir form oluşturur ve
wordcount.py dosyasında, Flask kütüphanesinden Flask sınıfını import ederiz ve
uygulamamızı oluşturmak için app adlı bir Flask nesnesi oluştururuz.
from flask import Flask
app = Flask(_name_)
Daha sonra, form verilerini alacak ve kelime sayısını hesaplayacak olan
count_words adlı bir fonksiyon tanımlarız.
def count_words(text):
words = text.split()
count = len(words)
return count
Bu fonksiyon, gelen metni boşluk karakterine göre ayırarak kelime sayısını
hesaplar.
Sonra, kullanıcının metin girebileceği bir form oluşturmak için Flask'in
@app.route dekoratörünü kullanarak index adlı bir route oluştururuz.
@app.route('/')
def index():
return '''
<form method="POST">
<label for="text">Enter text:</label><br>
<input type="text" id="text" name="text"><br>
<button type="submit">Count words</button>
</form>
'''
Bu HTML formu, method="POST" ile sunucuya verilerin post edileceğini belirtir.
<label> etiketi, kullanıcının metin girmesi için bir alanı tanımlar ve name="text"
ile bu alanın adını text olarak belirleriz.
Formun yanındaki "Count words" butonuna tıkladığımızda, form verileri
sunucuya gönderilir ve bu verileri alacak bir POST route'u oluştururuz.
@app.route('/', methods=['POST'])
def count():
text = request.form['text']
count = count_words(text)
return f'Text "{text}" contains {count} words.'
Bu route, formdan gelen metni alır ve count_words() fonksiyonunu kullanarak
kelime sayısını hesaplar. Sonuç olarak, kullanıcıya formdaki metnin kaç kelime
içerdiği gösterilir.
Son olarak, Flask uygulamasını çalıştırmak için if _name_ == '_main_': bloğunu
kullanırız.
if _name_ == '_main_':
app.run()
Böylece, app.py dosyası aşağıdaki gibi görünebilir:
from flask import Flask, request
app = Flask(_name_)
def count_words(text):
words = text.split()
count = len(words)
return count
@app.route('/')
def index():
return '''
<form method="POST">
<label for="text">Enter text:</label><br>
<input type="text" id="text" name="text"><br>
<button type="submit">Count words</button>
</form>
'''
@app.route('/', methods=['POST'])
def count():
text = request.form['text']
count = count_words(text)
return f'Text "{text}" contains {count} words.'
if _name_ == '_main_':
app.run()
Bu Flask uygulaması, kullanıcının metin girmesi için bir form sunar ve girilen
metnin kelime sayısını hesaplar. Bu örnekte, templates klasörü içinde index.html
adlı bir HTML dosyası ve ana uygulama dosyası olan app.py kullanılmaktadır.
index.html dosyası şöyle görünebilir:
<!doctype html>
<html>
<head>
<title>Kelime Sayacı</title>
</head>
<body>
<h1>Kelime Sayacı</h1>
<form action="/" method="POST">
<input type="text" name="text" required>
<input type="submit" value="Hesapla">
</form>
{% if word_count %}
<p>Girilen metinde {{ word_count }} kelime var.</p>
{% endif %}
</body>
</html>
Bu dosya, kullanıcının metin girmesi için bir form oluşturur. action özelliği,
formun sunucuya gönderildiğinde nereye yönlendirileceğini belirtir. method
özelliği, form verilerinin sunucuya nasıl gönderileceğini belirler. Bu örnekte,
POST yöntemi kullanılmaktadır.
app.py dosyası şöyle görünebilir:
from flask import Flask, render_template, request
app = Flask(_name_)
@app.route("/", methods=["GET", "POST"])
def word_count():
if request.method == "POST":
text = request.form["text"]
words = text.split()
return render_template("index.html", word_count=len(words))
else:
return render_template("index.html")
Bu dosya, Flask uygulamasının ana dosyasıdır. @app.route dekoratörü,
kullanıcının uygulamaya hangi URL ile erişeceğini belirler. Bu örnekte, kök dizine
(/) erişim izin verilir.
word_count fonksiyonu, form verilerini alır ve girilen metnin kelime sayısını
hesaplar. Eğer form verileri POST yöntemiyle sunucuya gönderilmişse, text
değişkeni formdaki text alanından alınır ve split() metodu kullanılarak kelime
listesine dönüştürülür. len() fonksiyonu, kelime sayısını hesaplar ve
render_template() fonksiyonuyla index.html dosyasına kelime sayısı bilgisi
gönderilir. Eğer form verileri GET yöntemiyle sunucuya gönderilmişse, sadece
index.html dosyası gösterilir.
Bu Flask uygulaması, bir web tarayıcısında çalıştırılabilir ve kullanıcıların metin
girmesi ve kelime sayısını hesaplaması için kullanılabilir. Bu örnek, Flask'ın basit
bir kullanımını göstermektedir ve daha karmaşık uygulamalar geliştirilebilir.
Mobil Uygulamaları Geliştirme
Android mobil uygulama geliştirme için Kotlin veya Java programlama dilleri
kullanılabilir. Kotlin, daha yeni bir dil olmasına rağmen, hızlı ve kullanımı
kolaydır. Bu örnekte, Kotlin dili kullanılarak bir not defteri uygulaması
oluşturulacak.
Uygulamamız, kullanıcının metin girmesi ve kaydetmesi için bir EditText bileşeni
ve kaydedilen notları göstermek için bir ListView bileşeni içerecek. Ayrıca,
kullanıcının bir notu düzenlemesi veya silmesi için düzenleme ve silme işlevleri
de mevcut olacak.
İlk olarak, Android Studio'yu açın ve yeni bir proje oluşturun. Proje adını ve
proje konumunu belirleyin ve "Empty Activity" seçeneğini seçin.
Not defterimiz için arayüzümüzü tasarlayacağız. activity_main.xml dosyasını açın
ve bir EditText ve bir ListView bileşeni ekleyin. EditText, kullanıcının metin
girmesi için kullanılacak ve ListView, kaydedilen notların listesi için kullanılacak.
activity_main.xml dosyasındaki kod şu şekilde olacaktır:
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<EditText
android:id="@+id/editText"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:hint="Enter your note"/>
<ListView
android:id="@+id/listView"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
</LinearLayout>
Daha sonra, Kotlin koduyla EditText ve ListView bileşenlerine erişebilir ve
işlevselliği ekleyebiliriz. MainActivity.kt dosyasını açın ve aşağıdaki kodu
ekleyin:
package com.example.notepad
import android.os.Bundle
import android.view.View
import android.widget.AdapterView
import android.widget.ArrayAdapter
import android.widget.EditText
import android.widget.ListView
import androidx.appcompat.app.AppCompatActivity
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val editText = findViewById<EditText>(R.id.editText)
val listView = findViewById<ListView>(R.id.listView)
val notes = ArrayList<String>()
val adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, notes)
listView.adapter = adapter
listView.onItemLongClickListener = object :
AdapterView.OnItemLongClickListener {
override fun onItemLongClick(parent: AdapterView<*>, view: View,
position: Int, id: Long): Boolean {
notes.removeAt(position)
adapter.notifyDataSetChanged()
return true
}
}
fun addNote() {
val note = editText.text.toString()
if (note.isNotEmpty()) {
notes.add(note)
adapter.notifyDataSetChanged()
editText.text.clear()
}
}
editText.setOnKeyListener { _, keyCode, event ->
if (keyCode == android.view.KeyEvent.KEYCODE_ENTER && event.action
== android.view.KeyEvent.ACTION_UP) {
addNote()
}
true
}
}
}
Bu kod, Android Studio kullanılarak Java programlama dili ile yazılmış basit bir
not defteri uygulamasıdır. Uygulama, onCreate () yöntemini kullanarak EditText
ve ListView bileşenlerine erişir ve notlar için bir ArrayList oluşturur. Kullanıcı
not eklediğinde, bu not ArrayList'e eklenir ve ListView bileşeni üzerinde
görüntülenir. Ayrıca, kullanıcının notu silmesi için her listedeki öğenin yanında
bir "sil" düğmesi de yer alır.
public class MainActivity extends AppCompatActivity {
private EditText editText;
private Button addButton;
private ListView listView;
private ArrayList<String> notes = new ArrayList<String>();
private ArrayAdapter<String> adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
editText = (EditText) findViewById(R.id.editText);
addButton = (Button) findViewById(R.id.addButton);
listView = (ListView) findViewById(R.id.listView);
adapter = new ArrayAdapter<String>(this,
android.R.layout.simple_list_item_1, notes);
listView.setAdapter(adapter);
addButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String note = editText.getText().toString();
if (note.length() > 0) {
notes.add(note);
adapter.notifyDataSetChanged();
editText.setText("");
}
}
});
listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position,
long id) {
notes.remove(position);
adapter.notifyDataSetChanged();
}
});
}
}
Bu kodda, onCreate () yöntemi, aktivite oluşturulduğunda yürütülen ilk
yöntemdir. Bu yöntem içinde, EditText, ListView ve Button bileşenleri için
örnekler oluşturulur ve ArrayList değişkeni tanımlanır. ListView bileşeni için
ArrayAdapter örneği de oluşturulur ve listeye notları eklemek için kullanılır.
addButton'a tıklanarak not eklendiğinde, editText bileşeninden not alınır ve
notes ArrayList'ine eklenir. Daha sonra, adapter üzerinden not listesinin
güncellenmesi ve editText bileşeninin sıfırlanması sağlanır.
listView bileşenindeki bir not öğesi silindiğinde,
AdapterView.OnItemClickListener kullanılır. Bu olay tıklanan öğenin konumunu
belirler ve notlar ArrayList'den kaldırılır. Daha sonra adapter kullanılarak
ListView'deki listede değişiklikler yapılır.
Bu örnek, Android Studio ile Java kullanarak basit bir mobil uygulama
geliştirmenin temellerini göstermektedir.
ListView bileşenindeki öğelerin seçilmesi durumunda, öğenin değerini Toast
mesajı olarak gösteren bir onItemClick() metodu tanımlanır. Ayrıca, EditText
bileşenindeki metnin bir diziye eklenmesi ve ListView bileşeninde
görüntülenmesi için bir onClick() yöntemi de tanımlanmıştır.
MainActivity.java dosyası şöyle olacaktır:
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Toast;
import androidx.appcompat.app.AppCompatActivity;
import java.util.ArrayList;
public class MainActivity extends AppCompatActivity {
ArrayList<String> items;
ArrayAdapter<String> itemsAdapter;
ListView lvItems;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
lvItems = findViewById(R.id.lvItems);
items = new ArrayList<>();
itemsAdapter = new ArrayAdapter<>(this,
android.R.layout.simple_list_item_1, items);
lvItems.setAdapter(itemsAdapter);
lvItems.setOnItemClickListener((parent, view, position, id) -> {
String item = items.get(position);
Toast.makeText(getApplicationContext(), item,
Toast.LENGTH_SHORT).show();
});
}
public void addItem(View v) {
EditText etNewItem = findViewById(R.id.etNewItem);
String itemText = etNewItem.getText().toString();
itemsAdapter.add(itemText);
etNewItem.setText("");
}
}
activity_main.xml dosyası da şöyle olacaktır:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<EditText
android:id="@+id/etNewItem"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_alignParentTop="true"
android:hint="Add an item"
android:padding="16dp" />
<Button
android:id="@+id/btnAdd"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/etNewItem"
android:layout_centerHorizontal="true"
android:layout_marginTop="16dp"
android:text="Add"
android:onClick="addItem"/>
<ListView
android:id="@+id/lvItems"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@id/btnAdd"
android:layout_marginTop="16dp" />
</RelativeLayout>
Bu örnek, basit bir liste uygulaması oluşturmanın nasıl yapılabileceğini
göstermektedir. Bu temel örneği, farklı veritabanları veya diğer bileşenlerle
birleştirerek daha gelişmiş uygulamalar oluşturmak mümkündür.
Bu örnekte, Android Studio kullanarak basit bir not defteri uygulaması
oluşturduk. Uygulama, kullanıcının notları girmesi ve kaydetmesine, daha önce
kaydedilmiş notları görüntülemesine ve silmesine olanak tanır. Bu örnek, mobil
uygulama geliştirme için temel bir anlayış sağlar ve Android Studio ile nasıl
uygulama oluşturulacağını gösterir.
Mobil uygulama geliştirme, günümüzde giderek önem kazanan bir alan haline
gelmiştir. İnsanların akıllı telefonlarını ve tabletlerini kullanma sıklığı arttıkça,
mobil uygulamaların da yaygınlaşması kaçınılmaz olmuştur. Python gibi
programlama dilleri, mobil uygulama geliştirme için de kullanılabilir olsa da, Java
ve Kotlin gibi diller Android uygulamalarının geliştirilmesi için daha yaygın
olarak kullanılmaktadır.
Bu kitap boyunca Python programlama dilinin temel yapı taşlarına değindik ve
çeşitli uygulama alanlarına örnekler vererek konuları pekiştirmeye çalıştık.
Kitabımızın ilk bölümlerinde Python temellerine odaklanarak dilin yapısı,
değişkenler, işleçler, koşullar, döngüler, fonksiyonlar ve modüller gibi temel
konularını ele aldık.
Daha sonra, veri bilimi için önemli olan NumPy, Pandas ve Matplotlib
kütüphanelerine değindik ve bu kütüphanelerle veri manipülasyonu, analizi ve
görselleştirme konularında örnekler sunduk.
Kitabımızın sonraki bölümlerinde, Python ile masaüstü ve web uygulamaları
geliştirme konularına yer verdik. Masaüstü uygulamaları için PyQt5 ve Kivy, web
uygulamaları için Flask, Bottle ve CherryPy gibi popüler Python çerçevelerini ele
aldık. Ayrıca mobil uygulama geliştirme konusunda da Android platformunda
Java kullanarak bir örnek uygulama geliştirdik.
Bu kitap boyunca, Python'un güçlü ve esnek yapısını, zengin kütüphane desteğini
ve geniş kullanım alanlarını öğrendik. Python, veri bilimi, yapay zeka, yazılım
geliştirme ve web uygulamaları gibi birçok alanda kullanılan bir programlama
dilidir.
Bu kitabın amacı, Python öğrenmek isteyenlerin temel konuları anlamalarına
yardımcı olmak ve farklı uygulama alanlarına yönelmelerine ilham vermektir.
Kitabımızın sonuna geldik ve umarız Python dünyasına atılmak isteyenler için
faydalı bir kaynak olmuştur.
Sevgiyle kalın.