Python

Python, Yazılım

24May

Python’da Veri Tabanı İşlemleri #2

Bu yazıda bir önceki yazımızda oluşturmuş olduğumuz MusteriTablosu isimli tablo üzerinde Python ile örnek uygulamalar yapacağız. Burada kullanacağım veri tabanı ile ilgili daha fazla bilgi için buraya tıklayarak bir önceki yazıya gidebilirsiniz.

Uygulama 1: Müşteri tablosunda taksit sayısı 6’dan küçük olanları listeleyelim.

INPUT: 

musteriler = sqlite3.connect("musteriler.sqlite")
imlec = musteriler.cursor()
secilenler = imlec.execute("Select * From MusteriTablosu WHERE MusteriTaksitsayisi < 6")
print(secilenler.fetchall())

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440)]

Burada veri tabanına olan erişimimizi kapatmıyorum. Çünkü yazı boyunca aynı bağlantı kodunu tekrar tekrar yazmayalım.

Uygulama 2: Müşteri tablosunda geliri 3000 TL’den fazla ve yaşı 30’dan küçük olan müşterileri listeleyelim.

INPUT:

secilenler1 = imlec.execute("Select * From MusteriTablosu WHERE MusteriGeliri > 3000 AND MusteriYas < 30")
secilenler1.fetchall()

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17)]

Uygulama 3: Müşteri tablosunda cinsiyeti kadın olanları listeleyelim.

INPUT:

secilenler2 = imlec.execute("Select * From MusteriTablosu WHERE MusteriCinsiyet  = 'K'")
secilenler2.fetchall()

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34)]

Uygulama 4: Müşteri tablosunda aylık ödemesi 600 TL’den düşük olan müşterilerin borcunu, gelirini, adını ve soyadını listeleyelim.

INPUT:

secilenler3 = imlec.execute("Select MusteriAd, MusteriSoyad, MusteriGeliri, MusteriToplamBorc From MusteriTablosu WHERE MusteriAylikOdeme  < 600")
secilenler3.fetchall()

OUTPUT:

[('Ece', 'Gündüz', 3655, 1760),
 ('Gizem', 'Duyar', 3500, 2750),
 ('Aslı', 'Çevik', 3000, 1650),
 ('Betül', 'Çevreci', 2800, 1400)]

Uygulama 5: Insert komutunu kullanarak aşağıda verilen verileri veri tabanına ekleyelim.

(625173, “Salih”, “Güven”, 30, “E”, 2200.00, 1250.00, 6, 208.34)

(153294, “Melike”, “Özdemir”, 26, “K”, 4350.00, 4250.00, 12, 283.34)

(309852, “Berk”, “İnan”, 56, “E”, 3800.00, 2760.00, 12, 230.00)

Bu verileri liste olarak yazıp, bir önceki yazıda oluşturduğumuz fonksiyon içerisine yazalım.

INPUT:

yeniVeriler = [[625173, "Salih", "Güven", 30, "E", 2200.00, 1250.00, 6, 208.34], [153294, "Melike", "Özdemir", 26, "K", 4350.00, 4250.00, 12, 283.34], [309852, "Berk", "İnan", 56, "E", 3800.00, 2760.00, 12, 230.00]]
VeriGirisi(yeniVeriler)
musteriler.commit()
secilenler4 = imlec.execute("Select * From MusteriTablosu ")
secilenler4.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34),
 (127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (437612, 'Mehmet', 'Bekçi', 35, 'E', 6500, 4800, 6, 800),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34),
 (971025, 'Cenk', 'Kahraman', 33, 'E', 4250, 9800, 12, 816.67),
 (625173, 'Salih', 'Güven', 30, 'E', 2200, 1250, 6, 208.34),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 4250, 12, 283.34),
 (309852, 'Berk', 'İnan', 56, 'E', 3800, 2760, 12, 230)]

Uygulama 6: Update komutunu kullanarak Melike Özdemir kişisinin borcunu 12800.00 TL ve taksit sayısını 8 olarak güncelleyelim. Buna bağlı olan sütunları da güncelleyelim.

INPUT:

imlec.execute("UPDATE MusteriTablosu SET MusteriToplamBorc = 12800.00, MusteriTaksitSayisi = 8, MusteriAylikOdeme = 1600.00 WHERE MusteriAd = 'Melike' AND MusteriSoyad = 'Özdemir'")
musteriler.commit()
Secilenler5 = imlec.execute("Select * From MusteriTablosu WHERE MusterID  = 153294")
Secilenler5.fetchall()

OUTPUT:

[(153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600)]

Uygulama 7: MusteriID’si 625173 olan Salih Güven kişisini tablodan silelim.

INPUT:

imlec.execute("DELETE FROM MusteriTablosu WHERE MusterID = 625173")
musteriler.commit()
Secilenler6 = imlec.execute("Select * From MusteriTablosu")
Secilenler6.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34),
 (127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (437612, 'Mehmet', 'Bekçi', 35, 'E', 6500, 4800, 6, 800),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34),
 (971025, 'Cenk', 'Kahraman', 33, 'E', 4250, 9800, 12, 816.67),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600),
 (309852, 'Berk', 'İnan', 56, 'E', 3800, 2760, 12, 230)]

Uygulama 8: Müşteri tablosunda isminde A harfi olan kişileri listeleyelim.

INPUT:

Secilenler7 = imlec.execute("Select * From MusteriTablosu WHERE MusteriAd Like '%A%'")
Secilenler7.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550)]

Uygulama 9: Müşteri tablosunda soyadı Ç harfi ile başlayan kişileri listeleyelim.

INPUT:

Secilenler8 = imlec.execute("Select * From MusteriTablosu WHERE MusteriSoyad Like 'Ç%'")
Secilenler8.fetchall()

OUTPUT:

[(201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34)]

Uygulama 10: Müşteri tablosunda ismi E harfi ile biten kişileri listeleyelim.

INPUT:

e("Select * From MusteriTablosu WHERE MusteriAd Like '%E'")
Secilenler9.fetchall()

OUTPUT:

[(127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600)]

Uygulama 11: Müşteri tablosunda geliri 3000 TL ya da 4500 TL olan kişilerin ad, soyad, maaş ve yaşını listeleyelim.

INPUT:

Secilenler10 = imlec.execute("Select MusteriAd, MusteriSoyad, MusteriGeliri, MusteriYas From MusteriTablosu WHERE MusteriGeliri IN(3000,4500)")
Secilenler10.fetchall()

OUTPUT:

[('Ahmet', 'Yenidoğan', 4500, 36), ('Aslı', 'Çevik', 3000, 26)]

Uygulama 12: Müşteri Tablosunda adında A harfi olmayan ve geliri 3500 TL, 4000 TL ya da 4800 TL olan kişilerin ad ve soyadlarını listeleyen sorguyu yazalım.

INPUT:

Secilenler11 = imlec.execute("Select MusteriAd, MusteriSoyad From MusteriTablosu WHERE MusteriAd NOT LIKE '%A%' AND MusteriGeliri IN(3500,4000,4800)")
Secilenler11.fetchall()

OUTPUT:

[('Gizem', 'Duyar')]

Uygulama 13: Müşteriler veri tabanına CihazTablosu isminde bir tablo oluşturalım. Bu tablonun içerisinde CihazID, CihazModel, CihazYıl ve CihazAd sütunlarını ekleyelim.

INPUT:

imlec.execute('''CREATE TABLE IF NOT EXISTS CihazTablosu(
                 CihazID INT NOT NULL, 
                 CihazModel Varchar(5), 
                 CihazYıl SMALLINT,
                 CihazAd Varchar(30))''')

Uygulama 14: Yeni oluşturduğumuz CihazTablosu isimli tabloya aşağıdaki verileri ekleyelim.

(“TBT16”, 2016, “Tablet”), (“BGR20”, 2020, “Bilgisayar”), (“TLN18”, 2018, “Telefon”), (“BZD19”, 2019, “Buzdolabı”), (“CMR21”, 2021, “Çamaşır Makinesi”), (“TVN21”, 2021, “Televizyon”)

INPUT:

cihazlar = [[1635,"TBT16", 2016, "Tablet"], [1654,"BGR20", 2020, "Bilgisayar"], [5643,"TLN18", 2018, "Telefon"], [4567,"BZD19", 2019, "Buzdolabı"], [1564,"CMR21", 2021, "Çamaşır Makinesi"], [4569,"TVN21", 2021, "Televizyon"]]
for cihaz in cihazlar:
 imlec.execute("INSERT INTO CihazTablosu VALUES (?,?,?,?)", cihaz)
musteriler.commit()
secilenler12 = imlec.execute("SELECT * FROM CihazTablosu")
secilenler12.fetchall()

OUTPUT:

[(1635, 'TBT16', 2016, 'Tablet'),
 (1654, 'BGR20', 2020, 'Bilgisayar'),
 (5643, 'TLN18', 2018, 'Telefon'),
 (4567, 'BZD19', 2019, 'Buzdolabı'),
 (4569, 'TVN21', 2021, 'Televizyon'),
 (1564, 'CMR21', 2021, 'Çamaşır Makinesi')]

Uygulama 15: Müşteri tablosuna SahipOlunanCihaz isimli ve veri türü INT olan bir sütun ekleyelim.

INPUT:

imlec.execute("ALTER TABLE MusteriTablosu ADD COLUMN SahipOlunanCihaz INT")
musteriler.commit()

Uygulama 16: Müşteri tablosuna yeni eklenen sütuna (1,3,5,6,2,4,3,5,1,6) değerlerini ekleyelim.

INPUT:

CihazNumaralari = [1,3,5,6,2,4,3,5,1,6]
MusteriNumaralari = [136752, 127650, 201638, 518023, 812503, 437612, 356721, 971025, 153294, 309852]
a = 0
for musteri in MusteriNumaralari:
 imlec.execute("UPDATE MusteriTablosu SET SahipOlunanCihaz = {} WHERE MusterID = {}" .format(CihazNumaralari[a], musteri))
 a += 1
musteriler.commit()
secilenler13 = imlec.execute("SELECT * FROM MusteriTablosu")
secilenler13.fetchall()

OUTPUT:

[(136752, 'Ahmet', 'Yenidoğan', 36, 'E', 4500, 3800, 6, 633.34, 1),
 (127650, 'Ece', 'Gündüz', 28, 'K', 3655, 1760, 4, 440, 3),
 (201638, 'Ali', 'Çelik', 46, 'E', 6500, 8900, 12, 741.67, 5),
 (518023, 'Gizem', 'Duyar', 23, 'K', 3500, 2750, 12, 229.17, 6),
 (812503, 'Aslı', 'Çevik', 26, 'K', 3000, 1650, 6, 550, 2),
 (437612, 'Mehmet', 'Bekçi', 35, 'E', 6500, 4800, 6, 800, 4),
 (356721, 'Betül', 'Çevreci', 26, 'K', 2800, 1400, 6, 233.34, 3),
 (971025, 'Cenk', 'Kahraman', 33, 'E', 4250, 9800, 12, 816.67, 5),
 (153294, 'Melike', 'Özdemir', 26, 'K', 4350, 12800, 8, 1600, 1),
 (309852, 'Berk', 'İnan', 56, 'E', 3800, 2760, 12, 230, 6)]

Bir sonraki yazımızda Python’dan bahsetmeye devam edeceğiz.

PYTN5JL10AJU0X299N

Python, Yazılım

7Ara

Python ile Veritabanı İşlemleri #1

Bu bölümde sizlere Python’da veritabanı işlemlerinin nasıl gerçekleştiğinden bahsedeceğim. Bu yazı kapsamında SQLITE ile veritabanı işlemleri gerçekleştirilecektir. SQLITE kullanmamızın sebebi, herhangi bir sunucuya ek bağlantı yapmadan SQL sorgularını hızlı ve taşınabilir dosya sistemlerinde kullanabilmektir. SQLITE veritabanı oldukça güçlü bir veritabanıdır. Burada kullanacağımız SQL sorgularını web sitemizde yer alan “SQL İle Veritabanı İşlemleri” yazılarında detaylı bir şekilde inceleyebilirsiniz. İlk olarak SQLITE bağlantısının nasıl yapılacağından bahsedelim.

Python’da SQLITE Bağlantısı Kurma

Python ile veritabanı işlemlerini gerçekleştirebilmek için SQLITE veritabanı ile ilk olarak bağlantı kurmamız gerekir. Bunun için SQLITE modülünü aşağıdaki gibi Python’a çağırmalıyız.

İmport sqlite3

Artık SQLITE veritabanına Python ile erişim sağlayabiliriz. Eğer kullandığımız SQLITE modülünün versiyonunu öğrenmek istersek aşağıdaki kodu kullanabiliriz.

INPUT: 

sqlite3.version


OUTPUT:

2.6.0

Veritabanı Oluşturma

Şimdi ise veritabanımızı oluşturalım. Bunun için aşağıdaki kod kullanılabilir.

musteriler = sqlite3.connect(“musteriler.sqlite”)

sqlite3.connect() fonksiyonu hem var olan bir veritabanına bağlanmak hem de yeni bir veritabanı oluşturmak için kullanılır. Ben burada Jupyter tabanlı Google Colab’ta kodları yazdığım için eğer var olan bir veritabanına bağlanmak isteseydim Google Drive’a veritabanı dosyasını yüklemem gerekirdi. Google Colab’ta kullandığınız Google hesabınız ile Google Drive’deki hesabınızın aynı olmasına ve bağlantı kurmuş olduğunuza dikkat ediniz.

Eğer var olan bir veritabanına bağlanmak isteseydim, veritabanının bulunduğu yolu sqlite3.connect() içerisine yazmam gerekirdi. Ben burada musteriler adlı yeni bir veritabanı oluşturdum. Eğer ki veritabanınızı istediğiniz yere kurmak istiyorsanız, kurmak istediğiniz yerin dosya yoluna veritabanı adınızı ekleyip sqlite.connect() içerisine yazabilirsiniz. Örnek olarak:

sqlite3.connect(“D:/ … /yeni klasör/veritabanım.db”)

Bu işlemin ardından veritabanımız oluşturuldu. Veritabanı üzerinde işlem yapabilmek için imleç tanımlamamız gerekir. Bu imleci tanımlamak için cursor() özelliği kullanılabilir. Veritabanımız üzerinde işlem yapabilmek için imleç oluşturalım.

imlec = musteriler.cursor()

Veritabanına Tablo Ekleme

Yukarıdaki işlemlerin ardından artık veritabanımızda sorgular ile işlemler gerçekleştirebiliriz. Veritabanımızda bir MusteriTablosu isimli bir tablo oluşturalım. Yazdığımız sorgu komutlarının veritabanında çalışması için execute() özelliğini kullanmalıyız.

INPUT: 

imlec.execute('''CREATE TABLE IF NOT EXISTS MusteriTablosu(
                          MusterID INT NOT NULL,
                          MusteriAd  varchar(20),
                          MusteriSoyad varchar(30),
                          MusteriYas TINYINT,
                          MusteriCinsiyet  char(1),
                          MusteriGeliri  Decimal(7,2),
                          MusteriToplamBorc  Decimal(7,2),
                          MusteriTaksitSayisi  TINYINT,
                          MusteriAylikOdeme Decimal(4,2))''')

Yukarıdaki kodda müşterilerimizin bazı bilgilerini tutan bir tablo oluşturduk. Bu tabloyu oluştururken IF NOT EXISTS dememizin sebebi, eğer böyle bir tablo yok ise oluştur demektir. Veritabanında işlemler gerçekleştirirken farkına varmadan yapılabilecek hataların önüne geçmek için kullanılabilir. MusterID sütununun birincil anahtar olduğunu ve boş olamayacağını belirttikten sonra diğer sütunlarımızı ve veri türlerini yazıp kod bloğunu çalıştırdık. Böylece veritabanımızda 9 sütunlu MüsteriTablosu isimli bir tablo oluşturulmuş oldu. Eğer SQLITE daha fazla incelemek isterseniz buraya tıklayarak resmi sayfaya gidebilirsiniz.

Şimdi ise oluşturduğumuz bu tabloya veri girişini sağlayalım. Birden fazla veriyi tek tek girmek yerine bir for döngüsü oluşturalım. Liste içerisine yazdığımız veriler döngü ile veritabanına aktaralım. Bunun için aşağıdaki kod bloğu kullanılabilir.

INPUT:

def  VeriGirisi(veri):
        for veriler in veri:
               imlec.execute(“INSERT INTO MusteriTablosu Values(?,?,?,?,?,?,?,?,?)”,veriler)
               musteriler.commit()
verilerim = [[136752, “Ahmet”, “Yenidoğan”,36,”E”, 4500.00, 3800.00, 6, 633.34], 
             [127650, “Ece”, “Gündüz”, 28,”K”, 3655.00, 1760.00, 4, 440.00], 
             [201638, “Ali”, “Çelik”, 46,”E”, 6500.00, 8900.00, 12, 741.67], 
             [518023, “Gizem”, “Duyar”, 23, “K”, 3500.00, 2750.00, 12, 229.17], 
             [812503, “Aslı”, “Çevik”, 26, “K”, 3000.00, 1650.00, 6, 550.00], 
             [437612, “Mehmet”, “Bekçi”, 35, “E”, 6500.00, 4800.00, 12, 400.00], 
             [356721, “Betül”, “Çevreci”, 26, “K”, 2800.00, 1400.00, 6, 233.34], 
             [971025, “Cenk”, “Kahraman”, 33, “E”, 4250.00, 9800.00, 12, 816.67]]

Yukarıda görüldüğü gibi 8 adet verimiz var. Bu verileri döngü ile veritabanına aktarma işlemini bir fonksiyon olarak tanımladık. Bu fonksiyonu çağırmak ve içerisine verilerin listesini yerleştirmemiz gerekiyor.

VeriGirisi(verilerim)

Yukarıda fonksiyonu tanımlarken imlec.commit() diye bir kod yazdık. Bu kod her veriyi disk üzerine yazmayı sağlar. Girilen veriler sadece bellekte olur ve disk üzerine yazılmaz. Bizde bağlantıyı koparmadan commit() fonksiyonu ile verilerimizi diske yazıyoruz. Eğer veritabanı üzerinde yapacağımız işlemler sonlandıysa veritabanımızı mutlaka kapatmalıyız. Bunun için close() fonksiyonu kullanılabilir.

musteriler.close()

Böylece veritabanımızı kapatmış olduk. Eğer veritabanı üzerinde yeniden işlem yapmak istersek tekrar bağlantı kurmamız gerekir. Veritabanımızın veri girişi yapıldıktan sonraki halini görmek için listeleyelim. Bunun için aşağıdaki kodlar kullanılabilir.

INPUT:

musteriler = sqlite3.connect("musteriler.sqlite")
imlec = musteriler.cursor()
imlec.execute("Select * From MusteriTablosu") 
liste = imlec.fetchall()
print("Müsteriler Listesi")
print("----------------------------------------------------------")
for müsteri in liste:
      print("Müsteri ID : {}\nMüşteri Adı : {}\nMüsteri Soyadı : {}\nMüşteri Yaş : {}\nMüşteri Cinsiyet : {}\nMüşteri Gelir : {}\nMüşterinin Borc : {}\nMüşteri taksit sayısı :{}\nMüşteri Aylık Ödeme : {}".format(müsteri[0], müsteri[1], müsteri[2], müsteri[3], müsteri[4], müsteri[5], müsteri[6], müsteri[7], müsteri[8]))
      print("-----------------------------------------------------")
musteriler.commit()
musteriler.close()










-

OUTPUT:

Müsteriler Listesi
-------------------------------------------
Müsteri ID : 136752
Müşteri Adı : Ahmet
Müsteri Soyadı : Yenidoğan
Müşteri Yaş : 36
Müşteri Cinsiyet : E
Müşteri Gelir : 4500
Müşterinin Borc : 3800
Müşteri taksit sayısı :6
Müşteri Aylık Ödeme : 633.34
-------------------------------------------
Müsteri ID : 12765
Müşteri Adı : Ece
Müsteri Soyadı : Gündüz
Müşteri Yaş : 28
Müşteri Cinsiyet : K
Müşteri Gelir : 3655
Müşterinin Borc : 1760
Müşteri taksit sayısı :4
Müşteri Aylık Ödeme : 440
                         ...

Veri Çekerken Kullanılabilecek Farklı Fonksiyonlar

Yukarıda yazdığım kod bloğuyla ilk önce veritabanına bağlandım. Ardından veritabanı üzerinde imleç oluşturdum. Bu adımdan sonra veritabanındaki tüm verileri çektim. fetchall() fonksiyonunu kullanarak tüm verileri çağırıp listeye aldım. Eğer burada fetchone() fonksiyonunu kullansaydım verileri tek tek çağırıp listelerdim. fetchone() fonksiyonu her çalıştığında bir sonraki satır listelenir. Bu iki fonksiyonun dışında fetchmany() fonksiyonu bulunur. Bu fonksiyon ile istediğimiz satırı listeyebiliriz. Yukarıdaki kod bloğunu fetchone() ve fetchmany() ile tekrar çalıştırıp sonuçları görelim.

INPUT:

musteriler = sqlite3.connect("musteriler.sqlite")
imlec = musteriler.cursor()
imlec.execute("Select * From MusteriTablosu") 
liste = imlec.fetchone()
print("Müsteriler Listesi")
print("----------------------------------------------------------")
print("Müsteri ID : {}\nMüşteri Adı : {}\nMüsteri Soyadı : {}\nMüşteri Yaş : {}\nMüşteri Cinsiyet : {}\nMüşteri Gelir : {}\nMüşterinin Borc : {}\nMüşteri taksit sayısı :{}\nMüşteri Aylık Ödeme : {}".format(liste[0], liste[1], liste[2], liste[3], liste[4], liste[5], liste[6], liste[7], liste[8]))
print("----------------------------------------------------------")
musteriler.commit()
musteriler.close()


-

OUTPUT:


Müsteriler Listesi
----------------------------------------------------------
Müsteri ID : 136752
Müşteri Adı : Ahmet
Müsteri Soyadı : Yenidoğan
Müşteri Yaş : 36
Müşteri Cinsiyet : E
Müşteri Gelir : 4500
Müşterinin Borc : 3800
Müşteri taksit sayısı :6
Müşteri Aylık Ödeme : 633.34
----------------------------------------------------------

INPUT:

musteriler = sqlite3.connect("musteriler.sqlite")
imlec = musteriler.cursor()
imlec.execute("Select * From MusteriTablosu") 
liste = imlec.fetchmany(2)
print("Müsteriler Listesi")
print("----------------------------------------------------------")
for müsteri in liste:
      print("Müsteri ID : {}\nMüşteri Adı : {}\nMüsteri Soyadı : {}\nMüşteri Yaş : {}\nMüşteri Cinsiyet : {}\nMüşteri Gelir : {}\nMüşterinin Borc : {}\nMüşteri taksit sayısı :{}\nMüşteri Aylık Ödeme : {}".format(müsteri[0], müsteri[1], müsteri[2], müsteri[3], müsteri[4], müsteri[5], müsteri[6], müsteri[7], müsteri[8]))
      print("-----------------------------------------------------")
musteriler.commit()
musteriler.close()











-

OUTPUT:


Müsteriler Listesi
-----------------------------------------------
Müsteri ID : 136752
Müşteri Adı : Ahmet
Müsteri Soyadı : Yenidoğan
Müşteri Yaş : 36
Müşteri Cinsiyet : E
Müşteri Gelir : 4500
Müşterinin Borc : 3800
Müşteri taksit sayısı :6
Müşteri Aylık Ödeme : 633.34
-----------------------------------------------
Müsteri ID : 127650
Müşteri Adı : Ece
Müsteri Soyadı : Gündüz
Müşteri Yaş : 28
Müşteri Cinsiyet : K
Müşteri Gelir : 3655
Müşterinin Borc : 1760
Müşteri taksit sayısı :4
Müşteri Aylık Ödeme : 440
-----------------------------------------------

Bu veritabanı üzerinde daha fazla işlem gerçekleştireceğiz. Ancak bu yazımızın daha fazla uzamaması adına bu veritabanı üzerinde bir tane daha örnek yapıp yazımızı sonlandıralım.

Örnek

MusterID’si 437612 olan müşterinin taksit sayısını 12 aydan 6 aya düşürün ve buna bağlı olan sütunları güncelleyin.

Burada yapmamız gereken MusterID’si 437612 olan Mehmet Bekçi adlı müşterinin taksit sayısını 6 aya indirmektir. Buna bağlı olan aylık ödeme tutarını güncellememiz gerekir. Bunun için update komutunu kullanmamız gerekir.

INPUT:

musteriler = sqlite3.connect("musteriler.sqlite") 
imlec = musteriler.cursor()
imlec.execute("UPDATE MusteriTablosu SET MusteriTaksitSayisi = 6, MusteriAylikOdeme = 800.00  WHERE  MusterID = 437612")
GuncellenmisSatir = imlec.execute("Select * from MusteriTablosu where MusterID = 437612")
GuncellenmisSatir.fetchone()
musteriler.commit()
musteriler.close()



-

INPUT:

musteriler = sqlite3.connect("musteriler.sqlite")
imlec = musteriler.cursor()
imlec.execute("Select * From MusteriTablosu") 
liste = imlec.fetchall()
print("Müsteriler Listesi")
print("----------------------------------------------------------")
for müsteri in liste:
      print("Müsteri ID : {}\nMüşteri Adı : {}\nMüsteri Soyadı : {}\nMüşteri Yaş : {}\nMüşteri Cinsiyet : {}\nMüşteri Gelir : {}\nMüşterinin Borc : {}\nMüşteri taksit sayısı :{}\nMüşteri Aylık Ödeme : {}".format(müsteri[0], müsteri[1], müsteri[2], müsteri[3], müsteri[4], müsteri[5], müsteri[6], müsteri[7], müsteri[8]))
      print("-----------------------------------------------------")
musteriler.commit()
musteriler.close()

OUTPUT:

Müsteriler Listesi
-------------------------------------------
Müsteri ID : 136752
Müşteri Adı : Ahmet
Müsteri Soyadı : Yenidoğan
Müşteri Yaş : 36
Müşteri Cinsiyet : E
Müşteri Gelir : 4500
Müşterinin Borc : 3800
Müşteri taksit sayısı :6
Müşteri Aylık Ödeme : 633.34
-------------------------------------------
Müsteri ID : 127650
Müşteri Adı : Ece
Müsteri Soyadı : Gündüz
Müşteri Yaş : 28
Müşteri Cinsiyet : K
Müşteri Gelir : 3655
Müşterinin Borc : 1760
Müşteri taksit sayısı :4
Müşteri Aylık Ödeme : 440
-------------------------------------------
Müsteri ID : 201638
Müşteri Adı : Ali
Müsteri Soyadı : Çelik
Müşteri Yaş : 46
Müşteri Cinsiyet : E
Müşteri Gelir : 6500
Müşterinin Borc : 8900
Müşteri taksit sayısı :12
Müşteri Aylık Ödeme : 741.67
-------------------------------------------
Müsteri ID : 518023
Müşteri Adı : Gizem
Müsteri Soyadı : Duyar
Müşteri Yaş : 23
Müşteri Cinsiyet : K
Müşteri Gelir : 3500
Müşterinin Borc : 2750
Müşteri taksit sayısı :12
Müşteri Aylık Ödeme : 229.17
-------------------------------------------

OUTPUT DEVAMI:

Müsteri ID : 812503
Müşteri Adı : Aslı
Müsteri Soyadı : Çevik
Müşteri Yaş : 26
Müşteri Cinsiyet : K
Müşteri Gelir : 3000
Müşterinin Borc : 1650
Müşteri taksit sayısı :6
Müşteri Aylık Ödeme : 550
-------------------------------------------
Müsteri ID : 437612
Müşteri Adı : Mehmet
Müsteri Soyadı : Bekçi
Müşteri Yaş : 35
Müşteri Cinsiyet : E
Müşteri Gelir : 6500
Müşterinin Borc : 4800
Müşteri taksit sayısı :6
Müşteri Aylık Ödeme : 800
-------------------------------------------
Müsteri ID : 356721
Müşteri Adı : Betül
Müsteri Soyadı : Çevreci
Müşteri Yaş : 26
Müşteri Cinsiyet : K
Müşteri Gelir : 2800
Müşterinin Borc : 1400
Müşteri taksit sayısı :6
Müşteri Aylık Ödeme : 233.34
-------------------------------------------
Müsteri ID : 971025
Müşteri Adı : Cenk
Müsteri Soyadı : Kahraman
Müşteri Yaş : 33
Müşteri Cinsiyet : E
Müşteri Gelir : 4250
Müşterinin Borc : 9800
Müşteri taksit sayısı :12
Müşteri Aylık Ödeme : 816.67
-------------------------------------------

-

Sonraki yazılarımızda Python ile veritabanı işlemlerine devam edeceğiz.

PYTNBLHO08H3A1G74C

Python, Yazılım

11Eki

Python’da Fonksiyonlar

“def” İle Tanımlanan Fonksiyonlar

Bu yazıda sizlere Python’da fonksiyonlardan bahsedeceğim. Fonksiyonların kullanımları matematikte bildiğimiz fonksiyonlar gibi olup, bir fonksiyon tanımlandıktan sonra içerisine bir girdi yazarız. Ardından fonksiyon bu girdiye göre bize bir çıktı verir.

Örnek olarak f(x) = 2x + 1 fonksiyonunu düşünürsek, x = 5 için fonksiyon çıktı olarak f(5) = 11 değerini bize verir. Python’da da fonksiyonlar, bir girdi alan (zorunlu değil) ve bu girdiyi bazı işlemlerden geçirip sonucunu bize geri döndüren ifadelerdir. Programımız için kod yazarken bazı kodları tekrar tekrar kullanmak zorunda kalabiliriz. Bu tür durumlada aynı kodu tekrar yazmak yerine kodumuzu bir fonksiyon olarak tanımlayıp, o fonksiyonu çağırabiliriz. Bu bize çok büyük bir kolaylık sağlayacaktır. Python’da fonksiyon tanımlamak için fonksiyon ifadesinin başına ‘def’ ifadesi eklenir. Bu ifade ingilizce ‘definition’ olan tanımlama kelimesidir. Örnek bir fonksiyon tanımlayalım.

Örnek 1

INPUT: 

  def f(x):
    print(2x+1)
  
  f(5)


OUTPUT:

     11

Yukarıdaki örnekte fonksiyonun içerisine girilen parametre için 2x+1 işlemini gerçekleştirip çıktıyı ekrana yazdıran bir fonksiyon tanımladık. Tanımladığımız fonksiyonların ekrana sonuç yazdırmasını istiyorsak print() ya da return gibi ifadeleri kullanmamız gerekir. return ifadesi döndürmek anlamına gelir. Örnek kullanımını gösterelim.

Örnek 2

INPUT:

isim = input("Lütfen bir isim giriniz :  ")
def f(deger):
        karsilamaMesaji = "Merhaba" + " " + deger
        return karsilamaMesaji
f(isim)       

OUTPUT:

Lütfen bir isim giriniz :  Adil
'Merhaba Adil'

Yukarıdaki fonksiyon dışarıdan girilen ismi karşılama mesajına ekleyip sonucu bize döndürecektir. Bir başka örnek:

Örnek 3

INPUT:

isim = input("Lütfen bir isim giriniz : ")
def karsilamaMesaji(yeni_deger):
       if yeni_deger.isnumeric():
           sonuc = yeni_deger + " " + "bir nümerik değerdir." 
           return sonuc
       else:
           print(yeni_deger + " " + "bir nümerik değer değildir.")
karsilamaMesaji(isim)

OUTPUT:

Lütfen bir isim giriniz : Erhan
Erhan bir nümerik değer değildir.

Fonksiyonlarda kullanılan değişkenler yerel değişkenlerdir. Yani fonksiyon bloğu dışında bu değişkenlere erişilemezdir. Örnek olarak:

Örnek 4

INPUT:

def f():
    y = 5
    return y 
print(y)

OUTPUT:

NameError: name 'y' is not defined

Burada yaptığımız örneklerin dışında fonksiyonlar birden fazla parametre almaları mümkündür. Örnek olarak:

Örnek 5

INPUT:

def f(x,y,z):
    a = 2*(x**2) + 5 
    b = 3*(y**3) + 6
    c = z  + 6
    return a,b,c

f(2,5,7)   

OUTPUT:

(13, 381, 13)

Örnek 2’de dışarıda tanımladığımız x = 5 değişkenini fonksiyon içerisine yazdıktan sonra tekrar çağırdığımızda x’in değeri yine 5 olarak ekrana yansımıştı. Dışarıda tanımladığımız değişkenin fonksiyon içerisindeki değişiminin her yerde geçerli olması için değişkeni fonksiyon içerisinde global olarak tanımlamamız gerekir. Örnek olarak:

Örnek 6

INPUT:

x = 5                            
def f(x):                      
    x += 1                           
    return x                          
f(x),x 

OUTPUT:

(6, 5)

INPUT:

x = 5
def f1():
    global x
    x += 1  
    return x
f1(),x

OUTPUT:

(6, 6)

Burada yaptığımız örneklerin dışında fonksiyonların birden fazla parametre almaları mümkündür. Örnek olarak:

Örnek 7

INPUT:

def f(x,y,z):
    a = 2*(x**2) + 5 
    b = 3*(y**3) + 6
    c = z  + 6
    return a,b,c

f(2,5,7)  


OUTPUT:

  (13, 381, 13)

Bunun dışında fonksiyon içinde fonksiyon tanımlamak ve bir fonksiyonun içerisinde başka bir fonksiyonun sonucunu kullanmak mümkündür. Örnek olarak:

Örnek 8

INPUT:


def fonksiyon():
     x = int(input("Lütfen bir sayı giriniz: "))
     a = x/2
     b = x/3
     def fonksiyon1():
        c = a+5
        d = b+5
        return c,d
     return print("a = {}, b = {}, c ve d = {} olarak elde edilir".format(a,b,fonksiyon1()))

fonksiyon()


OUTPUT:

Lütfen bir sayı giriniz: 6
a = 3.0, b = 2.0, c ve d = (8.0, 7.0) olarak elde edilir

Örnek 9

INPUT:

def f(a,b,c): 
   toplam = a+b+c 
   return toplam
def g(a,b,c):
    ortalama = f(a,b,c)/3
    return ortalama    

g(3,5,4)


OUTPUT:

     4.0

Buraya kadar yaptığımız örneklerin dışında birkaç örnek daha yapalım ve ardından lambda fonksiyonundan bahsedelim.

Örnek 10

Vize, final notunun girildiği ve sonuç olarak dersten geçme-kalma durumunun döndürüldüğü bir program yazınız.

INPUT:

def DersDurum(VizeNotu, FinalNotu):
    ortalama = (0.4*VizeNotu) + (FinalNotu*0.6)
    if ortalama >= 50:
       return (ortalama, "Geçtiniz")
    else:
       return (ortalama, "Kaldınız") 
DersDurum(45,50)
(48.0, 'Kaldınız')

OUTPUT:

    (48.0, 'Kaldınız')

Örnek 11

Girilen bir sayının çift olup olmadığını tespit eden bir fonksiyon yazınız.

INPUT:

def f(z):
    if z%2 ==0:
       print("Girilen sayı çiftir.")
    else:
       print("Girilen sayı tektir.")   
f(5),f(8)

OUTPUT:

Girilen sayı tektir.
Girilen sayı çiftir.

Lambda Fonksiyonu

Python’da fonksiyon tanımlamanın bir diğer yolu lambda fonksiyonunu kullanmaktır. def ile tanımlanan fonksiyondan farkı ise adsız olarak tek bir satır ile oluşturulabilen fonksiyonlar olmasıdır. Lambda fonksiyonları, birden fazla parametre alabilirken içerisinde yalnızca tek işlem yapabilirler. Bu fonksiyon, fonksiyon parametreleri döndürmek için kullanılabilir. def fonksiyonuna benzer olarak başka fonksiyonlar içerisinde de kullanılması mümkündür. Lambda fonksiyonunun kullanımı aşağıdaki gibidir:

lambda parametre(ler): işlem

Örnek 12

INPUT:

y = lambda x: x+2
print(y(2))

OUTPUT:

       4

Örnek 13

INPUT:

z = lambda a,b: 2*a + 3*b +5
print(z(5,2))


OUTPUT:

       21

Örnek 14

INPUT:


def islem(a,b,c):
     f = lambda x,y,z : 6*x + 7*y + 8*(z**2)
     sonuc = f(a,b,c) + 100
     return sonuc
islem(3,5,7)


OUTPUT:

    545

Bu yazımızda sizlere Python’da fonksiyonların nasıl kullanıldıkların ve fonksiyon çeşitlerinden bahsettik. Python ile ilgili yeni içeriklerimizi okumak için sitemizi takip etmeyi unutmayınız.

PYTNC59YX0N8ZQ3V49

Python, Yazılım

27Ağu

Python ile Dosya İşlemleri

Önceki yazılarda yazdığımız Python kodları, program sonlandığı andan itibaren kaybolur. Program yeniden başlatıldığında daha önceden yazdığımız kodlar eğer kaydedilmemiş ise erişilemezdir. Bilgisayarların temel görevi ve bizlerin istediği verilerimizin depolanmasıdır. Bir veriyi kalıcı olarak depolayabilmek için ya sabit disklerde ya da kalıcı belleklerde saklanması gerekir. Verilerimizi disk üzerlerinde saklamanın en iyi yolu, verileri dosya olarak kaydetmektir.

Dosya Oluşturma

Bu bölümde sizlere Python ile dosyaları nasıl oluşturabileceğimizden ve düzenleyebileceğimizden bahsedeceğim. Bunun için bilgisayarımızda bir metin dosyası oluşturabilir ya da bu işlemi kod ile gerçekleştirebiliriz. open() fonksiyonu bilgisayarda oluşturulan bir dosyayı açmak için ya da dosya oluşturmak için kullanılır. open() fonksiyonunun içerisine, eğer bilgisayarınıza yüklü bir Python IDE’si kullanıyorsanız dosyanın bilgisayardaki konumunu yazmanız yeterlidir. Eğer Jupyter gibi tarayıcıda çalışan IDE’ler kullanıyorsanız, dosyayı kullandığınız IDE ortamına yükleyip dosya yolunu open() fonkiyonuna yazmanız yeterlidir. Eğer adını yazdığınız dosya oluşturulmamış ise open() fonksiyonu dosyayı oluşturacaktır. Bu şekilde dosya Python içerisine aktarılmış olacaktır.

INPUT:
open("/content/drive/MyDrive/Colab Notebooks/İstiklal Marşı.txt")

Dosya Okuma

Python’a yüklediğimiz dosyayı bir değişkene atayıp satır satır okumak için readline() komutunu kullanabiliriz.

INPUT:
file = open("/content/drive/MyDrive/Colab Notebooks/İstiklal Marşı.txt")
file.readline().rstrip()

OUTPUT:
  'Korkma, sönmez bu şafaklarda yüzen al sancak;'

Programı her çalıştırdığımızda diğer satırlar ekrana gelmeye devam eder. Eğer herhangi bir satırda, baştan okuma işlemi yapmak istiyorsak seek(0) fonksiyonunu kullanabiliriz. Eğer seek() fonksiyonun içerisine farklı bir değer yazarsak, o değerin karşılık geldiği karakterden sonrasını okuma işlemi yapar. Örnek olarak:

INPUT:
file.seek(2)
file.readline().rstrip()

OUTPUT:
'rkma, sönmez bu şafaklarda yüzen al sancak;'

Dosya Üzerinde For Döngüsü Oluşturma

Dosya üzerinde for döngüsü oluşturup, bütün satırlara erişmek mümkündür.

INPUT:
file.seek(0)
for i in file:
     print(i)


OUTPUT:

Korkma, sönmez bu şafaklarda yüzen al sancak;

Sönmeden yurdumun üstünde tüten en son ocak.

O benim milletimin yıldızıdır, parlayacak;

O benimdir, o benim milletimindir ancak.

Eğer dosya üzerinde yaptığımız işlemler sona erdiyse close() fonksiyonunu kullanıp, dosyayı kapatabiliriz.

INPUT:
file.close()

readlines() fonksiyonunu kullanıp, tüm dosya içeriğini bir listeye dönüştürebiliriz. Örnek olarak:

INPUT:
file = open("/content/drive/MyDrive/Colab Notebooks/İstiklal Marşı.txt")
file_list = file.readlines()
for i in range(0, len(file_list)):
   file_list[i] = file_list[i].rstrip()
file_list  

OUTPUT:

['Korkma, sönmez bu şafaklarda yüzen al sancak;',
 'Sönmeden yurdumun üstünde tüten en son ocak.',
 'O benim milletimin yıldızıdır, parlayacak;',
 'O benimdir, o benim milletimindir ancak.']

Örnek

Üyeler adlı bir dosya oluşturalım ve bu dosya içerisine aşağıdaki bilgileri yazalım.

12345-Ali-10-5

6789-Ayşe-20-7

10112-Mustafa-50-15

12134-Gönül-5-8

Kitap satın alma sitesinde üyelerin bilgilerinin bulunduğu bu dosyayı Python’a aktaralım ve listeye dönüştürelim. Ardından Üye bilgilerini sorguladığımız bir program yazalım.

INPUT:
members = open("/content/drive/MyDrive/Colab Notebooks/Üyeler.txt").readlines()
for member in range(len(members)):
    members[member] = members[member].rstrip()
    members[member] = members[member].split("-")
members



OUTPUT:

[['12345', 'Ali', '10', '5'],
 ['6789', 'Ayşe', '20', '7'],
 ['10112', 'Mustafa', '50', '15'],
 ['12134', 'Gönül', '5', '8']]

Böylece dosyadaki üyeleri listeye atıp düzenlemiş olduk. Üye numarası, para ve kitap adedi gibi değerlerin tiplerini for döngüsü ile integer’a dönüştürebiliriz.

INPUT:
for i in members:
  i[0] = int(i[0])
  i[2] = int(i[2])
  i[3] = int(i[3])
members 


OUTPUT:

[[12345, 'Ali', 10, 5],
 [6789, 'Ayşe', 20, 7],
 [10112, 'Mustafa', 50, 15],
 [12134, 'Gönül', 5, 8]]

Şimdi ise gireceğimiz üye numarası ile üyelik bilgilerini sorgulayalım.

INPUT:
MemberNo = input("Lütfen sorgulamak istediğiniz üye numarasını giriniz : ")
if MemberNo.isnumeric():
   for member in members:
       if int(MemberNo) == member[0]:
          print("Üye numarası {0} olan,\nadlı kişinin hesabından {2} Türk lirası bakiye bulunmaktadır.\nŞu zamana kadar {3} adet kitap satın almıştır.".format(member[0],member[1],member[2],member[3]))
          break;
       else:
         print("Üye numarasına ait kişi bulunamadı.")
else:
  print("HATA! SANIRIM YANLIŞ BİR ŞEY OLDU\nÜye numarası sayılardan oluşmalıdır.")


OUTPUT:

Lütfen sorgulamak istediğiniz üye numarasını giriniz : 12345h
HATA! SANIRIM YANLIŞ BİR ŞEY OLDU
Üye numarası sayılardan oluşmalıdır.

Dosya üzerine yazmaya geçmeden evvel şunu hatırlatmakta fayda var; şu ana kadar yaptıklarımız var olan bir dosya üzerinden, yani daha önceden oluşturup veriler girdiğimiz dosya üzerinden gerçekleşmektedir.

Dosya Üzerine Yazma

Dosya oluşturmak ya da var olan bir dosyayı açmak için open() fonkisyonunu kullanıyorduk. open() fonksiyonun içerisine aşağıdaki tabloda yer alan argümanlardan birini girerek dosyanın ne şekilde açılacağına karar verebiliriz.

Argüman	Açıklama
r	Salt okuma
w	Yazma
a	Sonuna ekleme
b	İkili kip
t	Salt metin
+	Dosya güncelleme

Eğer var olan bir dosyayı w argümanı ile açarsak, dosyanın içerisindeki tüm içerikler silinir ve boş bir dosya olarak açılmış olur. Açtığımız dosya içerisine write() fonksiyonu ile satır eklemesi yapabilirsiniz. Dosya üzerinde yaptığınız değişiklikleri kaydetmek için flush() fonksiyonu kullanılabilir. Açılan dosya flush() fonksiyonu ile kaydedilmeden kapatılırsa, otomatik kayıt yapılır. Örnek olması için bir dosya oluşturup içerisine bilgiler yazalım.

INPUT:
customers = open("customers.txt","w")
customers_list = [[1245,"Gizem","Borcu yok"],[6789,"Aslı","Borcu Yok"],[6123,"Kerim","Borcu var"]]
for customer in customers_list:
    for i in customer:
        customers.write(str(i)+"-")
    customers.write("\n")    
customers.close()   

customers = open("customers.txt",”r”)
customers.seek(0)
customers_list1 = customers.readlines()
for i in range(0,len(customers_list1)):
   customers_list1[i] = customers_list1[i].rstrip()
customers_list1 


OUTPUT:

['1245-Gizem-Borcu yok-', 
'6789-Aslı-Borcu Yok-', 
'6123-Kerim-Borcu var-']

Örnekler

Aşağıdaki şekilde bir mat.txt dosyası oluşturalım.

No Ad-soyad mat fizik kimya

11 Ayşe Gök 60 50 70

12 Ahmet altun 20 40 50

13 Can Emek 80 60 70

14 Nesrin Ay 90 60 20

a) Yukarıdaki şekilde mat.txt dosyası oluşturulması ve verilerin girilmesini sağlayan bir program yazınız.

INPUT:
#Dosyanın Oluşturulması
open("mat.txt", "w")
#Dosyayı yazmak için açıyoruz ve içerisine veri ekliyoruz.
with open("mat.txt", "a")  as  dosya:
    dosya.write("No      Ad-Soyad       Mat     Fizik   Kimya\n")
    dosya.write("11      Ayşe Gök       60       50      70\n")
    dosya.write("12      Ahmet Altun    20       40      50\n")
    dosya.write("13      Can Emek       80       60      70\n")
    dosya.write("14      Nesrin Ay      90       60      20\n")
dosya.close()

b) Ekrana sadece Numara ad-soyad ve kimya notunu listeleyen bir program yazınız.

INPUT:
with open("mat.txt")  as  dosya:
  dosya.seek(0) 
  liste = dosya.readlines()
  for x in range(0,5):
      a = liste[x:x+1]  
      print(a[0][0:2],"\t",a[0][8:20],"\t",a[0][39:44])

OUTPUT:

No 	 Ad-Soyad     	 Kimya
11 	 Ayşe Gök     	  70

12 	 Ahmet Altun  	  50

13 	 Can Emek     	  70

14 	 Nesrin Ay    	  20

c) Ekrana her üç dersten 50 nin altında alanları listeleyınız.



INPUT:
with open("mat.txt")  as  dosya:
  dosya.seek(0) 
  liste = dosya.readlines()
  Fizikten_Kalanlar = []
  Matematikten_Kalanlar = []
  Kimyadan_Kalanlar = []
  for x in range(1,5):
      a = liste[x:x+1]
      Mat_Not = int(a[0][23:26]) 
      Kimya_Not = int(a[0][39:44])
      Fizik_Not = int(a[0][30:35])
      if Mat_Not < 50: 
         Matematikten_Kalanlar.append("{} kişisi Matematikten {} alarak bu dersten kalmıştır.".format(a[0][8:20],a[0][23:26].rstrip()))
      if Kimya_Not < 50: 
         Kimyadan_Kalanlar.append("{} kişisi Kimyadan {} alarak bu dersten kalmıştır.".format(a[0][8:20],a[0][39:44].rstrip()))
      if Fizik_Not < 50: 
         Fizikten_Kalanlar.append("{} kişisi Fizikten {} alarak bu dersten kalmıştır.".format(a[0][8:20],a[0][30:35].rstrip()))
  print("Matematikten kalanlar : ",Matematikten_Kalanlar)
  print("Fizikten kalanlar : ",Fizikten_Kalanlar)
  print("Kimyadan_Kalanlar : ",Kimyadan_Kalanlar)


OUTPUT:

Matematikten kalanlar :  ['Ahmet Altun  kişisi Matematikten 20 alarak bu dersten kalmıştır.']
Fizikten kalanlar :  ['Ahmet Altun  kişisi Fizikten   40 alarak bu dersten kalmıştır.']
Kimyadan_Kalanlar :  ['Nesrin Ay    kişisi Kimyadan  20 alarak bu dersten kalmıştır.']

PYTNFEXVD4K26M2510

Python, Yazılım

8Tem

Python’da Dizeler ve Dize Fonksiyonları

Dize, bir karakter setidir. Bilgisayarlar karakterleri 0’ların ve 1’lerin bir kombinasyonu olarak saklayıp işlerler. Karakterlerin bu şekilde ikili sayılara dönüştürülmesine kodlama denir. ASCII ve Unicode, popüler kodlamalardan bazılarıdır. Klavyeden bir karakter girildiğinde bilgisayarın anladığı o karakterin ASCII (ya da Unicode) tablosundaki 0 ve 1’lerden oluşan kombinasyonudur. Daha önceki yazılarda da bahsedildiği gibi çift tırnak (“ ”) ya da tek tırnak (‘ ’) arasına karakterler yazılarak string (dize) tanımlanabilir. Bu string değişkenin içerisindeki her bir karaktere indeks numarası kullanılarak erişilebileceğini daha önceki yazılarda bahsetmiştim. Örnek olması için bu yazıda da bir değişken tanımlayıp, indeks numarasını yazdığımız bir karaktere erişelim.

Örnekler

INPUT:
  isim = "Mehmet" 
  isim[2]

OUTPUT:
   'h'

Bu yazıda sizlere bahsetmek istediğim bu string ifadeler üzerinde kullanabileceğimiz fonksiyonlardır. Bunlardan ilki len() fonksiyonudur. Bu fonksiyon dizenin uzunluğunu verir.

INPUT:
  sehir = "istanbul"
  len(sehir)

OUTPUT:
  8

in ve not in operatörlerini kullanarak, bir dize içerisindeki herhangi bir karakterin varlığını sorgulayabiliriz. in operatörü, karakter dize içerisindeyse True, değilse False sonucunu döndürür. Tam tersi olarak, not in operatörü, karakter dize içerisinde değilse True sonucunu, içindeyse False sonucunu döndürür.

INPUT:
  ulke = "Türkiye"  
  k in ulke
 
OUTPUT:
  True

INPUT:
  ulke = "Türkiye"  
  y not in ulke

OUTPUT:
  False

Diğer yandan, satır sonu karakterini (\n) kullanarak satırın sonlandığını belirtebilirsiniz. Böylece aynı dize içerisine yazılan ikinci cümle, bir satır aşağı alınarak çıktı olarak gösterilir. Örnek olarak:

INPUT:
  print("Bugün hava yağmurluydu.\nAncak yarın güneşli olabilir.")

OUTPUT:
   Bugün hava yağmurluydu. 
   Ancak yarın güneşli olabilir.

Sekme karakterini (\t) kullanırsak, dize içerisindeki kelimeler arasından belirgin bir boşluk bırakılır. Bu cümlelerin daha düzgün görünmesi için kullanılabilir. Örnek olarak:

INPUT:
  aday_listesi = [["Gökhan","İstanbul",3.42],["Aslı","Balıkesir",1.96], 
  ["Canan","Ankara",2.97],["Gizem","Tokat",1.96]]
  print("Aday","\t","Şehir","\t","\t","Ort.")
  for aday in aday_listesi:
      print(aday[0],"\t",aday[1],"\t",aday[2])

OUTPUT:
  Aday     Şehir       Ort. 
  Gökhan   İstanbul    3.42
  Aslı     Balıkesir   1.96
  Canan    Ankara      2.97
  Gizem    Erzurum     1.96

Cümle içerisinde, bir değişkene ait değeri kullanabilmek için format() fonksiyonunu kullanabiliriz. Bu fonksiyonu kullanmadan da değişkenin değerini cümle içerisine yazdırabiliriz. Ancak bu her veri tipi için farklı bir karakter kullanılmasını gerektirecektir. Burada yazılanları örnek ile gösterelim.

INPUT:
  gün1 = 26
  gün2 = "salı"
  print("Bugün ayın {0}’sı  ve günlerden {1}’dır.".format(gün1,gün2))
  print("---------------------------------------")
  macSaati = "23.00"
  print("Şampiyonlar ligi maçı %s’de başlar."%macSaati)
  print("---------------------------------------")
  piSayisi = 3.14
  print("pi sayını %f alınız."%piSayisi)
  print("---------------------------------------")
  KacTL = 200
  print("Yunus Emre’nin resmi %d TL’nin arka yüzünde vardır."%KacTL)
  print("---------------------------------------")
  print("Bugün kredi faizleri %s%f azaldı."%("%",1.5)) 
  print("---------------------------------------")

OUTPUT:
   Bugün ayın 26’sı ve günlerden salı’dır.
   ---------------------------------------
   Şampiyonlar ligi maçı 23.00’de başlar.
   ---------------------------------------
   pi sayını 3.140000 alınız.
   ---------------------------------------
   Yunus Emre’nin resmi 200 TL’nin arka yüzünde vardır.
   ---------------------------------------
   Bugün kredi faizleri %1.500000 azaldı.
   ---------------------------------------

upper() ve lower Fonksiyonu

Bir dizedeki tüm karakterleri büyük harfe ya da küçük harfe dönüştürmek için kullanılan fonksiyonlardır. Örnek olarak:

INPUT:
  sehir1 = "Adıyaman"
  sehir1.upper() 

OUTPUT:
  'ADIYAMAN'

INPUT:
  sehir1 = "Adıyaman"
  sehir1.lower() 

OUTPUT:
   'adıyaman'

find() Fonksiyonu

Bir kelimenin cümle içerisinde olup olmadığını kontrol edebilmek için kullanılan fonksiyondur. find() fonskiyonunun avantajı aradığımız kelimelerin hangi konumda başladığını bize söylemesidir. Yukarıda da bahsettiğim gibi in operatörü kullanarak kelimenin ya da karakterin cümle içerisinde olup olmadığını sorgulayabilirdik. Ancak, in operatörü bize aranan kelimenin ya da karakterin konumunu vermez. Örnek olarak:

INPUT:
  sentence = "En sevdiğim gün Cuma’dır."
  sentence.find("Cuma") 

OUTPUT:
  16

Aradığımız kelime ya da karakter cümle içerisinde yok ise -1 değerini sonuç olarak döndürür.

Eğer bir kelimenin herhangi bir alt kelime ya da karakter ile başlayıp başlamadığını ya da bitip bitmediğini sorgulamak istersek startswith() ve endswith() fonksiyonlarını kullanabiliriz. startswith(), kelimenin aradığımız alt kelime ya da karakter ile başlayıp başlamadığını kontrol ederken, endswith() ise bitip bitmediğini kontrol eder. True ya da False değerlerini döndürür.

INPUT:
  sentence.startswith("Benim") 

OUTPUT:
  False

INPUT:
  sentence.endswith("r.")

OUTPUT:
  True

split() Fonksiyonu

Cümleyi belirli bir karakter ya da kelimeye göre parçalamak için kullanılan fonksiyondur. Cümleyi parçalayıp bir liste olarak bize geri verir. Örnek olarak:

INPUT: 
  sentence = "Gizemli, bir sıfattır"
  sentence.split(" ")

OUTPUT:
  ['Gizemli', 'bir', 'sıfattır']

join() Fonksiyonu

split() fonksiyonu ile parçalara ayrılan ya da liste halinde verilen kelimeleri ya da karakterleri bir karakter ya da alt cümle kullanarak birleştirmek için kullanılan fonksiyondur. Örnek olarak:

INPUT:
  sentence1 = "Haritanın fiziki şartları gereği 25derece görünmektedir."
  words = sentence1.split(" ") 
  print("Ayrılmış hali :",words)
  bosluk = " "
  print("Birleştirilmiş hali : ", bosluk.join(words)) 

OUTPUT:
   Ayrılmış hali : ['Haritanın', 'fiziki', 'şartları', 'gereği', '25', 'derece', 'görünmektedir.']
   Birleştirilmiş hali :  Haritanın fiziki şartları gereği 25 derece görünmektedir.

replace() Fonksiyonu

Cümle içerisindeki bir karakteri ya da kelimeyi istenilen karakter veya kelime ile değiştirmek için kullanılan fonksiyondur. Örnek olarak:

INPUT:
  cumle = "Bu-bir-python-yazısıdır"  
  cumle.replace("-",".")

OUTPUT:
  'Bu.bir.python.yazısıdır'

strip() Fonksiyonu

Kullanıcı tarafından girilen ya da metin dosyalarından alınan cümlelerin başında veya sonundaki boşlukları atmak için kullanılır. Eğer cümlelerin sadece başındaki boşluklar atılmak isteniyorsa .rstrip() fonksiyonu, eğer sadece cümle sonundaki boşluklar atılmak isteniyorsa .lstrip() fonksiyonu kullanılabilir. Örnek olarak:

INPUT:
  x = "  Bu cümlenin başında ve sonunda boşluklar vardır.  "
  x.strip()

OUTPUT:
  'Bu cümlenin başında ve sonunda boşluklar vardır.'

isnumeric() Fonksiyonu

Kullanıcı tarafından girilen cümlelerin sayı değerlerinden oluşup oluşmadığını kontrol etmek için kullanılan fonksiyondur. Eğer cümle sayılardan oluşuyorsa True, oluşmuyorsa False değerini döndürür. Örnek olarak:

INPUT:
  sayi = "1102" 
  sayi.isnumeric( )

OUTPUT:
   True

INPUT:
  uyeler = [["12345","Ali","10","5"],["67890","Gizem","20","7"],["10112","Mustafa","50","15"],["12134","Aslı","5","8"]]
  uyeNo = input("Lütfen üye numarasını giriniz : ")
  if uyeNo.isnumeric():
      for deger in uyeler:
          if deger[0] == uyeNo:
             print("Üye numarası {0} olan, {1} adlı kişinin hesabında {2} TL bakiye bulunmaktadır. Şu zamana kadar {3} adet kitap satın
             almıştır.".format(deger[0],deger[1],deger[2],deger[3]))
             break;
      else:
           print("Bu üye numarasına ait kişi bulunmamıştır.")
  else:
       print("Üye Numarası sayılardan oluşmalıdır.") 

OUTPUT:
   Lütfen üye numarasını giriniz : 12345
   Üye numarası 12345 olan, Ali adlı kişinin hesabında 10 TL bakiye bulunmaktadır. Şu zamana kadar 5 adet kitap satın almıştır.

PYTNVK3L0T72C14L2U

Python, Yazılım

25Haz

Python’da Listeler

Liste Oluşturma

Bir değişkende birçok öğeyi saklamak için kullanılan yapılara liste denir. Listelere ait öğeler [ ] (köşeli parantez) içerisine yazılırlar. Eğer yazılacak öğe string ise ” ” (tırnak işareti) arasına yazılır. Öğeleri birbirinden ayırmak için virgül kullanılır. Basit bir liste aşağıdaki gibi tanımlanabilir:

names = [“Ahmet”, “Mehmet” , “Ali”, “Ayşe”]

Listenin içerisindeki öğelere erişmek mümkündür. Bunun için her bir öğenin indeks numarasının kullanması gerekir. İndeks numarası 0’dan başlayarak öğe sayısı kadar aritmetik olarak devam eder. Listeler tamsayı, dize ve nesne gibi veri türlerinden oluşabilirler. Aynı zamanda listeler sıralı ve değiştirilebilirlerdir.

example_list = [1,2,3,”Adnan”, [1,2,3]]

example_list[2] yazarsak 2 indeks numarasına sahip öğe çıktı olarak gözükür. Bu da 3 öğesidir. Python’da listelerin içerisindeki öğelere negatif indisler kullanılarakta erişilebilir. Örnek olarak example_list[-1] yazılırsa, en son öğe olan [1,2,3] öğesine erişilir.

Listeye Öğe Ekleme

Listeye öğe eklenildiğinde, eklenilen öğe listenin sonuna yazılır. Eğer listeye öğe eklemek istenilirse .append() fonksiyonu kullanılabilir.

INPUT:

example_list = [1,2,3,"Adnan", [1,2,3]]
example_list.append(4)
example_list

OUTPUT:

[1, 2, 3, 'Adnan', [1, 2, 3], 4]

Yukarıdaki kod bloğunda yapılan işlemle listeye 4 elemanı eklendi. Listeler içerisindeki öğelerin değiştirilebileceği söylenmişti. Bu değişikliği yapmak için değiştirilmek istenen öğenin indeks numarasının kullanılması gerekir. Örnek olarak 1 öğesinin yerine 0 yazılsın.

INPUT:

example_list[0] = 0
example_list

OUTPUT:

[0, 2, 3, 'Adnan', [1, 2, 3], 4]

Liste Uzunluğunu Bulma

Listenin içerisindeki eleman sayısı listenin uzunluğunu verir. Listenin içerisindeki eleman sayısını bulmak için len() fonksiyonu kullanılır.

INPUT:

len(example_list)

OUTPUT:

6

.append() ile eklenilecek öğe listenin sonuna eklenir. Eklenilen öğenin konumunu kendiniz belirlemek istiyorsanız insert() fonksiyonunu kullanabilirsiniz. Bu fonksiyon insert(konum,değer) şeklinde kullanılır.

INPUT:

example_list.insert(0, "pi404")
example_list 

OUTPUT:

['pi404', 0, 2, 3, 'Adnan', [1, 2, 3], 4]

Bu iki ekleme fonksiyonun yanı sıra extend() fonksiyonu da listeye öğe eklemek için kullanılabilir. Bu fonksiyonun diğerlerinden farkı ise birden çok öğeyi listeye ekleyebiliyor olmasıdır.

INPUT:

example_list.extend([7,8,9])
example_list

OUTPUT:

['pi404', 0, 2, 3, 'Adnan', [1, 2, 3], 4, 7, 8, 9]

Listeden Öğe Çıkarma

Burada kadar gösterilenler listeye öğe eklemek için kullanılan fonksiyonlardı. Şimdi ise bir listeden öğe çıkarmak için kullanılan fonksiyonlardan bahsedelim. remove() fonksiyonu içerisine yazılan tek bir öğeyi listeden kaldırır.

INPUT:

example_list.remove(7)
example_list

OUTPUT:

['pi404', 0, 2, 3, 'Adnan', [1, 2, 3], 4, 8, 9]

Eğer listeden aynı öğeden birden fazla var ise ve bu öğe üzerinde remove() fonksiyonu kullanılırsa, indeks numarası önce olan öğe silinir. Aynı olan diğer öğeler ise listede durmaya devam eder.

INPUT:

example_list2 = [1,2,3,4,2]
example_list2.remove(2)
example_list2

OUTPUT:

[1, 3, 4, 2]

Bu fonksiyona benzer olarak pop() ve del fonksiyonlarıda kullanılabilir. pop() fonksiyonu kaldırılmak istenen öğenin indeks numarası kullanılmalıdır. Örnek olarak

INPUT:

example_list.pop(2)
del   example_list[3]
example_list

OUTPUT:

['pi404', 0, 3, [1, 2, 3], 4, 8, 9]

Listenin içerisindeki tüm öğeleri silmek için clear() metodu kullanılabilir.

INPUT:

example_list2.clear()
example_list2

OUTPUT:

[]

Listelerde Kullanılan Başlıca Fonksiyonlar

index() Fonksiyonu

index() fonksiyonu liste içerisindeki bir öğrenin indeks numarasını öğrenmek için kullanılır. Örnek olarak,

INPUT:

example_list.index([1,2,3])

OUTPUT:

3

count() Fonksiyonu

Liste içerisindeki bir öğeden kaç adet olduğunu öğrenmek için count() fonksiyonu kullanılabilir.

INPUT:

example_list3 = ["a","a","a","a","a","a","b","c","d"]
example_list3.count("a")

OUTPUT:

6

sort() Fonksiyonu

Liste içerisindeki öğeleri küçükten büyüğe doğru sıralamak için sort() fonksiyonu kullanılabilir.

INPUT:

example_list4 = [5,8,14,7,6,9]
example_list4.sort()
example_list4

OUTPUT:

[5, 6, 7, 8, 9, 14]

Burada liste içerisindeki öğelerin hepsi ya dizelerden ya da sayılardan oluşmalıdır. Eğer dize ve sayılar birlikte olduğu bir listede sort() fonksiyonu kullanılırsa hata alınır.

INPUT:

example_list5 = ["Ali", 5]
example_list5.sort()
example_list5

OUTPUT:

----------------------------------------------------------------
TypeError         Traceback (most recent call last) 
<ipython-input-39-e362aaef30e4> in <module>()       
1 example_list5 = ["Ali", 5] 
----> 2 example_list5.sort()      
 3 example_list5 

TypeError: '<' not supported between instances of 'int' and 'str'

reverse() Fonksiyonu

Listenin içerisindeki öğeleri tersten yazmak için reverse() fonksiyonu kullanılabilir.

INPUT:

example_list3.reverse()
example_list3

OUTPUT:

['d', 'c', 'b', 'a', 'a', 'a', 'a', 'a', 'a']

copy() Fonksiyonu

Oluşturulan bir listenin kopyasını oluşturmak için copy() fonksiyonu kullanılır. Örnek olarak

INPUT:

copyList3 = example_list3.copy()
copyList3

OUTPUT:

['d', 'c', 'b', 'a', 'a', 'a', 'a', 'a', 'a']

Liste Oluşturmak için Alternatif Yöntemler

Liste oluşturmak için farklı birkaç yöntem daha kullanılabilir. Örneğin list() fonksiyonu kullanılarak, içerisine yazılan öğelerden bir liste oluşturulabilir.

INPUT:

new_list = list(("pencil","eraser","book", 5))
new_list

OUTPUT:

['pencil', 'eraser', 'book', 5]

Bu yöntemin dışında range kullanılarakta liste tanımlamak mümkündür. Örnek olarak:

INPUT:

NewList = [2*x+1 for x in range(10)]
NewList

OUTPUT:

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

Liste Dilimleme

Bu bölümde son olarak listelerin dilimlenmesinden ve üyelik testinden bahsedelim. Bir listeyi dilimlemek için a[m:n] ifadesi kullanılabilir. Burada m, dilimlenmeye hangi elemandan başlanılmak isteniyorsa, o elemanın indeks numarasını ifade ederken, n ise dilimlenmenin hangi elemanda son bulması isteniyorsa, o elemanın indeks numarasını ifade eder.

INPUT:

example_list6 = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
mini_list = example_list6[0:6]
mini_list

OUTPUT:

[0, 1, 2, 3, 4, 5]

a[m:n] ifadesini kullanarak liste içindeki elemanlardan yeni bir liste oluşturulabilir. Bu durum bir kümenin, alt kümesi gibi düşünülebilir. Ancak burada dikkat edilmesi gereken husus dilimleme ile oluşturulan yeni listenin içerisinde indeks numarası m olan değer bulunurken, indeks numarası n olan değer bulunmaz. Liste oluşturmanın yanı sıra dilimleme ile listenin birden fazla elemanına ulaşılabilir ve bu elemanlar üzerinde çeşitli işlemler yapabilir.

INPUT:

ListOfEvenNumbers = [ ]  
ListOfOddNumbers = [ ]              
for number in example_list6:      
       if number%2 ==0:
          ListOfEvenNumbers.append(number)
       else:
           ListOfOddNumbers.append(number)  
print("0-15 arasındaki çift sayılar kümesi = {}".format(ListOfEvenNumbers))
print("0-15 arasındaki tek sayılar kümesi = {}".format(ListOfOddNumbers))

OUTPUT:

0-15 arasındaki çift sayılar kümesi = [0, 2, 4, 6, 8, 10, 12, 14] 
0-15 arasındaki tek sayılar kümesi = [1, 3, 5, 7, 9, 11, 13, 15]

Eğer a[:] ifadesi kullanılırsa, listenin içerisindeki tüm elemanlar çağrılır. Örnek olarak:

INPUT:

example_list6[:]

OUTPUT:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

a[m:n:c] ifadesi liste içerisindeki m ile n arasındaki elemanları c(2 olsaydı,2’şerli atlayarak) atlayarak yeni bir liste olarak geri verir. Örnek olarak:

INPUT:

example_list6[0:10:2]

OUTPUT:

[0, 2, 4, 6, 8]

Ayrıca liste içerisindeki elemanlar tersten yazılmak isteniyorsa, [::-1] ifadesi kullanılabilir. Örnek olarak

INPUT:

example_list6[::-1] 

OUTPUT:

[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Üyelik Sorgulama

Üyelik sorgulaması ise bir elemanın liste içerisinde olup olmadığını öğrenmek için yapılır. in ve not in operatörlerini kullanarak bu sorgulama gerçekleştirilebilir. in operatörü eğer eleman liste içerisinde ise True, değilse False döndürür. not in operatörü ise eleman liste içinde değilse True, içinde ise False döndürür. Örnek olarak:

INPUT:

5 in example_list6

OUTPUT:

True

INPUT:

16 in example_list6

OUTPUT:

False

INPUT:

20 not in example_list6

OUTPUT:

True

INPUT:

3 not in example_list6

OUPUT:

False

Bir sonraki yazıda Python’dan bahsetmeye devam edeceğim.

PYTN2972U5XK85ULZ9

Python, Yazılım

8Haz

Python’da Operatörler, If-Else ve Döngüler

Bu yazıda sizlere karşılaştırma operatörleri, atama operatörleri, mantıksal operatörler ve döngüler gibi konulardan bahsedeceğim.

Karşılaştırma Operatörleri

Karşılaştırma Operatörleri iki değeri karşılaştırmak için kullanılır. Aşağıdaki tabloda karşılaştırma operatörlerini görebilirsiniz.

Operatörler	Adı
==	Eşittir
!=	Eşit değil
>	Büyüktür
<	Küçüktür
>=	Büyük ya da eşit
<=	Küçük ya da eşit

Karşılaştırma işlemleri True ya da False sonuçlarını verir. Yukarıdaki karşılaştırma operatörleri için örnek vermek gerekirse,

INPUT:

4 == 4

OUTPUT:

True

INPUT:

5 == 4

OUTPUT:

False

INPUT:

6 != 1

OUTPUT:

True

INPUT:

4 > 5

OUTPUT:

False

INPUT:

5 >= 2

OUTPUT:

True







-

Atama Operatörleri

Python’da bir değişkene değer atamak için atama operatörlerini kullanabiliriz. Başlıca atama operatörleri tablodaki gibidir.

Operatörler	Örnek	Açıklama
=	x = 8	x’e 8’i atar.
+=	x += 8	x’e 8 ekler.
-=	x -= 8	x’ten 8 çıkarır.
*=	x *= 8	x’i 8 ile çarpar.
/=	x /= 8	x’i 8’e böler.
%=	x %= 8	x’in 8 ile bölümünden kalanı x’e atar.
//=	x //= 8	x’in 8’e bölümündeki bölümü, x’e atar.
**=	x **= 8	x’in 8 üssünü alır ve x’e atar.

Mantıksal Operatörler

Operatörler	Açıklama	Kullanımı
and	İki ifade doğruysa True döndürür.	z>10 and z<20
or	İki ifadeden biri doğruysa True döndürür.	x>10 or x<11
not	Mantıksal durumu tersine çevirir. True ise False döndürür.	not(x<10 and x<15)

Kimlik Operatörleri

Python’da kimlik operatörleri iki nesnenin bellek konumunu karşılaştırır.

Operatörler	Açıklama	Kullanımı
is	İki değişken aynı nesneyse True döndürür.	x is y
is not	İki değişken aynı nesne değilse True döndürür.	x is not y

Üyelik Operatörleri

Üyelik operatörleri tuple’lar, string’ler ve listelerde bir nesnenin var olup olmadığını test etmek için kullanılır ve iki tanedir. Bunlar in ve not in’dir. in, belirtilen nesne tuple, string veya listenin içerisindeyse True sonucunu döndürür. not in, ise belirtilen nesnenin tuple, string ve listenin içerisinde değilse True sonucunu döndürür.

INPUT:

List1 = [1,2,3,4,5]

5 in List1

OUTPUT:

True

INPUT:

6 in List1

OUTPUT:

False

INPUT:

6 not in List1

OUTPUT:

True

Python’da Döngüler

Python’da çalışırken yineleme içeren işlemler yapabiliriz. Döngülerin amacı, aynı veya benzer kodu birkaç kez tekrarlamak. Bu tekrarlama belirli bir sayı kadar ya da bir koşul sağlanana kadar sürebilir. Python’da iki tane döngü mevcuttur. Bunlar for döngüsü ve while döngüsüdür.

For Döngüsü

For döngüleri, sabit sayıda tekrarlamak istediğimiz bir kod bloğu olduğunda kullanılır. Sırasıyla dizinin her bir elemanı üzerinde (liste, tuple, string, dictionary olabilir) yineleme yaparak her seferinde bloğu çalıştırır. For döngüsü, “range” ve “xrange” işlevlerini kullanarak bir sayı dizisi üzerinde yineleme yapar. range ile xrange arasındaki fark, range belirtilen aralıktaki sayılar ile bir liste döndürmesidir.

INPUT:

for i in range(0,10):
    print(i)

OUTPUT:
0 
1 
2 
3 
4 
5 
6 
7 
8 
9

INPUT:

t = 0
for k in range(100):
    t += k
print(t)


OUTPUT:

4950


INPUT:


people = ["Ahmet","Mehmet","Ali"]
for name1 in people:
  print("Kişi adı = {}".format(name1))


OUTPUT:


Kişi adı = Ahmet 
Kişi adı = Mehmet 
Kişi adı = Ali

INPUT:

for i in "pi404":
     print(i)

OUTPUT:

p 
i 
4 
0 
4

INPUT:

for x in range(3,30,3):  
    print(x) 
#3’den başlayıp 30’a kadar 3’er 3’er 
#artarak değerleri yazar.

OUTPUT:

3 
6 
9 
12 
15 
18 
21 
24 
27

INPUT:

List1 = [1,2,3,4,5]
new_list = []
for employee in List1:
    employee+= 5
    new_list.append(employee) 
new_list 

OUTPUT:

[6, 7, 8, 9, 10]

Break komutu bir for ya da while döngüsünden çıkmak için kullanılırken, continue komutu ise geçerli blogu atlamak için kullanılır.

INPUT:


stuff = ["bardak","kasik","catal","dolab","masa"]
for new_stuff in stuff:
      if new_stuff == "catal":
         print("Döngü bitti")
         break;

         
OUTPUT:

Döngü bitti

While Döngüsü

Belirli bir koşul gerçekleşene kadar devam eden döngülere while döngüleri denir.

INPUT:

num1 = 3
sumOf = 0
totalSum = 0
while sumOf < 100:
          sumOf = sumOf + num1
          totalSum +=1
print("Toplam = %d" % sumOf)
print("Döngü sayısı = %d" % totalSum)  

OUTPUT:

Toplam = 102 
Döngü sayısı = 34

INPUT:

list1 = [1,2,3,4,5]
i = 0
while list1[i] != 5:
           print("Seçili eleman = ", list1[i])
           i += 1

OUTPUT:


Seçili eleman =  1 
Seçili eleman =  2 
Seçili eleman =  3 
Seçili eleman =  4

For ve while döngülerinde, döngü bitiminde ya da döngü koşulu başarısız olduğunda yapmak istediğimiz bir eylem varsa else komutunu kullanabiliriz. Eğer döngüden break komutu ile çıkılırsa, else blogu atlanır.

INPUT:

num1 = 10
while num1 > 5:
          num1-= 1
          print(num1)
else:
        print("Sayi 5’ten küçük, döngü sona erdi.")

OUTPUT:

9 
8 
7 
6 
5 
Sayi 5’ten küçük, döngü sona erdi.

İç İçe Döngüler

For ve While döngüleri iç içe döngü olarak kullanılabilirler. Ayrıca for döngüsünden oluşan iç içe döngü ve while döngüsünden oluşan iç içe döngüler de yaratmak mümkündür.

INPUT:

#Çarpım Tablosu
for i in range(1,11):
      k = 1
      print("{} ile çarpım".format(i))
      while k < 11:
                multiply1 = i*k
                print("\n{}x{} = {}".format(i,k, multiply1))
                k = k + 1
      print("--------------------")

OUTPUT:

1 ile çarpım
 
1x1 = 1 , 1x2 = 2 , 1x3 = 3 , 1x4 = 4 , 1x5 = 5 , 1x6 = 6 ,   1x7 = 7 , 1x8 = 8 , 1x9 = 9 , 1x10 = 10 
--------------------
2 ile çarpım 

2x1 = 2 , 2x2 = 4 , 2x3 = 6 , 2x4 = 8 , 2x5 = 10 , 2x6 = 12 , 2x7 = 14 , 2x8 = 16 , 2x9 = 18 , 2x10 = 20 
--------------------

...

-------------------- 
10 ile çarpım 
10x1 = 10 , 10x2 = 20 , 10x3 = 30 , 10x4 = 40 , 10x5 = 50 ,  10x6 = 60 , 10x7 = 70 , 10x8 = 80 , 10x9 = 90 , 10x10 = 100    
--------------------

IF-ELSE-ELİF

If-else blokları, programcı tarafından bir bool koşulunun doğru ya da yanlış olmasına göre belirtilen eylemleri gerçekleştirmeye yarayan özelliktir. Kullanımı ise aşağıdaki gibidir:

if (koşul):

Koşul sağlanırsa çalışacak kodlar

elif (koşul):

Yukarıdaki koşul sağlanmaz ve bu koşul sağlanırsa çalışacak kodlar

else:

Koşullar sağlanmazsa çalışacak kodlar

INPUT:

x = int(input("Lütfen bir değer giriniz : "))
if x > 5:
   print("Girdiğiniz sayı 5’ten büyük")
elif x < 5:
   print("Girdiğiniz sayı 5’ten küçük") 
else:
   print("Girilen sayı 5’tir.")


OUTPUT:

Lütfen bir değer giriniz : 3 
Girdiğiniz sayı 5’ten küçük

INPUT:

num1 = int(input("Lütfen bir sayı giriniz : "))
if num1 %2 == 1:
   print("Girdiğiniz sayı tek sayıdır.")
else:
   print("Girdiğiniz sayi çift sayıdır.")

OUTPUT:

Lütfen bir sayı giriniz : 22 
Girdiğiniz sayi çift sayıdır.

Bir sonraki yazıda Python’dan bahsetmeye devam edeceğim.

PYTNT911Y115N6IC8U

Python, Yazılım

27Nis

Python’da Veri Tipleri

String Veri Tipi

String, çift ya da tek tırnak içerisine yazılabilen bir ya da daha fazla harf, sayı veya özel karakterlerden oluşan bir dizidir. Python’da karakter veri tipi bulunmaz. Tırnaklar arasına yazılan her karakter dizenin bir parçasıdır. Bu parçaların indeks numaralarını kullanarak her bir karaktere erişebiliriz. Aşağıda string veri tipinde bir değişken oluşturulmuş ve bir karakterin indeks numarası kullanılarak karaktere ulaşılmıştır.

INPUT:

isim = "Mehmet"

isim[4]   #İndeks numarası 4 olan karakter "e" dir.

OUTPUT:

' e '

Integer Veri Tipi

Pozitif veya negatif tam sayılardan oluşan 32 bit veri tipidir. Python’da bir tam sayı değerinin uzunluğu sistemin sahip olduğu bellek kapasitesi ile sınırlıdır. Ancak bu uzunluktan daha uzun bir sayı tanımlamak bellek kapasitesi yeterli sistemler için mümkündür.

Long Veri Tipi

Çok daha uzun tam sayıları tanımlamak için kullanılan 64 bitlik veri tipidir.

Float Veri Tipi

Ondalık sayılardan oluşan 64 bitlik veri tipidir.

Complex Veri Tipi

a+bj şeklinde gerçek ve sanal kısımdan oluşan kompleks sayıları ifade eden veri tipidir.

List Veri Tipi

List, birbirinden farklı veri tipine sahip ögeleri barındırabilen, sıralı ve değiştirilebilir veri tipidir. Listeler, [ ] arasına yazılan değerler ile tanımlanabilir. Metinsel(string) değerler “ ”(tırnak) içerisinde yazılması gerekirken numerik değerler(int,long,float) normal yazılır. Liste içerisindeki değerler birbirlerinden “ , ” (virgül) ile ayrılır. Burada da bir ögenin indeks numarası kullanılarak ögeye ulaşılabilir hatta değiştirilebilir.

Tuple Veri Tipi

Tuple, list veri tipi gibi sıralı ögelerden oluşan veri tipidir. Tuple ile list arasındaki fark ise tuple’ın değiştirilemez olmasıdır. Tuple ( ) içerisine yazılan değerler ile tanımlanır.

Dictionary (Sözlük) Veri Tipi

Sözlük, veri değerlerini (anahtar:değer) çiftlerinde tutmak için kullanılan veri tipidir. Sözlüklerin içerisindeki içerisindeki çiftler hemen hemen her veri tipinden oluşabilen, sıralanmamış ve değiştirilebilir ögelerdir. Sözlükler { } (süslü parantez) ile yazılırlar. Bir sözlük içerisindeki anahtarların değerlerini tek tek çağırabiliriz. Ayrıca bu anahtarların tiplerini de sorgulayabiliriz.

Boolean Veri Tipi

Mantıksal bir veri tipi olan boolean, True ve False olmak üzere iki değere sahiptir. Mantıksal olarak doğru olan duruma True, yanlış olan duruma ise False değeri karşılık gelir.

Python’da kod yazarken yukarıdaki veri tiplerine uygun olarak değişkenler tanımlayabilir ya da input( ) fonksiyonunu kullanarak dışarıdan kendimiz bir değişkene değer verebiliriz. Tanımladığımız ya da dışarıdan girdiğimiz değerlerin veri tiplerini değiştirmek mümkündür. Şimdi bu durumları inceleyelim.

String Veri Tipini Integer Veri Tipine Dönüştürme

String veri tipinde bir değişken tanımlayalım:

x = "12345"

Python, x değişkeninin değerini (“ ”) arasına yazıldığından string tipinde algılayacaktır. Bu string tipindeki x değişkenini int( ) fonksiyonunun içerisine yazarsak x değişkeni artık integer tipinde olur.

INPUT:

int(x)

print(type(x))

OUTPUT:

<class 'int'>

Burada dikkat edilmesi gereken husus tanımlanan bu string değerinin her bir karakterinin sayısal olmasıdır. Yoksa bu dönüştürme işlemi gerçekleşmez.

İki adet string tipinde değişken tanımlayalım:

x = “1” ve y = ” 2 ” şeklinde olsun. Burada x ve y’yi toplamayı denersek normal toplama işlemindeki gibi 3 değerini elde etmeyiz. String ifadeleri topladığımızda çıktı olarak iki ifadenin yan yana yazılmış halini görürüz.

INPUT:

x = "1"

y = "2"

print(x+y)

OUTPUT:

12

Örnek olarak tanımladığımız x değişkenini 4 değeri ile çarparsak çıktı olarak 4 defa arka arkaya yazılmış 1 rakamını görürüz.

INPUT:


x = "1"

print(4*x)

OUTPUT:

1111

Böylece toplama ve çarpma işlemlerinin string ifadeler için ekleme ve arka arkaya ekleme işlevlerinde kullanılabileceğini görmüş oluruz.

String Veri Tipini Float Veri Tipine Dönüştürme

Karakterleri rakamlardan oluşan string ifadeleri float() fonksiyonu ile float tipine dönüştürebiliriz.

INPUT:

x = "20.21"

y = float(x)

print(type(y))

OUTPUT:

<class 'float'>

Float ya da Integer’dan String’e Dönüştürme

Tanımladığımız sayısal bir değere sahip olan değişkeni str() fonksiyonu ile string tipine dönüştürebiliriz.

INPUT:

x = 10

y = str(x)

print(type(x))

OUTPUT:

<class 'int'>

Boolean Veri Tipini String Ve Integer Veri Tipine Dönüştürme

Boolean, True ve False değerlerine sahip veri tipi olduğunu belirtmiştik. Aşağıdaki örnekte boolean tipinde bir değişkenin integer ve string veri tiplerine dönüştürülmesi gösterilmiştir.

INPUT:

dogru_mu = True

print(type(dogru_mu))

y = int(dogru_mu)

print(type(y))

OUTPUT:

<class 'bool'>

<class 'int'>

ya da

INPUT:

dogru_mu = False

print(type(dogru_mu))

y = str(dogru_mu)

print(type(y))

OUTPUT:

<class 'bool'>

<class 'str'>

Bu tip dönüştürmenin tersi olan integerdan boolean’a ve string’ten boolean’a dönüştürmeyi örnekle gösterelim.

INPUT:

sonuc = " dogru "

print(type(sonuc))

yeni_sonuc = bool(sonuc)

print(type(yeni_sonuc))

OUTPUT:

<class 'str'>

<class 'bool'>

INPUT:

x = 10

print(type(x))

y = bool(x)

print(type(y)) 

OUTPUT:

<class 'int'>

<class 'bool'>

Böylece veri tiplerini ve tip dönüştürmelerini görmüş olduk. Şimdi ise matematiksel işleçlere göz atalım. Bu işleçleri aşağıdaki tablodan inceleyebilirsiniz.

İŞLEÇLER	KARAKTER
Toplama	+
Çıkarma	–
Çarpma	*
Bölme	/
Tam Sayı Bölme	//
Mödüler Bölme	%
Kuvvet Alma	**

Bu işleçlerden faydalanarak birkaç tane problem çözüp konuyu sonlandıralım.

Örnekler

1- Yarıçapı 5 olan bir dairenin çevresini hesaplayınız.

INPUT:

r = 5

pi = 3.14

dairenin_cevresi = 2*pi*r


print("Dairenin Çevresi :{}".format(dairenin_cevresi))

OUTPUT:

Dairenin Çevresi : 31.400000000000002

2- Yukarı doğru v₀ hızı ile atış hareketinde, cismin herhangi bir t anındaki yüksekliği -h = v₀.t – (1/2) .g.t bağıntısı ile verilir. Yukarı doğru 20 m/s hızla atılan cismin 5 saniye sonra yüksekliğini hesaplayınız. (g = 9.81 m/s² , π = 3.14 alınız.)

INPUT:

v0 = 10

t = 3

g = 9.81

h = v0*t-(1/2)*g*(t**2)

print("5 saniye sonra yükseklik : {}".format(-1*h))

OUTPUT:

5 saniye sonra yükseklik : 14.145000000000003

3- L uzunluklu bir basit sarkacın periyodu T = 2π(L/g)^(1/2) olarak verilir. 5 m uzunluklu sarkacın periyodunu hesaplayınız. (g = 9.81 m/s² , π = 3.14 alınız.)

INPUT:

L = 5

g = 9.81

pi = 3.14

T = 2*pi*((L/g)**(1/2))

print("Sarkacın Periyodu : {}".format(T))

OUTPUT:

Sarkacın Periyodu : 4.483427405990983

Bir sonraki yazıda Python’da karşılaştırmalar ve döngülerden bahsedeceğim.

PYTN6O05URZXMNUNQC

Python, Yazılım

22Mar

Python ile Temel Programlamaya Giriş

Bir önceki yazıda Python nedir ve hangi alanlarla kullanılır gibi pek çok konudan bahsetmiştim. Bu yazıda ise Python ile temel programlamaya giriş yapacağım. Python ile kod yazarken bir IDE’ye ihtiyaç duyulur. Bir IDE(Integrated Development Environment, Tümleşik Geliştirme Ortamı), yazılım geliştirme için bilgisayar programcılarına kapsamlı olanaklar sağlayan bir yazılım uygulamasıdır. Atom, Pycharm, IDLE, Jupyter, Spyder gibi IDE’leri kullanabilirsiniz. Bu yazıda sizlere örnek olarak göstereceğim kodlar Jupyter tabanlı Google Colab’ta hazırlanmıştır. Google Colab, Python kodlarını yazmaya yarayan, kurulum gerektirmeyen, ücretsiz, birçok kütüphaneyi içerisinde barındıran ve olmayan kütüphaneleri yüklemeye izin veren; web tarayıcıda çalışan ve bilgisayarınızdan GPU ve RAM kullanmayan bir geliştirme ortamıdır.

Google Colab ile ücretsiz olarak Tesla K80 GPU üzerinde uygulamalar geliştirebilirsiniz. Çalışmalarınız Google Drive’e kaydedebilir ya da Google Drive’ınıza yüklediğiniz bir çalışmayı Google Colab’ta inceleyebilir ve düzenleyebilirsiniz. Google Colab hakkında daha fazla bilgi almak istiyorsanız buraya tıklayarak resmi sayfaya gidebilirsiniz.

Programlama Hataları

Her programlama dilinde olduğu gibi Python’da da çalışırken hata yapmamak mümkün değildir. Bir uygulama geliştirirken yazılan kodlardaki hataları bulmak ve çözmek geliştirme sürecinde en fazla zaman harcanan bölümü olabilir. Yazacağınız en küçük programda bile onlarca farklı hata çıkma ihtimali vardır. Kod yazarken karşımıza çıkabilecek hataların ne tür bir hata olduğunu bilmek hatayı daha kolay çözmemizi sağlayacaktır.

Yazım Hataları

Syntax (söz dizimi), üzerinde çalıştığımız programlama dilinin kendine has program yapısını ve bu yapının kurulmasında kullanılan kuralları ifade eder. Her programlama dilinin yazımı farklıdır. Python derleyicisi yazdığımız kodlarda bir syntax hatası fark ederse programı durdurur ve nerede syntax hatası olduğunu gösterir. Böylece bizler nerede ve ne tür bir hata yaptığımızı görmüş oluruz. Örnek olarak ad = “Mehmet yazarsak Python derleyicisi bize burada bir hata olduğunu söyleyecektir.

ad = "Mehmet

     File "<ipython-input-1-e098e0017e34>", line 1
          ad ="Mehmet
                     ^
SyntaxError: EOL while scanning string literal

Çünkü string bir değişken tanımlanmaya çalışılmış ancak doğru bir şekilde yazılmamıştır. String ifadeler (” “) arasına yazılarak tanımlanır. Doğrusu ad = “Mehmet” şeklinde olmalıdır.

Çalışma Zamanı Hataları

Bu tür hatalar kodların hatalı yazılmasından ziyade beklenilmeyen durumlarda ortaya çıkabilen hatalardır. Örnek olarak, çalışma yaptığımız bir dosya üzerinde düzenleme iznimiz yoksa ya da veritabanında çalışacak kodlar yazmışsak ve veritabanı ile bağlantı kurmamışsak program hata verecektir.

Anlamsal Hatalar

Python’da kod yazarken, yazdığımız kodlar hatasız bir şekilde çalışır ancak istediğimiz sonuçları vermez ve farklı sonuçlar verirse anlamsal hata ortaya çıkmış demektir. Bu tür hatalar farkedilmesi zor hatalardır. Örnek olarak 13 sonucunu elde edeceğiniz 6 + 20/2 işlemini Python kullanarak çözdünüz. Ancak program size 16 sonucunu verdi. Burada program size bir hata çıktısı vermeyecektir. Çünkü bu durumda işlem önceliği hatası yapılmıştır. Program ilk olarak 20/2 işlemini gerçekleştirir, ardından bu sonuca 6 ekleyerek sonucu elde edip size gösterir. Düşündüğümüz sonucu elde etmek için ise (6+20)/2 şeklinde yazmamız gerekirdi.

Python’da Değişkenler Ve Veri Tipleri

Değişken (variable), girdiğimiz ya da atadığımız bazı değerlerin geçiçi olarak hafızada saklanması için oluşturulan alanlara denir. Bir değişkene herhangi bir değer atamak için “ = ” ifadesi kullanılır. Örnek olarak:

meslek = "Çiftçi"
dogum_yili = 1995
ondalik_sayi = 0.5

Eğer Python’da değişkene değer ataması yapılmazsa hata alınır. Yukarıda tanımlanılan üç değişkenin tipi sırasıyla string, integer ve float’tır. Burada yazılan değişkenleri kod bloğuna yazdığımızda herhangi bir çıktı göremeyiz çünkü herhangi bir komut vermedik. Ekranda çıktı görmek için print() fonksiyonunu kullanmalıyız. Böylece değişkenlerin değerlerini çıktı olarak görebiliriz. Eğer tanımladığımız bir değişkenin tipini görmek istersek type() fonksiyonunu kullanmalıyız.

type(meslek)
str

type(dogum_yili)
int

type(ondalik_sayi)
float

Tanımlanılan değişkenler harf ile başlayabilir, içerisinde sayı ve alt çizgi barındırabilir, büyük-küçük harf barındırabilirken herhangi bir sayıyla başlayamaz ve içerisinde alt çizgi hariç özel karakterler barındıramazlar. Değişken tanımlarken dikkat etmemiz gereken bir diğer hususta değişkenlere ileride hatırlanabilecek anlamlar verilerek tanımlamaktır. Örnek olarak 5 kişinin not ortalamasını hesaplayacak bir program yazmak istiyoruz. Burada ortalamayı hesaplayacak olan işlemi, alakalı bir değişkenin değeri olarak atamamızda fayda vardır.

kisi1 = 10
kisi2 = 50
kisi3 = 70
kisi4 = 85
kisi5 = 60
notlarin_toplami = kisi1 + kisi2 + kisi3 + kisi4 + kisi5
not_ortalamasi = otlarin_toplami/5
print("Notların Toplamı: ", notlarin_toplami)
print("Not Ortalaması: ", not_ortalamasi)

OUTPUT------------------
Notların Toplamı: 275
Not Ortalaması: 55.0

Python’da anahtar kelime olarak belirlenmiş kelimeleri değişken adı olarak kullanamazsınız. Bunlara örnek olarak print, if-else, class, False, none, break, import, while, for gibi kelimeler verilebilir.

Veri Tipleri

Python’da bulunan başlıca veri tipleri aşağıdaki gibidir:

String veri tipi (Metinsel veri tipi)
Integer veri tipi (Sayısal veri tipi)
Long veri tipi (Sayısal veri tipi)
Float veri tipi (Sayısal veri tipi)
Complex veri tipi (Sayısal veri tipi)
List veri tipi
Tuple veri tipi
Dictionary veri tipi

Yukarıda sıralanan veri tiplerinden bir sonraki yazıda detaylı olarak bahsedeceğim.

PYTN0FBN4Y72459ALA

Python, Yazılım

1Oca

Python Nedir? Kullanım Alanları ve Avantajları Nelerdir?

Bu yazıda sizlere günümüzde bir çok alanda kullanılan ve popüler bir dil olan Python’dan bahsedeceğim. Genel olarak Python nedir, hangi alanlarda kullanılır, kütüphaneleri nelerdir, öğrenme zorluğu nedir? gibi sorulara yanıt bulabilirsiniz. Keyifli okumalar.

**Guido van Rossum** – Oscon Konferansı, 2006

Python Nedir?

Python 1990 yılında çıkış yapan ve Guido van Rossum tarafından geliştirilen nesne yönelimli, yorumlamalı ve etkileşimli yüksek seviyeli bir dildir.

Python, ismini Guido van Rossum’un çok sevdiği MonthyPython isimli bir komedi grubunun Monty Python’s Flying Circus gösterisinden alır.

Programlama dilleri, insanlar ve makineler arasında bir köprüdür. Bir programlama dilinin makine mantığına yakın olması insanlar tarafından daha zor anlaşılması anlamına gelir. Bu tarz programlama dillerine düşük seviyeli programla dili denir. Assembly dili buna bir örnektir. Yüksek seviyeli diller ise insan mantığına daha yakındır ve bu da bizim bu dili daha kolay anlayabileceğimiz ve kullanabiliceğimiz anlamına gelir.

Python, ABC programlama diline alternatif olarak tasarlanmıştır. Python 1.0 sürümü Ocak 1994, 2.0 sürümü 16 Ekim 2000 ve son olarak 3 Aralık 2008 tarihinden itibaren 3.x serisi yayınlanmaya başlamıştır.

Python Hangi Alanlarda Kullanılır?

Python dilinin kullanıldığı pek çok çalışma alanı vardır. Bunlardan hangisine yönelmek isteyeceğiniz sizin ilginize ve merakınıza bağlıdır.

1. Web geliştirme

Python ile web geliştirmesi yapabilir ya da web sitesi oluşturabilirsiniz. Django ve Flash gibi yazılım iskeletleri’ni(framework) kullanarak sunucuda çalışan Back-End kodları yazabilirsiniz.

2. Veri bilimi

Python makine öğrenmesi, veri analizi ve veri görselleştirme alanlarında kullanılır. Bu alanlarda çok büyük miktarda veriler toplanır, analiz edilir ve işlenir.

Veri bilimcilerin topladıkları çok büyük miktardaki veriler başlangıçta işlenmemiş haldedir. Elde edilen verilen işlenmesi ve analizi için Numpy, Pandas kütüphanelerinden faydalanırlar.

Pandas kütüphanesi sayesinde R gibi istatistik programlarına ihtiyaç duymadan veriler analiz edilebilir.

Numpy bilimsel hesaplamaların hızlıca yapılabildiği basit ve kullanışlı bir matematik kütüphanesidir. Toplanılan, işlenip ve analiz edilen verilerin görselleştirilmesi için Matplotlib ve Seaborn kütüphaneleri kullanılabilir.

Makine öğrenmesinde Pandas, Numpy ve Matplotlib kütüphanelerinin yanı sıra Scikit-learn kütüphanesi de kullanılır. Scikit-learn kütüphanesi sınıflandırma, kümeleme, regresyon ve boyutsallığın azaltılması gibi özelliklere sahiptir.

3. Oyun geliştirme

Python ile insanların çok seveceği ve saatlerce oynayacağı oyunlar yaratabilirsiniz. Oyun endüstrisinde her ne kadar C++, JAVA, C# gibi diller kadar popüler olmasa da Python ile de oyun yazılabilir. Örnek vermek gerekirse günümüzde popüler oyunlardan olan Battlefield 2 ve Civilization IV’de Python dilinden faydalanılmıştır.

Siz Python ile oyun yazarken Pygame, PyKyra, Pyglet, PyOpenGL ve Panda3D gibi kütüphaneleri kullanabilirsiniz.

Yukarıdaki başlıkların haricinde masaüstü arayüz uygulamaları, ağ programlama, sistem yönetimi, yapay zeka ve veritabanı gibi alanlarda Python kullanılır.

Python’ın Avantajları

Python açık kaynak kodlu ve ücretsiz bir programdır.

Derlemeye gerek yoktur, yorumalı bir dildir.

Çok sayıda kütüphane ve fonksiyonlara sahiptir.

Kod yazması kolaydır. Başkalarının yazdığı kodlar daha bir şekilde anlaşılır.

Farklı platformlarda çalışabilir(Windows, Linux, Mac, vb.).

Diğer programlama dillerine göre daha hızlı kod yazılabilir. Bu da zaman yönetimini kolaylaştırır.

Python Kütüphaneleri

Python’da çok sayıda kütüphane ve fonksiyon olduğundan bahsettik. Bu kütüphanelerin sayısı ve işlevi kullanacağınız alanlara göre değişmektedir. Bu konuya daha sonra detaylı olarak değineceğim. Ancak buradan, Python’ın resmi websitesine giderek standart kütüphane ve fonksiyonları inceleyebilirsiniz.

Python Kullanan Önemli Şirketler

Python’ın çok kullanışlı bir programla dili olmasından dolayı günümüzde büyük şirketler tarafından oldukça tercih edilmektedir.

Bunlar arasında Google, Youtube, BitTorrent, CERN, NASA, Reddit, Zope gibi büyük markalar yer almaktadır.

Python Geliştirme Ortamları(IDE)

Python kullanarak kodlama yaparken kullanabileceğiniz ücretli ve ücretsiz IDE’ler mevcuttur. Ben size ücretsiz olan IDE’lerden bahsetmek istiyorum.

*Herhangi bir önem sırasından bağımsız olarak;

1. Jupyter, 2. Pycharm, 3. IDLE, 4. Spyder, 5. Atom, 6. Eric Python, 7. Thonny, 8. PyDev

Python Öğrenme Zorluğu

Yazının yukarıki kısımlarında da bahsettiğim gibi Python kolay öğrenilebilen, basit, anlaşılır ve sade bir dildir. Bu özellikler Python’ı diğer dillere göre daha avantajlı kılmaktadır.

Yazımı bitirmeden önce sizlere Python ve diğer diller ilgili örnek bir kod bloğu paylaşmak istiyorum.

C++

int main()
(
    printf("Merhaba Dünya");

    return 0;
}

C#

using System;
class MerhabaDunya {
  static void Main() {
    Console.WriteLine("Merhaba Dünya");
  }
}

JAVA

public class Main
{
	public static void main(String[] args) {
		System.out.println("Merhaba Dünya");
	}
}

print('Merhaba Dünya')

PYTN543LSZ03YY221R

Etiket arşivi: Python

Python’da SQLITE Bağlantısı Kurma

Veritabanı Oluşturma

Veritabanına Tablo Ekleme

Veri Çekerken Kullanılabilecek Farklı Fonksiyonlar

Örnek

“def” İle Tanımlanan Fonksiyonlar

Lambda Fonksiyonu

Dosya Oluşturma

Dosya Okuma

Dosya Üzerinde For Döngüsü Oluşturma

Örnek

Dosya Üzerine Yazma

Örnekler

Örnekler

upper() ve lower Fonksiyonu

find() Fonksiyonu

split() Fonksiyonu

join() Fonksiyonu

replace() Fonksiyonu

strip() Fonksiyonu

isnumeric() Fonksiyonu

Liste Oluşturma

Listeye Öğe Ekleme

Liste Uzunluğunu Bulma

Listeden Öğe Çıkarma

Listelerde Kullanılan Başlıca Fonksiyonlar

index() Fonksiyonu

count() Fonksiyonu

sort() Fonksiyonu

reverse() Fonksiyonu

copy() Fonksiyonu

Liste Oluşturmak için Alternatif Yöntemler

Liste Dilimleme

Üyelik Sorgulama

Karşılaştırma Operatörleri

Atama Operatörleri

Mantıksal Operatörler

Kimlik Operatörleri

Üyelik Operatörleri

Python’da Döngüler

For Döngüsü

While Döngüsü

İç İçe Döngüler

IF-ELSE-ELİF

String Veri Tipi

Integer Veri Tipi

Long Veri Tipi

Float Veri Tipi

Complex Veri Tipi

List Veri Tipi

Tuple Veri Tipi

Dictionary (Sözlük) Veri Tipi

Boolean Veri Tipi

String Veri Tipini Integer Veri Tipine Dönüştürme

String Veri Tipini Float Veri Tipine Dönüştürme

Float ya da Integer’dan String’e Dönüştürme

Boolean Veri Tipini String Ve Integer Veri Tipine Dönüştürme

Örnekler

Programlama Hataları

Yazım Hataları

Çalışma Zamanı Hataları

Anlamsal Hatalar

Python’da Değişkenler Ve Veri Tipleri

Veri Tipleri

Python Nedir?

Python Hangi Alanlarda Kullanılır?

1. Web geliştirme

2. Veri bilimi

3. Oyun geliştirme

Python’ın Avantajları

Python Kütüphaneleri

Python Kullanan Önemli Şirketler

Python Geliştirme Ortamları(IDE)

Python Öğrenme Zorluğu

C++

C#

JAVA

Python

Articles About Algorithm and Programming