Python Hızlı Tekrar
Contents
Python Hızlı Tekrar#
Python Hızlı Tekrar#
Bu defter, başka dillerde programlama bilen kişilere, kitabımızda kullanılan içeriği anlamasına yetecek düzeyde, Python yazım kurallarını hızlıca öğretmeyi hedefler. Okurun örnekleri incelemesinin içeriği anlamak için yeterli olacağı varsayılarak metin/açıklama içeriği özellikle (okuru yormamak için) sınırlı tutulmuştur. Örneğin okurun döngüler, değişkenler, fonksiyonlar gibi programlama kavramlarını bildiği varsayılmış, bu kavramlara dair açıklamalar sunulmamıştır.
Okurun kavrayışını test etmesi için “Uygulama” başlığıyla küçük programlama problemleri birer cevapla beraber sunulmuştur. Programlama sorularında her soru için birden fazla çözüm vardır, cevabımız örnek niteliğindedir. Okurun öncelikle çözümü kendi bulmaya çalışması, sonra verdiğimiz çözümü incelemesini ve olası diğer çözüm alternatiflerini düşünmesini tavsiye ederiz. “Show code” ibaresine tıklayarak çözümü görüntüleyebilirsiniz.
Uyarı: Kodun tümünün tek seferde çalışmasını engelleyen bazı kod örnekleri önüne # eklenerek devre dışı bırakılmıştır. #’leri silerek örnek kodları çalıştırabilirsiniz.
Defteri hazırlarken faydalanılan kaynaklar:
http://web.stanford.edu/class/cs106ap/handouts/python-guide.html
https://cs.stanford.edu/people/nick/python-in-one-easy-lesson/
Önerdiğimiz diğer Python özet kaynakları:
1) Değişkenler#
Değişkenleri tanımlarken tür bilgisini belirtmeniz gerekmez ve daha sonra değişkenin türünü (daha doğrusu işaret ettiği değerin türünü) değiştirebilirsiniz. Değişken’in türünü kontrol etmek için de type() veya isinstance() fonksiyonlarını kullanabilirsiniz. Örnekleri inceleyiniz ve kodu değiştirerek deneyler yaparak kavrayışınızı test ediniz.
x = 75 # tam sayı atama
print("x'in ilk değeri: ", x) # çift tırnak ve tek tırnak kullanımını inceleyiniz
x'in ilk değeri: 75
x = "Az önce sayıydı, şimdi bir metin" # string/metin atama, x'in işaret ettiğin verinin türünün değişiyor olması sorun değil
print("x'in ikinci değeri: ",x)
x'in ikinci değeri: Az önce sayıydı, şimdi bir metin
x = """Metin tanımlarken "3-çift tırnak" da kullanabilirsiniz """
print("x'in son değeri: ",x)
x'in son değeri: Metin tanımlarken "3-çift tırnak" da kullanabilirsiniz
#Tür bilgisine erişim
print("\t x'in türü: ", type(x)) #\t (tab) karakteri kullanım örneği, benzer şekilde \n karakterini de deneyiniz
x'in türü: <class 'str'>
# değişken türü kontrol etme örneği: x'in string olup olmadığını kontrol edelim
if(isinstance(x,str)):
print("String seçmekle iyi etmişim") # 'code block' 'indentation' ile sağlanıyor, birçok diğer programlama dilindeki süslü parantez kullanılmıyor
else:
print("keşke string olsaymış")
String seçmekle iyi etmişim
UYGULAMA: Kullanıcıdan girdi okumak için kullanabileceğiniz fonksiyonlardan birisi input([prompt])’dur. Kullanıcıdan bir girdi okuyarak input fonksiyonunun döndürdüğü türü ekrana yazdıran bir kod parçası yazınız.
# Kodunuzu buraya yazınız
Çözüm:
#@title
# Diyezleri silerek kodu çalıştırabilirsiniz
# test = input("Bir girdi yapınız: ")
# print('input() fonksiyonu ',type(test), ' türü bir değer döndürüyor')
UYGULAMA: input fonksiyonu kullanarak kullanıcıdan iki tam sayı okuyup toplama sonucunu ekrana yazdıran bir kod yazınız. Bu adım için tür değiştirmeye ihtiyaç duyacaksınız. string değeri tam sayıya çevirmek için int() fonksiyonunu kullanabilirsiniz.
# Kodunuzu buraya yazınız
Çözüm:
#@title
# Diyezleri silerek kodu çalıştırabilirsiniz
# sayi1 = int(input("ilk sayiyi giriniz: "))
# sayi2 = int(input("ikinci sayiyi giriniz: "))
# print(sayi1, ' + ', sayi2, ' = ',sayi1 + sayi2)
Değişkeni silmek isterseniz del komutunu kullanabilirsiniz
# Diyezleri silerek kodu çalıştırabilirsiniz
# del sayi1, sayi2
# print(sayi1)
2) Sık kullanılan matematik fonksiyonları#
Örnekleri inceleyiniz. Bu kısımda önce çıktıyı okuyup daha sonra çıktıyı oluşturan kodu inceleyiniz.
Built-in fonksiyonlar için bakınız: https://docs.python.org/3/library/functions.html
print('Üst alma:\t 2 ** 5 = ',2 ** 5, ', veya pow(2,5) = ', pow(2,5)) # kuvvet alma
print('Mod alma:\t 12 % 10 = ',12 % 10) # mod alma
print('Bölme:\t 5/2 = ', 5/2) # sonucu float olan int/int bölme işlemi
print('Tam sayı bölme:\t 5//2 = ', 5//2) # sonucu tam sayı olan int/int bölme işlemi
print('Floating point değer saklama gariplikleri:\t 0.1 + 0.1 + 0.1 = ', 0.1 + 0.1 + 0.1) # floating point öğeleri sınırlı sayıda bit ile temsil beklemediğiniz sonuçlar doğurabilir
# min - max işlemleri
print("Python'da Elma ile armut karşılaştırılabilir:\t min('elma', 'armut', 'ayva') = ", min('elma', 'armut', 'ayva'))
Üst alma: 2 ** 5 = 32 , veya pow(2,5) = 32
Mod alma: 12 % 10 = 2
Bölme: 5/2 = 2.5
Tam sayı bölme: 5//2 = 2
Floating point değer saklama gariplikleri: 0.1 + 0.1 + 0.1 = 0.30000000000000004
Python'da Elma ile armut karşılaştırılabilir: min('elma', 'armut', 'ayva') = armut
‘Akıllı’ toplama: toplama işlemi girdilerin türüne göre işlem yapıp sonuç oluşturacaktır.
# Sayılarla toplama
print('5 + 7 = ', 5 + 7)
# String toplama -> yanyana dizme ("concatenation")
print("'BootCamp'+'Izmir' = ",'BootCamp'+'Izmir')
# String ile sayı toplama
print("String'le sayıyı yanyana dizmek için önce sayıyı string'e dönüştürmelisiniz:\t str(34) + 'AB' + str(1234) = ", str(34)+' AB '+str(1234))
# Listeleri toplama
print('[1,2,3] + [4,5,6] = ', [1,2,3] + [4,5,6])
5 + 7 = 12
'BootCamp'+'Izmir' = BootCampIzmir
String'le sayıyı yanyana dizmek için önce sayıyı string'e dönüştürmelisiniz: str(34) + 'AB' + str(1234) = 34 AB 1234
[1,2,3] + [4,5,6] = [1, 2, 3, 4, 5, 6]
UYGULAMA: Hesaplama yapan makinelerin ilk mucitlerinden birisi olan Charles Babbage, asal sayı üreten bir fonksiyon bulmuştu: f(n) = n^2+n+41. Bu fonksiyon, n’e verilen tam sayı değerlerle çoğunluğu asal olan sayılar üretebiliyordu. Kullanıcıdan n değerini okuyarak Babbage fonksiyonu ile sayı üreten bir kod parçası yazınız
# Kodunuzu buraya yazınız
Çözüm:
#@title
# Diyezleri silerek kodu çalıştırabilirsiniz
# n = int(input("n = "))
# print('Üretilen sayı: ', pow(n,2)+n+41)
3) Boolean türü ve operatörleri örnekleri#
Kontrol ifadeleri:
x == 15 (x 15’e eşit mi?)
x != 15 (x 15’e eşit değil mi?)
x >= 15 (x 15’ten büyük veya 15’e eşit mi?)
x <= 15 (x 15’ten küçük veya 15’e eşit mi?)
# Karşılaştırma işleminin sonucunu bir değişkene atayarak inceleyelim
sonuc = 5 > 10
print(" 5 > 10 = ",sonuc, " , sonucun türü: ", type(sonuc),"\n")
5 > 10 = False , sonucun türü: <class 'bool'>
# Sayıların boolean olarak kullanımı
if -0.6:
print("Sıfırdan farklı sayılar 'True' olarak değerlendirilir\n")
else:
print("Sıfır ise 'False'\n")
Sıfırdan farklı sayılar 'True' olarak değerlendirilir
Benzer şekilde boş liste ve boş string de False, dolu string ve dolu liste True olarak değerlendirilir
if []:
print('Sonuc True')
else:
print('Sonuc False')
Sonuc False
if '':
print('Sonuc True')
else:
print('Sonuc False')
Sonuc False
Birden fazla karşılaştırma işlemini yapıp karar verirmek gerektiğinde mantık işlemlerine ihtiyaç duyarız
# Boolean operatör örneği... operatörler: and, or, not
yas = 50
if yas > 0 and yas < 100:
print(yas, " yaşındaki bir insan yaşıyor olabilir")
50 yaşındaki bir insan yaşıyor olabilir
UYGULAMA: Kullanıcı tarafından girilen bir yıl’ın (örnek: 2019), artık yıl olup olmadığını ekrana yazdıran bir kod parçası yazınız. Kural: 4’e bölünebilen ama 100’e bölünmeyen yıllar artıktır. Bunun istisnası 400’e bölünün yıllardır; onlar da artıktır
# Kodunuzu buraya yazınız
Çözüm:
#@title
# Diyezleri silerek kodu çalıştırabilirsiniz
# yil = int(input('Yılı giriniz: '))
# if yil <= 0:
# print('MÖ yılların artıklık durumunu hesaplayamıyorum')
# elif (yil % 4 == 0 and yil % 100 != 0) or yil % 400 == 0:
# print('Yıl artıktır')
# else:
# print('Yıl artık değil')
4) Fonksiyon tanımlama ve kullanma#
Fonksiyonları def anahtar kelimesi ile tanımlıyoruz. Tanım satırının sonunda : olduğuna ve fonksiyon içine yazılan kodların bir kademe içeride hizalandığına dikkat ediniz. Fonksiyonun ne işe yaradığını ve nasıl kullanıldığını tanımın hemen altına ve “””…””” arasına yazarız.
# Girdi almayan fonksiyon örneği tanımı.
def mesaj():
'''Homosapiens'le ilk iletişim mesajını yazdırır.
'''
print('Merhaba dünyalı, merak etme ben senin dostunum')
# Bu hücre çalıştırıldığında sadece fonksiyon tanımı yüklenir, fonksiyon çağırılmaz
# Fonksiyonun tanım bilgisine erişmek için help() kullanabilirsiniz
help(mesaj)
Help on function mesaj in module __main__:
mesaj()
Homosapiens'le ilk iletişim mesajını yazdırır.
# Fonksiyonun çağırılması
mesaj()
Merhaba dünyalı, merak etme ben senin dostunum
Girdi alıp çıktı döndüren fonksiyon örneği:
# İki girdi alıp tek çıktı döndüren fonksiyon örneği
def toplama(x, y):#degisken turlerini tanımlamamıza gerek yok
return x + y
# Fonksiyonun iki girdi ile çağırılması
toplama(5, 15)
20
ÖRNEK: asaldir() fonksiyonu verilen bir tam sayının asal olup olmadığını kontrol eden bir fonksiyon olarak tanımlanmıştır, öncelikle kodu inceleyiniz. Kod içerisinde for döngüsü kullanıma bir örnek görüyoruz (açıklama için bakınız).
C/C++, Java gibi dillerde yaygın for döngüsü yapısı alttaki gibidir.
for (int i = 0; i < 10; i ++){ … }
Python’da ise daha kısa ifadeler kullanılır:
for i in range(10): …
UYGULAMA: 100-150 arası tüm asal sayıları ekrana yazdıran bir kod parçası yazınız.
range() fonksiyonuyla belirli aralıktaki değerleri oluşturmak için range(baslangic_degeri, bitis_degeri) yapısını kullanabilirsiniz. Dikkat: bitis_degeri dahil edilmez.
# Asallık kontrolü yapan fonksiyon. İçeriğini inceleyiniz
def asaldir(sayi):#1den büyük sayıların asal olup olmadığını kontrol eder
for i in range(2,sayi):
if sayi%i == 0:
return False
return True
# Kodunuzu buraya yazınız
Çözüm:
#@title
print('100-150 arası asal sayılar:')
for sayi in range(100,151):
if asaldir(sayi):
print(sayi)
100-150 arası asal sayılar:
101
103
107
109
113
127
131
137
139
149
Döngülerle başlamışken bir de while döngüsü yazımına örnek görelim. (Örnekte anlamlı bir iş yapılmıyor, \(x\) değişkeni 5 değerinden küçük olduğu sürece artırılıyor. Yazım kuralını ögrenmek için inceleyiniz.)
x = 0
while x < 5:
print(x)
x += 1
0
1
2
3
4
UYGULAMA: Verilen bir pozitif tam sayının rakamları toplamını bulup döndüren bir fonksiyon yazınız ve şu girdiler için test ediniz: 1005, 123456, 321. İpucu: Her adımda birler basamağını toplayıp rakamdan birler basamağını attığınız birer satır kod içeren bir while döngüsü kullanmayı düşünebilirsiniz. Bu iki işlem için mod operatörü(%) ve tamsayı bölme (//) işinize yarayabilir.
Alttaki hücreye rakamlar_toplami() isimli bir fonksiyon tanımlayınız ve çalıştırınız. Bir sonraki hücreyi çalıştırarak fonksiyon tanımınızı test ediniz.
# Kodunuzu buraya yazınız
Çözüm:
#@title
def rakamlar_toplami(x):
sonuc = 0
while x>0:
sonuc += x % 10
x = x //10
return sonuc
print('1005 rakamları toplamı = ', rakamlar_toplami(1005))
print('123456 rakamları toplamı = ', rakamlar_toplami(123456))
print('321 rakamları toplamı = ', rakamlar_toplami(321))
1005 rakamları toplamı = 6
123456 rakamları toplamı = 21
321 rakamları toplamı = 6
Bazı fonksiyonlar için, kullanıcıya tüm girdileri tanımlamayıp bazıları için varsayılan bir değer kullanma ihtimalini sunmak isteyebilirsiniz. Aşağıdaki örnekte fonksiyon çağırılırken ikinci girdi (\(y\)) kullanımı opsiyoneldir; eğer girdi verildiyse verilen değer, verilmediyse fonksiyon tanımında belirtilen varsayılan değer kullanılır. Örneği inceleyiniz.
def toplama(x, y=0): # varsayılan değer kullanımı: y girilmez ise yerine 0 atanır, girilir ise girilen değer kullanılır
return x + y;
# Fonksiyonun çağırılması
print(toplama(5))
print(toplama(5, 15))
5
20
Fonksiyonlarda parametreler/girdiler, isimleri kullanıldığında sıralamadan etkilenmeyecek şekilde kullanılabilirler
def adi_yazdir(isim, soyisim):
print(isim, soyisim)
adi_yazdir('Barış', 'Bozkurt')
adi_yazdir(soyisim = 'Bozkurt', isim = 'Barış') # Değişkenlerin farklı sırayla ama isimleri açıkça belirtilerek kullanımı
Barış Bozkurt
Barış Bozkurt
Foksiyonlar birden fazla değer döndürebilir
def ikili_carpim(x, y, z):
""" Üç adet girdinin tüm ikili kombinasyonlarının çarpım sonucunu döndürür
"""
a = x * y
b = x * z
c = y * z
return a, b, c
sonuclar = ikili_carpim(2,3,5)
print("2,3,5 sayılarının ikili kombinasyonları çarpım sonucu: ", sonuclar)
# sonuclar değişkenindeki öğelerin tekil değişkenlere kopyalanması
sonuc1, sonuc2, sonuc3 = sonuclar
print("İlk sonuc:", sonuc1)
print("İkinci sonuc:", sonuc2)
print("Üçüncü sonuc:", sonuc3)
2,3,5 sayılarının ikili kombinasyonları çarpım sonucu: (6, 10, 15)
İlk sonuc: 6
İkinci sonuc: 10
Üçüncü sonuc: 15
Fonksiyonlarda belirsiz sayıda girdi kullanmak da mümkün (kaynak)
def carp(*args):
""" Girdilerin tümünü çarpıp sonucu döndürür
"""
z = 1
for sayi in args:
z *= sayi
return z
print("carp(4, 5) => ", carp(4, 5))
print("carp(2, 3, 4) => ", carp(2, 3, 4))
print("carp(3, 5, 10, 6) => ", carp(3, 5, 10, 6))
carp(4, 5) => 20
carp(2, 3, 4) => 24
carp(3, 5, 10, 6) => 900
UYGULAMA: Girilen girdilerin aritmetik ortalamasını yazdıran bir fonksiyon tanımlayıp kullanınız. Girdi sayısı belirsiz olsun, istenilen kadar girdi virgüllerle ayırılacak şekilde girilebilsin
# Kodunuzu buraya yazınız
Çözüm:
#@title
def aritmetikOrtalama(*args):
toplam = 0
for sayi in args:
toplam += sayi
return toplam/len(args)
print('aritmetikOrtalama(2, 4, 6) = ',aritmetikOrtalama(2,4,6))
print('aritmetikOrtalama(5, 10, 15, 20, 25) = ',aritmetikOrtalama(5, 10, 15, 20, 25))
aritmetikOrtalama(2, 4, 6) = 4.0
aritmetikOrtalama(5, 10, 15, 20, 25) = 15.0
5) List’ler ve list değerlerine erişim#
Verileri tutmak ve işlemek için kullanılan ana türlerden birisi List’tir. “Collections” kategorisinde bulunan List, Tuple, Set, Dictionary arasında en yaygın kullanılan List için basit örnekler görelim.
# List veri türü cinsinden homojen olmak zorunda değildir
listem = ["elma", "armut", 2.5, 5 < 10] # iki string, bir float ve bir boolean içeren bir liste tanımı
print(len(listem), " boyutlu listemin içeriği: ",listem)
4 boyutlu listemin içeriği: ['elma', 'armut', 2.5, True]
Listelerin boyutu değiştirelebilir; eleman ekleyebilir veya çıkartabilirsiniz. Altta sadece ekleme işlemi için örnek sunuyoruz. Daha fazla işlem türü ve örnek için bakınız.
# Listenin ucuna eleman ekleme
listem.append("ayva")
print(len(listem), " boyutlu listemin içeriği: ",listem)
#benzer şekilde insert, remove, clear, reverse, sort... metodları da bulunmakta
5 boyutlu listemin içeriği: ['elma', 'armut', 2.5, True, 'ayva']
Verilerle işlem yaparken liste içeriğindeki verileri parçalara ayırma( slicing) adımlarına ihtiyaç duyarız. Aşağıda bir listenin nasıl endekslendiği görselleştirilmiştir. Python, diğer birçok programlama dilinden negatif endeks kullanma opsiyonu sunmasıyla ayrışır. Dizinin altında belirtilen negatif endeks değerlerini ve örnekleri inceleyiniz.
#liste içeriğine erişim örnekleri
print('listem = ', listem)
print('Listenin ilk elemanı: listem[0] = ', listem[0])
print('Listenin son elemanı: listem[-1] = ', listem[-1])# veya: listem[len(listem)-1]
print('Listenin ilk iki elemanı: listem[:2] = ', listem[:2])# veya listem[0:2]
print('Listenin son iki elemanı: listem[-2:] = ', listem[-2:])
print('1. ve 3. endeksler arası elemanlar; listem[1:3] = ', listem[1:3])#dikkat: ilk endeksteki dahil, son endeksteki dahil değil
listem = ['elma', 'armut', 2.5, True, 'ayva']
Listenin ilk elemanı: listem[0] = elma
Listenin son elemanı: listem[-1] = ayva
Listenin ilk iki elemanı: listem[:2] = ['elma', 'armut']
Listenin son iki elemanı: listem[-2:] = [True, 'ayva']
1. ve 3. endeksler arası elemanlar; listem[1:3] = ['armut', 2.5]
UYARI: Burada Matlab kullanıcıları Python’da yapacakları hesaplamalı uygulamalarda ana değişken türü olarak list kullanacaklarını düşünebilirler. Bu mümkün ama çok pratik değil. Daha sonraki örneklerde göreceğimiz gibi tercihimiz daha çok numpy-dizileri olacak.
Listedeki bir elemanın endeksine ulaşmak isteyebilirsiniz:
print("Armut'un endeksi: ", listem.index('armut'))
Armut'un endeksi: 1
Listeleri parçalara ayırma örneklerine devam edelim ( kaynak):
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
some_nums = nums[2:7] # 2. elemandan itibaren 5 adet eleman al ( 2 + 5 = 7)
some_nums
[30, 40, 50, 60, 70]
UYGULAMA: Uzunluğunu bilmediğiniz listenin (yine ‘nums’ listesini kullanalım, uzunluğunu bilmediğimizi varsayalım) ilk ve son elemanını dışarıda bırakacak şekilde içeriğini yeni bir listeye eşleyen bir kod parçası yazınız.
# Kodunuzu buraya yazınız
Çözüm:
#@title
some_nums = nums[1:-1]
some_nums
[20, 30, 40, 50, 60, 70, 80]
UYGULAMA: Belirli sayıda eleman atlayarak işlem yapmak istediğimizde kullanacağımız yapı: başlangıç/bitiş/zıplamaMiktarı’dır. Aşağıda verilen örneği inceleyip diziyi tersten yazdıran bir kod parçası yazınız
print('nums[0:6:2] = ',nums[0:6:2]) # 0'dan başlayıp ikişer adımlarla 6. elemana kadar (6 hariç) tüm elemanlar
nums[0:6:2] = [10, 30, 50]
# Kodunuzu buraya yazınız
Çözüm:
#@title
# Terse çevirme işlemi yapan kodunuzu buraya yazınız
print('Dizinin ter çevirilmiş hali:')
nums[-1::-1]
Dizinin ter çevirilmiş hali:
[90, 80, 70, 60, 50, 40, 30, 20, 10]
“Iteration”: Python geleneksel for döngüleri yerine teker teker verilerin okunup kullanıldığı döngüler kullanır. Örnekle anlatmak/anlamak daha kolay olacak, alttaki örneği inceleyiniz. (veya kaynak için tıklayınız)
for num in nums: # Her döngüde num içerisine nums listesinden bir değer atanır
print(num)
10
20
30
40
50
60
70
80
90
Bu birçok açıdan çok pratik bir uygulamadır. Gerekmedikçe endeks değişkenleri kullanılmaz, kod sadeleşir, endeks aşma hataları yapılmaz. Bu, Python ile veri işlerken çok sık kullanacağınız bir döngü yazma biçimidir. Hatta endeks kullanmak istediğinizde bile aynı yapıyı (iterator) kullanacaksınız. Örneği altta:
# 5 boyutlu dizinin endekslerini oluşturan döngü
for endeks in range(5):
print(endeks)
0
1
2
3
4
range() kullanımı ile ilgili bakınız: kaynak1, kaynak2
UYGULAMA: Bir işyeri sahibinin çalışma saatlerinin uzunluğuna göre ayrılan 3 kategoride çalışanı vardır. İlk kategorideki işçi ayda 5000 tl, ikinci kategorideki işçi 1000 tl ve üçüncü kategorideki işçi 50 tl almaktadır. Her kategoride en az bir işçi bulunmaktadır ve toplam işçi sayısı 100dür. İşyeri sahibi ayda toplam 100bin Tl maaş ödemesi yapmaktadır. Her kategoride kaç işçi bulunduğunu bir kod parçası yardımıyla bulunuz. İpucu: for döngüleri kullanarak her olasılığı denemeyi düşünebilirsiniz. İçiçe for döngüleri kullanmanız gerekecektir.
# Kodunuzu buraya yazınız
Çözüm:
#@title
for kategori1 in range(100000//5000):
for kategori2 in range(100000//1000 - kategori1):
kategori3 = 100 - (kategori1 + kategori2)
if kategori1 * 5000 + kategori2 * 1000 + kategori3 * 50 == 100000:
print('Kategori 1 = ', kategori1, ' işçi')
print('Kategori 2 = ', kategori2, ' işçi')
print('Kategori 3 = ', kategori3, ' işçi')
Kategori 1 = 19 işçi
Kategori 2 = 1 işçi
Kategori 3 = 80 işçi
Birden fazla kolleksiyonu sıralı karıştırarak iterasyon yapmak da mümkün
L1 = [1,2,3,4,5,6,7,8]
L2 = ['hop','hop','altın','top']
for x,y in zip(L1, L2):
print(x,y)
1 hop
2 hop
3 altın
4 top
‘List comprehension’:
Yeni bir listenin içeriğini oluştururken for döngüsünün kullanıldığı pratik bir yapı. Örneği inceleyiniz.
ornekDizi = [6,2,4,-1,8,9,11,-5,8]
[x*10 for x in ornekDizi if x>5] # ornekDizi içerisindeki 5'ten büyük her sayıyı 10 ile çarparak yeni dizinin elemanı olarak ekle
[60, 80, 90, 110, 80]
UYGULAMA: Altta verilen listenin içeriğindeki sadece 10’a tam bölünen sayıları taşıyan yeni bir listeyi “list comprehension” ile oluşturunuz
ilk_liste = [10, 21, 32, 40, 55, 60, 67, 72, 80, 90, 92, 101]
# Kodunuzu buraya yazınız
Çözüm:
#@title
son_liste = [x for x in ilk_liste if x % 10 == 0]
print(son_liste)
[10, 40, 60, 80, 90]
6) Kümeler (sets))#
Kümeler her bir elemanın bir kere yer alabildiği (aynı değerde iki farklı elemanı içermeyen) kolleksiyonlardır. Örnekleri inceleyiniz.
grup1 = {"Barış", "Ahmet", "Seçil"}
grup2 = {"Hakan", "Eylem", "Ahmet"}
populasyon = grup1.union(grup2) # Küme birleştirme
print("Toplam küme:", populasyon)
Toplam küme: {'Seçil', 'Hakan', 'Eylem', 'Barış', 'Ahmet'}
# iteration kullanarak öğelere teker teker erişim
print("Kümenin elemanları/öğeleri:")
for isim in populasyon:
print(isim)
Kümenin elemanları/öğeleri:
Seçil
Hakan
Eylem
Barış
Ahmet
Set’ler için de list’lerdekine benzer şekilde eleman ekleme çıkarma fonksiyonları bulunmaktadır: .add(), .remove()
populasyon.add('Ahmet') # Varolan bir değer eklnmek istediğinde tekrarlamaya izin olmadığı için eklenmez
print(populasyon)
populasyon.add('Selin') # Olmayan bir değer eklenir
print(populasyon)
populasyon.remove('Hakan') # eleman silme örneği
print(populasyon)
{'Seçil', 'Hakan', 'Eylem', 'Barış', 'Ahmet'}
{'Seçil', 'Hakan', 'Eylem', 'Barış', 'Ahmet', 'Selin'}
{'Seçil', 'Eylem', 'Barış', 'Ahmet', 'Selin'}
Varolmayan bir değeri silmek istediğimizde hata alırız
# Diyez(#)i silerek kodu çalıştırabilirsiniz
# populasyon.remove('Ayşe')
Silmeden önce kümede var mı kontrol edebiliriz
# Diyez(#)leri silerek kodu çalıştırabilirsiniz
# kisi = input('Silinecek ismi giriniz: ')
# if kisi in populasyon:
# print('Kisi kümede var, siliyorum')
# populasyon.remove(kisi)
# else:
# print('Kisi kümede yok, silinmedi')
# print(populasyon)
UYGULAMA:
Küme birleştirmede kullanılan union fonksiyonu kendiniz yazınız. Şu şekilde kullanılsın:
kume3 = birlestir(kume1,kume2)
Kullanıcı kume2’yi girmediğinde bu küme boş küme olarak kullanılsın. Boş kümeyi şu şekilde tanımlayabilirsiniz:
kume = set()
Fonksiyonu tanımlayınız ve hücreyi çalıştırınız.
# Kodunuzu buraya yazınız
Çözüm:
#@title
def birlestir(kumeX, kumeY = set()):
sonuc = set()
for eleman in kumeX:
sonuc.add(eleman)
for eleman in kumeY:
sonuc.add(eleman)
return sonuc
# Yukarıdaki hücreye yazdığınız fonksiyonu bu hücreyi çalıştırarak test ediniz
kume3 = birlestir({1,3,2,4})
print(kume3)
kume3 = birlestir({1,3,2,4},{2,10,6,1})
print(kume3)
{1, 2, 3, 4}
{1, 2, 3, 4, 6, 10}
Endeks yaratarak ‘iteration’. Küme elemanları sıralı değildir ancak gerekli görürsek birer sayı ile eşleyebiliriz.
for (i, isim) in enumerate(populasyon):
print(i, ' endeksli isim ', isim)
0 endeksli isim Seçil
1 endeksli isim Eylem
2 endeksli isim Barış
3 endeksli isim Ahmet
4 endeksli isim Selin
‘Set comprehension’
Örnek olarak karesinin değeri 30’un altında olan tamsayıları içeren bir küme oluşturan bir ‘set comprehension’ satırı yazalım.
from math import sqrt
{int(sqrt(x)) for x in range(30)}
{0, 1, 2, 3, 4, 5}
7) Python’da ‘dictionary’ kolleksiyonu#
(kaynak1)
Kütüphane (Ing:dictionary) türünü, ‘bir değere eşlenen başka bir değer’den oluşan (‘key’ -> ‘value’) ikilileri tutan bir kolleksiyon olarak düşünebiliriz.
Boş olarak başlatılıp içine öğeler eklenen alttaki örneği inceleyiniz.
plakalar = {} # Kütüphanemizi boş başlatıyoruz
plakalar['Adana'] = 1 # 'Adana' için bir girdi bulunmadığı için yeni bir öğe olarak 'Adana'->1 ekleniyor
plakalar['İstanbul'] = 34 # 'İstanbul' için bir girdi bulunmadığı için yeni bir öğe olarak 'İstanbul'->34 ekleniyor
plakalar['İzmir'] = 35 # 'İzmir' için bir girdi bulunmadığı için yeni bir öğe olarak 'İzmir'->35 ekleniyor
print(plakalar)
{'Adana': 1, 'İstanbul': 34, 'İzmir': 35}
Diğer bir örnek:
oznitelikler = {} # Bir evin özelliklerini taşıyan bir 'dictionary' kurgulayalım
oznitelikler['alan'] = 125
oznitelikler['odaSayisi'] = 3
oznitelikler['mahalle'] = 'Üçkuyular'
oznitelikler['yapiIzniVar'] = True
oznitelikler['birimler'] = ['banyo', 'oda', 'salon','hol']
print(oznitelikler)
{'alan': 125, 'odaSayisi': 3, 'mahalle': 'Üçkuyular', 'yapiIzniVar': True, 'birimler': ['banyo', 'oda', 'salon', 'hol']}
Kütüphane öğelerine erişim örneği:
# Kütüphane oluşturma örneği
kisaltmalar = {"a": "alpha", "o":"omega", "g": 'gamma'}
# Kütüphanedeki anahtarlara erişim ve anahtarlardan değerlere erişim
for key in kisaltmalar.keys():
print(key, ' -> ', kisaltmalar[key])
print('-----------')
# veya anahtar-değer ikilisine doğrudan erişebiliriz
for (key, value) in kisaltmalar.items():
print(key, ' -> ', value)
a -> alpha
o -> omega
g -> gamma
-----------
a -> alpha
o -> omega
g -> gamma
Telefon rehberi örneği:
Kullanıcıdan rehber için isim ve numara okuyan, daha sonra isimle numara arama işlemi yapan kod parçası örneği görelim. \(calistir\) değişkenine True atadıktan sonra (ilk kod satırı) kodu çalıştırınız ve değerler giriniz. Giriş işlemlerini bitirmek için boş giriş yapmanız beklenmektedir.
#Rehberin kullanıcıdan okunan bilgilerle oluşturulması
calistir = False # bu değeri True yaparak kodu çalıştırabilirsiniz
if calistir:
rehber = {}
while True:
isim = input('İsim: ')
if isim == '':
break
rehber[isim] = input('Telefon no:')
print('Rehber oluşturuldu, şimdi isimle numara arayabilirsiniz')
#Rehberin kullanımı
while True:
isim = input('İsim: ')
if isim == '':
break
if isim in rehber.keys():
print(rehber[isim])
else:
print('Rehberde yok')
print('--ELVEDA--')
8) Rasgele sayılar#
(kaynak)
Rasgele sayıları random kütüphanesini kullanarak üretebiliriz. Örnekler görelim:
import random
print('random.random() ile üretilen sayılar:')
for x in range(5):
print(random.random()) # 0-1 arası rasgele ondalık sayı üretimi
print('random.randint(1,10) ile üretilen sayılar:')
for x in range(5):
print(random.randint(1,10)) # 1-10 arası(dahil) rasgele tamsayı üretimi
print('random.randrange(0,100,5) ile üretilen sayılar:')
for x in range(5):
print(random.randrange(0,100,5)) # 0-100 arası 5'er adımlı uzaklıklarda rasgele tamsayı üretimi
random.random() ile üretilen sayılar:
0.9967261715288077
0.9506427937669322
0.9022699416325767
0.506689464389918
0.24101457024416117
random.randint(1,10) ile üretilen sayılar:
3
4
9
7
2
random.randrange(0,100,5) ile üretilen sayılar:
70
35
70
50
55
Örnek: Monte Carlo metoduyla pi sayısının kestirimini yapan bir kod parçası yazınız (yöntemin açıklaması için bakınız.). random.uniform(alt_limit, ust_limit) fonksiyonu ile verilen aralıkta sayı üretebilirsiniz.
dartSayisi = 10000
dairedekiler = 0
for i in range(dartSayisi):
x = random.uniform(-1,1)
y = random.uniform(-1,1)
if x * x + y * y <= 1:
dairedekiler += 1
print('{} adet rasgele dart ile deney yapıldı:'.format(dartSayisi))
print('Pi = ', 4 * dairedekiler / dartSayisi)
10000 adet rasgele dart ile deney yapıldı:
Pi = 3.1348
Örnek: Bir yazı/tura atma deneyi tasarlayın: ardarda 3 tura gelinceye kadar yazı/tura atan bir kod parçası yazınız.
random.choice([‘yazı’, ‘tura’]) ile yazı/tura atabilirsiniz.
ardisikTuraSayisi = 0
deneySayisi = 0
while True:
sonuc = random.choice(['yazı','tura'])
print(sonuc)
deneySayisi += 1
if sonuc == 'tura':
ardisikTuraSayisi += 1
else:
ardisikTuraSayisi = 0
if ardisikTuraSayisi == 3:
break
print('Deney sayisi = ', deneySayisi)
print('---Oyun Bitti---')
tura
yazı
yazı
tura
yazı
yazı
yazı
tura
tura
yazı
tura
tura
tura
Deney sayisi = 13
---Oyun Bitti---
Verilerden rasgele örneklem seçme
Örnek olarak verilen bir listedeki elemanlarının yarısını rasgele seçen bir kod parçası yazalım:
veri = [10,20,30,40,50,60,70,80,90,100] # verilerimizi içeren listeyi tanımladık
random.shuffle(veri) # listenin öğelerinin sırasının karıştırılması
secilenOrnekler = veri[:len(veri)//2] # örneklerin ilk yarısının seçilmesi
print('Verilerden seçilen örnekler: ', secilenOrnekler)
Verilerden seçilen örnekler: [30, 80, 60, 50, 100]
Rasgele örnek seçme (örneğin eldeki verilerin eğitim ve test verisi olarak iki gruba bölünmesi) makine öğrenmesinde sıkça kullanacağımız bir işlem. Ancak bunu numpy veya scikit-learn gibi kütüphanelerdeki fonksiyonlarla yapmak daha kolay olacağı için burada daha fazla detaya girmeyeceğiz. Kısa bir örneği altta bulabilirsiniz.
from sklearn.model_selection import train_test_split
import numpy
veri_np = numpy.array(veri) # veriyi listeden numpy dizisine dönüştürüyoruz
x_train ,x_test = train_test_split(veri, test_size = 0.3) # veriyi %30-%70 ayıran hazır fonksiyonun çağırılması
print('Eğitim için kullanılan veriler: ', x_train)
print('Test için kullanılan veriler: ', x_test)
Eğitim için kullanılan veriler: [100, 40, 10, 30, 80, 70, 20]
Test için kullanılan veriler: [90, 50, 60]
Bu defterde Python kodlama deneyimi bulunmayanlar için kod yazım örnekleri sunduk. Hedefimiz, kitabımızın içeriğinin anlaşılmasını kolaylaştıracak kısa bir yardımcı defter sağlamaktı. Bir sonraki ek dökümanda numpy kütüphanesinin kullanımıyla ilgili benzer bir içerik bulabilirsiniz.
Yazar: Barış Bozkurt, editör: Ahmet Uysal