<jupyter_start><jupyter_text>Bölüm 00: Python'a Giriş  <NAME>ında<NAME> Çalışma Defteri HakkındaBu çalışma defteri Google'ın Jupyter Notebook platformuna benzer özellikler taşıyan Google Colab üzerinde oluşturulmuştur. Google Colab, herhangi bir altyapı düzenlemesine ihtiyaç duymadan Web tabanlı olarak Python kodları yazmanıza ve çalıştırmanıza imkan veren ücretsiz bir platformdur. Platform ile ilgili detaylı bilgiye [https://colab.research.google.com/notebooks/intro.ipynb](https://colab.research.google.com/notebooks/intro.ipynb) adresinden ulaşabilirsiniz.Python'a giriş seviyesinde 10 dersten oluşan bu çalışma defteri daha önce kodlama deneyimi olmayan öğrenenler için hazırlanmıştır. Etkileşimli yapısından dolayı hem konu anlatımlarının hem de çalıştırılabilir örneklerin bir arada olduğu bu yapı, sürekli olarak güncellenebilecek bir altyapıya sahiptir. Bu açıdan çalışma defterinin güncel sürümünü aşağıdaki adresten kontrol etmenizi tavsiye ederim.Sürüm 1.0: [Python 101](https://github.com/orcunmadran/Python101/blob/main/Python_101.ipynb)İyi çalışmalar ve başarılar :)  Kullanım ŞartlarıBu çalışma defteri aşağıda belirtilen şartlar altında, katkıda bulunanlara Atıf vermek ve aynı lisansla paylaşmak kaydıyla ticari amaç dahil olmak üzere her şekilde dağıtabilir, paylaşabilir, üzerinde değişiklik yapılarak yeniden kullanılabilir.---![Atıf-AynıLisanslaPaylaş 4.0 Uluslararası Lisansı](https://i.creativecommons.org/l/by-sa/4.0/88x31.png)Bu çalışma defteri Jetbrains'in "Introduction to Python" dersi temel alınarak hazırlanmış ve Creative Commons [Atıf-AynıLisanslaPaylaş 4.0 Uluslararası Lisansı](http://creativecommons.org/licenses/by-sa/4.0/) ile lisanslanmıştır.---  Bölüm 01: GirişBu bölümde:*   İlk bilgisayar programımız,*   Yorumlar yer almaktadır.  İlk Bilgisayar ProgramımızGeleneksel olarak herhangi bir programlama dilinde yazılan ilk program "Mer<NAME>!"'dır. **Örnek Uygulama:**```print("Mer<NAME>!")```<jupyter_code># Örnek uygulamayı çalıştır
print("Mer<NAME>!")<jupyter_output>Merhaba Dünya!<jupyter_text>**Görev:** Kendinizi dünyaya tanıtacak ilk bilgisayar programını yazın!<jupyter_code>print("Merhaba Python")<jupyter_output>Merhaba Python<jupyter_text>YorumlarPython'daki yorumlar  "hash" karakteriyle başlar ve fiziksel çizginin sonuna kadar uzanır. Yorum yapmak için kullanılan  "hash" karakteri kod satırlarını geçici olarak devre dışı bırakmak amacıyla da kullanılabilir.  **Örnek Uygulama:**``` Bu ilk bilgisayar programım için ilk yorumumprint(" bu bir yorum değildir")print("Merhaba!")   yorumlar kod satırının devamında da yapılabilir.print("Bu kod geçici olarak devre dışı bırakılmıştır.")```<jupyter_code># Örnek uygulamayı çalıştır

# Bu ilk bilgisayar programım için ilk yorumum
print("# bu bir yorum değildir")
print("Merhaba!")  # yorumlar kod satırının devamında da yapılabilir.
# print("Bu kod geçici olarak devre dışı bırakılmıştır.")

#Python öğreniyorum
print("#Python öğreniyorum")<jupyter_output># bu bir yorum değildir
Merhaba!
#Python öğreniyorum<jupyter_text>**Görev:** Python kodunuza yeni bir yorum ekleyin, mevcut satıra yorum ekleyin, yazılmış olan bir kod satırını geçici olarak devre dışı bırakın!<jupyter_code>print("Bu satırın devamına bir yorum ekleyin") #Python öğreniyorum
#print("Bu satırı devre dışı bırakın!")<jupyter_output>Bu satırın devamına bir yorum ekleyin<jupyter_text>Bölüm 02: DeğişkenlerBu bölümde:*   Değişken nedir?,*   Değişken tanımlama,*   Değişken türleri,*   Değişken türü dönüştürme,*   Aritmetik operatörler,*   Artıtılmış atama operatörleri,*   Boolean operatörleri,*   Karşılaştırma operatörleri yer almaktadır.  Değişken Nedir?Değişkenler değerleri depolamak için kullanılır. Böylece daha sonra bu değişkenler program içinden çağırılarak atanan değer tekrar ve tekrar kullanılabilir. Değişkenlere metinler ve / veya sayılar atanabilir. Sayı atamaları direkt rakamların yazılması ile gerçekleştirilirken, metin atamalarında metin tek tırnak içinde ( 'abc' ) ya da çift tırnak ( "abc" ) içinde atanır.Değişkenler etiketlere benzer ve atama operatörü olarak adlandırılan eşittir ( = ) operatörü ile bir değişkene bir değer atanabilir. Bir değer ataması zincirleme şeklinde gerçekleştirilebilir. Örneğin: a = b = 2 **Örnek Uygulama 1**Aşağıda bir "zincir atama" örneği yer almaktadır. Değer olarak atanan 2 hem  "a" değişkenine, hem de "b" değişkenine atanmaktadır.```a = b = 2print("a = " + str(a))print("b = " + str(b))```"a" ve "b" değişkenleri başka metinler ile birlikte ekrana yazdırılmak istendiğinde metin formatına çevrilmesi gerekmektedir. Bu bağlamda kullanılan "str(a)" ve  "str(b)" ifadeleri eğitimin ilerleyen bölümlerinde anlatılacaktır.<jupyter_code># Örnek uygulamayı çalıştır

a = b = 2
print("a = " + str(a))
print("b = " + str(b))

a = b = 5
print("a = " + str(a))
print("b = " + str(b))<jupyter_output>a = 2
b = 2
a = 5
b = 5<jupyter_text>**Örnek Uygulama 2**```adSoyad = "<NAME>"print("Adı Soyadı: " + adSoyad)```<jupyter_code># Örnek uygulamayı çalıştır

adSoyad = "<NAME>"
print("Adı Soyadı: " + adSoyad)

AdSoyad = "<NAME>"
print("Adı Soyadı: " + AdSoyad)<jupyter_output>Adı Soyadı: Orçun Madran
Adı Soyadı: <NAME><jupyter_text>**Görev:** "eposta" adlı bir değişken oluşturun. Oluşturduğunuz bu değişkene bir e-posta adresi atayın. Daha sonra atadığınız bu değeri ekrana yazdırın. Örneğin: "E-posta: orcun[at]madran.net"<jupyter_code># Ekrana e-posta yazdır
Eposta = "<EMAIL>"
print("E-Posta Adresi: " + Eposta)<jupyter_output>E-Posta Adresi: <EMAIL><jupyter_text>Değişken TanımlamaDeğişken isimlerinde uyulması gereken bir takım kurallar vardır:*   Rakam ile başlayamaz.*   Boşluk kullanılamaz.*   Alt tire ( _ ) haricinde bir noktalama işareti kullanılamaz.*   Python içinde yerleşik olarak tanımlanmış anahtar kelimeler kullanılamaz (ör: print).*   Python 3. sürümden itibaren latin dışı karakter desteği olan "Unicode" desteği gelmiştir. Türkçe karakterler değişken isimlerinde kullanılabilir. **Dikkat:** Değişken isimleri büyük-küçük harfe duyarlıdır. Büyük harfle başlanan isimlendirmeler genelde *sınıflar* için kullanılır. Değişken isimlerinin daha anlaşılır olması için deve notasyonu (camelCase) ya da alt tire kullanımı tavsiye edilir. **Örnek Uygulama:**```degisken = 1kullaniciAdi = "orcunmadran"kul_ad = "rafet"``` Henüz tanımlanmamış bir değişken kullanıldığında derleyicinin döndürdüğü hatayı kodu çalıştırarak gözlemleyin!<jupyter_code>degisken1 = "Veri"
print(degisken2)<jupyter_output><empty_output><jupyter_text>**Görev:** Tanımladığınız değişkeni ekrana yazdırın!<jupyter_code>degisken3 = 'Yeni veri'
print("Değişkeni yaz: " + degisken3)<jupyter_output><empty_output><jupyter_text>Değişken TürleriPython'da iki ana sayı türü vardır; tam sayılar ve ondalık sayılar.**Dikkat:** Ondalık sayıların yazımında Türkçe'de *virgül* (,) kullanılmasına rağmen, programlama dillerinin evrensel yazım kuralları içerisinde ondalık sayılar *nokta* (.) ile ifade edilir. **Örnek Uygulama:**```tamSayi = 5print(type(tamSayi))    tamSayi değişkeninin türünü yazdırırondalikSayi = 7.4print(type(ondalikSayi)  ondalikSayi değişkeninin türünü yazdırır```<jupyter_code># Örnek uygulamayı çalıştır

tamSayi = 5
print(type(tamSayi))

ondalikSayi = 7.4
print(type(ondalikSayi))<jupyter_output><empty_output><jupyter_text>**Görev:** "sayi" değişkeninin türünü belirleyerek ekrana yazdırın!<jupyter_code>sayi = 9.0
print(type(sayi))<jupyter_output><empty_output><jupyter_text>Değişken Türü DönüştürmeBir veri türünü diğerine dönüştürmenize izin veren birkaç yerleşik fonksiyon (built-in function) vardır. Bu fonksiyonlar ("int()", "str()", "float()") uygulandıkları değişkeni dönüştürerek yeni bir nesne döndürürler.  **Örnek Uygulama**```sayi = 6.5print(type(sayi))  "sayi" değişkeninin türünü ondalık olarak yazdırırprint(sayi)sayi = int(sayi)   Ondalık sayı olan "sayi" değişkenini tam sayıya dönüştürürprint(type(sayi))print(sayi)sayi = float(sayi)  Tam sayı olan "sayi" değişkenini ondalık sayıya dönüştürürprint(type(sayi))print(sayi)sayi = str(sayi)  "sayi" değişkeni artık düz metin halini almıştırprint(type(sayi))print(sayi)```<jupyter_code># Örnek uygulamayı çalıştır

sayi = 6.5
print(type(sayi))
print(sayi)
 
sayi = int(sayi)
print(type(sayi))
print(sayi)
 
sayi = float(sayi)
print(type(sayi))
print(sayi)
 
sayi = str(sayi)
print(type(sayi))
print(sayi)<jupyter_output><empty_output><jupyter_text>**Görev:** Ondalık sayıyı tam sayıya dönüştürün ve ekrana değişken türünü ve değeri yazdırın!<jupyter_code>sayi = 3.14
print(type(sayi))
print(sayi)

sayi = int(sayi)
print(type(sayi))
print(sayi)

sayi = float(sayi)
print(type(sayi))
print(sayi)

sayi= str(sayi)
print(type(sayi))
print(sayi)
Değer = input("Yaşınızı giriniz")
print(Değer)
print(type(Değer))
print(2022 - int(Değer))
#Doğum Yılı Yazdırma Programı

bulunduğumuzyıl = input("Bulunduğunuz yılı giriniz")
yaş = input("Yaşınızı giriniz")
print(int(bulunduğumuzyıl)- int(yaş))
#Doğum Yılı Yazdırma Programı

#Şimdiki yılı al
syil = input("İçinde bulunduğunuz yılı giriniz")
#Doğum tarihini al
dtarih = input("Doğum tarihinizi giriniz")

#Dönüştürme işlemleri
syil = int(syil)
dtarih = int(dtarih)

#Yaşı hesapla
yas = syil - dtarih

#Yaşı ekrana yazdır
print("Yaşınız: " + str(yas))<jupyter_output><empty_output><jupyter_text>Aritmetik OperatörlerDiğer tüm programlama dillerinde olduğu gibi, toplama (+), çıkarma (-), çarpma (yıldız) ve bölme (/) operatörleri sayılarla kullanılabilir. Bunlarla birlikte Python'un üs (çift yıldız) ve mod (%) operatörleri vardır.**Dikkat:** Matematik işlemlerinde geçerli olan aritmetik operatörlerin öncelik sıralamaları (çarpma, bölme, toplama, çıkarma) ve parantezlerin önceliği kuralları Python içindeki matematiksel işlemler için de geçerlidir.  **Örnek Uygulama:**``` Toplama işlemisayi = 7.0sonuc = sayi + 3.5print(sonuc) Çıkarma işlemisayi = 200sonuc = sayi - 35print(sonuc) Çarpma işlemisayi = 44sonuc = sayi * 10print(sonuc) Bölme işlemisayi = 30sonuc = sayi / 3print(sonuc) Üs alma işlemisayi = 30sonuc = sayi ** 3print(sonuc) Mod alma işlemi sayi = 35sonuc = sayi % 4print(sonuc)```<jupyter_code># Örnek uygulamayı çalıştır

# Toplama işlemi
sayi = 7.0
sonuc = sayi + 3.5
print(sonuc)
 
# Çıkarma işlemi
sayi = 200
sonuc = sayi - 35
print(sonuc)
 
# Çarpma işlemi
sayi = 44
sonuc = sayi * 10
print(sonuc)
 
# Bölme işlemi
sayi = 30
sonuc = sayi / 3
print(sonuc)
 
# Üs alma işlemi
sayi = 30
sonuc = sayi ** 3
print(sonuc)
 
# Mod alma işlemi 
sayi = 35
sonuc = sayi % 4
print(sonuc)<jupyter_output><empty_output><jupyter_text>**Görev:** Aşağıda değer atamaları tamamlanmış olan değişkenleri kullanarak ürünlerin peşin satın alınma bedelini TL olarak hesaplayınız ve ürün adı ile birlikte ekrana yazdırınız! İpucu: Ürün adını ve ürün bedelini tek bir satırda yazdırmak isterseniz ürün bedelini str() fonksiyonu ile düz metin değişken türüne çevirmeniz gerekir.<jupyter_code>urunAdi = "Bisiklet"
urunBedeliAvro = 850
kurAvro = 10
urunAdet = input("Ürün adetini giriniz: ")
pesinAdetIndirimTL = 500
butce = 15000

hesapla = ((urunBedeliAvro* int(urunAdet)) * kurAvro) - pesinAdetIndirimTL
butceTamam = butce > hesapla

print(hesapla)

print("Alışveriş bütçeme uygun mu?" + str(butceTamam))
#Ürünlerin peşin satın alma bedelini TL olarak hesapla, ürün adı ile ekrana yazdır!

urunAdı = "Telefon"
urunBedeliAvro = 2000
kurAvro = 15
urunAdet = input("Ürün adetini giriniz: ")
pesinAdetindirimTL = 500
butce = 30000

hesapla = ((urunBedeliAvro * int(urunAdet)) * kurAvro) - pesinAdetindirimTL

butceTamam = butce > hesapla

print(hesapla)

print("Alışveriş bütçeme uygun mu?" + str(butceTamam))<jupyter_output><empty_output><jupyter_text>Artırılmış Atama OperatörleriArtırılmış atama, bir değişkenin mevcut değerine belirlenen değerin eklenerek ( += ) ya da çıkartılarak ( -= ) atanması işlemidir.  **Örnek Uygulama**```sayi = 8sayi += 4   Mevcut değer olan 8'e 4 daha ekler.print(sayi) sayi -= 6  Mevcut değer olan 12'den 6 eksiltir.print("Sayı = " + str(sayi))```<jupyter_code># Örnek uygulama çalıştır

sayi = 8
sayi += 4
print(sayi) 
 
sayi -= 6 
print("Sayı = " + str(sayi))<jupyter_output><empty_output><jupyter_text>**Görev:** Artıtılmış atama operatörleri kullanarak "sayi" değişkenine 20 ekleyip, 10 çıkartarak değişkenin güncel değerini ekrana yazdırın!<jupyter_code>sayi = 55
sayi += 20
print(sayi)

sayi -= 10
print("Sayı = " + str(sayi))<jupyter_output><empty_output><jupyter_text>Boolean OperatörleriBoolean, yalnızca **Doğru (True)** veya **Yanlış (False)** olabilen bir değer türüdür. Eşitlik (==) operatörleri karşılaştırılan iki değişkenin eşit olup olmadığını kontrol eder ve *True* ya da *False* değeri döndürür. **Örnek Uygulama:**```deger1 = 10deger2 = 10esitMi = (deger1 == deger2)  Eşit olup olmadıkları kontrol ediliyorprint(esitMi)  Değişken "True" olarak dönüyordeger1 = "Python"deger2 = "Piton"esitMi = (deger1 == deger2)  Eşit olup olmadıkları kontrol ediliyorprint(esitMi)  Değişken "False" olarak dönüyor```<jupyter_code># Örnek uygulama çalıştır

deger1 = 10
deger2 = 10
esitMi = (deger1 == deger2) 
print(esitMi) 
 
deger1 = "Python"
deger2 = "Piton"
esitMi = (deger1 == deger2)
print(esitMi)<jupyter_output><empty_output><jupyter_text>**Görev:** Atamaları yapılmış olan değişkenler arasındaki eşitliği kontrol edin ve sonucu ekrana yazıdırın!<jupyter_code>sifre = "Python2020"

sifreTekrar = "Piton2020"

sifrek = input("Şifrenizi giriniz: ")


print(sifrek==sifre)


#Kullanıcı adı ve şifre gir

Kullanıcıadı = "yarengozutok"
Sıfre = "tavsan23"

Kullanıcıadık = input("Kullanıcı adınızı giriniz: ")
Sıfrek = input("Şifrenizi giriniz: ")

print(Kullanıcıadık==Kullanıcıadı)
print(Sıfrek==Sıfre)<jupyter_output><empty_output><jupyter_text>Karşılaştırma OperatörleriPython'da, >=, , < vb. dahil olmak üzere birçok operatör bulunmaktadır. Python'daki tüm karşılaştırma operatörleri aynı önceliğe sahiptir. Karşılaştırma sonucunda boole değerleri (*True* ya da *False*) döner. Karşılaştırma operatörleri isteğe bağlı olarak arka arkaya da (zincirlenerek) kullanılabilir. **Örnek Uygulama:**```deger1 = 5deger2 = 7deger3 = 9print(deger1 < deger2 < deger3)   Sonuç "True" olarak dönecektir```<jupyter_code># Örnek uygulama çalıştır

deger1 = 5
deger2 = 7
deger3 = 9
 
print(deger1 < deger2 < deger3)<jupyter_output><empty_output><jupyter_text>**Görev:** Aşağıda değer atamaları tamamlanmış olan değişkenleri kullanarak ürünlerin peşin satın alınma bedelini TL olarak hesaplayın. Toplam satın alma bedeli ile bütçenizi karşılaştırın. Satın alma bedelini ve bütçenizi ekrana yazdırın. Ödeme bütçenizi aşıyorsa ekrana "False", aşmıyorsa "True" yazdırın.<jupyter_code>urunAdi = "Bisiklet"
urunBedeliAvro = 850
kurAvro = 10
urunAdet = 3
pesinAdetIndirimTL = 500
butce = 20000

hesapla= ((urunBedeliAvro*urunAdet)*kurAvro)- pesinAdetIndirimTL
butceTamam = butce > hesapla
print(hesapla)
print("Alışveriş bütçeme uygun mu? " + str(butceTamam))
yasLimiti = 13
yas = int(input( "Yaşınızı giriniz: "))
kontrol = yas >= yasLimiti

print("Youtube yayınlarını izleyebilir: " + str(kontrol))<jupyter_output><empty_output><jupyter_text>Bölüm 03: Metin KatarlarıBu bölümde:*   Birbirine bağlama,*   Metin katarı çarpımı,*   Metin katarı dizinleme,*   Metin katarı negatif dizinleme,*   Metin katarı dilimleme,*   In operatörü,*   Metin katarının uzunluğu,*   Özel karakterlerden kaçma,*   Basit metin katarı metodları,*   Metin katarı biçimlendirme yer almaktadır.  Birbirine BağlamaBirbirine bağlama artı (+) işlemini kullanarak iki metin katarının birleştirilmesi işlemine denir. **Örnek Uygulama**```deger1 = "Merhaba"deger2 = "Dünya"selamlama = deger1 + " " + deger2print(selamlama)       Çıktı: <NAME>```<jupyter_code># Örnek uygulamayı çalışıtır

deger1 = "Merhaba"
deger2 = "Dünya"

selamlama = deger1 + " " + deger2
print(selamlama)<jupyter_output><empty_output><jupyter_text>**Görev:** *ad*, *soyad* ve *hitap* değişkenlerini tek bir çıktıda birleştirecek kodu yazın!<jupyter_code>hitap = "Öğr. Gör."
ad = "Orçun"
soyad = "Madran"

çıktı = hitap + ad + soyad
print(çıktı)

# Çıktı: Öğr. Gör. <NAME><jupyter_output><empty_output><jupyter_text>Metin Katarı ÇarpımıPython, metin katarlarının çarpım sayısı kadar tekrar ettirilmesini desteklemektedir. **Örnek Uygulama**```metin = "Hadi! "metniCarp = metin * 4print(metniCarp)  Çıktı: Hadi! Hadi! Hadi! Hadi! ```<jupyter_code># Örnek uygulamayı çalıştır

metin = "Hadi! "
metniCarp = metin * 4
print(metniCarp)<jupyter_output><empty_output><jupyter_text>**Görev:** Sizi sürekli bekleten arkadaşınızı uyarabilmek için istediğiniz sayıda "Hadi!" kelimesini ekrana yazdırın!<jupyter_code>metin = "Hadi! "
metniCarp = metin*4
print(metniCarp)

# Çıktı: Hadi! Hadi! Hadi! Hadi! ... Hadi!<jupyter_output><empty_output><jupyter_text>Metin Katarı DizinlemeKonumu biliniyorsa, bir metin katarındaki ilgili karaktere erişilebilir. Örneğin; str[index] metin katarındaki indeks numarasının karşılık geldiği karakteri geri döndürecektir. İndekslerin her zaman 0'dan başladığı unutulmamalıdır. İndeksler, sağdan saymaya başlamak için negatif sayılar da olabilir. -0, 0 ile aynı olduğundan, negatif indeksler -1 ile başlar. **Örnek Uygulama**```metin = "Python Programlama Dili"print("'h' harfini yakala: " + metin[3])  Çıktı: 'h' harfini yakala: h"```<jupyter_code># örnek uygulama çalıştır

metin = "Python Programlama Dili"
print("'h'harfini yakala: " + metin[3])<jupyter_output>'h'harfini yakala: h<jupyter_text>**Görev:** İndeks numarasını kullanarak metin katarındaki ikinci "P" harfini ekrana yazdırın!<jupyter_code>#Çıktı = P

metin ="Python Programlama Dili"
print(metin[0])<jupyter_output>P<jupyter_text>Metin Katarı Negatif DizinlemeMetin katarının sonlarında yer alan bir karaktere daha rahat erişebilmek için indeks numarası negatif bir değer olarak belirlenebilir. **Örnek Uygulama**```metin = "Python Programlama Dili"dHarfi = metin[-4]print(dHarfi)  Çıktı: D```<jupyter_code># Örnek uygulama çalıştır

metin = "Python Programlama Dili"
dHarfi = metin[-4]
print(dHarfi)<jupyter_output>D<jupyter_text>**Görev:** Metin katarının sonunda yer alan "i" harfini ekrana yazdırın!<jupyter_code>metin = "Python Programlama Dili"
print(metin[-1])
#Çıktı: i<jupyter_output>i<jupyter_text>Metin Katarı DilimlemeDilimleme, bir metin katarından birden çok karakter (bir alt katar oluşturmak) almak için kullanılır. Söz dizimi indeks numarası ile bir karaktere erişmeye benzer, ancak iki nokta üst üste işaretiyle ayrılmış iki indeks numarası kullanılır. Ör: str[ind1:ind2].Noktalı virgülün solundaki indeks numarası belirlenmezse ilk karakterden itibaren (ilk karakter dahil) seçimin yapılacağı anlamına gelir. Ör: str[:ind2]Noktalı virgülün sağındaki indeks numarası belirlenmezse son karaktere kadar (son karakter dahil) seçimin yapılacağı anlamına gelir. Ör: str[ind1:] **Örnek Uygulama**```metin = "Python Programlama Dili"dilimle = metin[:6]      print(dilimle)  Çıktı: Pythonmetin = "Python Programlama Dili" print(metin[7:])  Çıktı: Programlama Dili```<jupyter_code># Örnek uygulama çalıştır

metin = "Python Programlama Dili"
dilimle = metin[:6]      
print(dilimle)

metin = "Python Programlama Dili" 
print(metin[7:])<jupyter_output>Python
Programlama Dili<jupyter_text>**Görev:** Metin katarını dilemleyerek katarda yer alan üç kelimeyi de ayrı ayrı (alt alta) ekrana yazdırın!.<jupyter_code># Çıktı:
# Python
# Programlama
# Dili

metin = "Python Programlama Dili" 
dilimle = metin[:6]
print(dilimle)

metin = "Python Programlama Dili"
print(metin[7:])

metin2 = "Python Programlama Dili"
dilimle2 = metin2[7:18]
print(dilimle2)

haber= "But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and I will give you a complete account of the system"
print(haber)
ozet = haber[:40] + " devamı için tıklayınız..."
print(ozet)
haber = "But I must explain to you how all this mistaken idea of denouncing pleasure praising pain was born"
baslangic = haber[:20]
bitis = haber[-20:]
print(baslangic + "......." + bitis)<jupyter_output><empty_output><jupyter_text>In OperatörüBir metin katarının belirli bir harf ya da bir alt katar içerip içermediğini kontrol etmek için, in anahtar sözcüğü kullanılır. **Örnek Uygulama**```metin = "Python Programlama Dili"print("Programlama" in metin)     Çıktı: True``` **Görev:** Metin katarında "Python" kelimesinin geçip geçmediğini kontrol ederek ekrana yazdırın!<jupyter_code>metin = "Python Programlama Dili"
arama = input("Arama yapılacak kelimeyi giriniz: ")
sonuç = arama in metin
print("Aradığınız kelime var: " + str(sonuç))<jupyter_output>Arama yapılacak kelimeyi giriniz: p
Aradığınız kelime var: False<jupyter_text>Metin Katarının UzunluğuBir metin katarının kaç karakter içerdiğini saymak için len() yerleşik fonksiyonu kullanılır.  **Örnek Uygulama**```metin = "Python programlama dili"print(len(metin))  Çıktı: 23```<jupyter_code># Örnek uygulamayı çalıştır

metin = "Python programlama dili"
print(len(metin)) 
# 1-Bir girdiye > klavyeden
# 2-Klavyeden girilen bilginin uzunluğunu hesapla
# 3-Uzunluğu limit ile karşılaştır
# 4-Sonucu ekrana yaz

#Klavyeden girilen metnin 20 karakterden küçük ise false mesajı veren kod.

girilen = input("Metin giriniz: ")
print(girilen)

girilenKarakter = len(girilen)
print(girilenKarakter)

kontrol = girilenKarakter > 10
print(kontrol)<jupyter_output><empty_output><jupyter_text>**Görev:** Metin katarındaki cümlenin ilk yarısını ekrana yazdırın! Yazılan kod cümlenin uzunluğundan bağımsız olarak cümleyi ikiye bölmelidir.<jupyter_code>metin = "Python programlama dili, dünyada eğitim amacıyla en çok kullanılan programlama dillerinin başında gelir."

print(metin[:52])

#yarısı = len(metin)/2

#print(yarısı)





# Çıktı: Python programlama dili, dünyada eğitim amacıyla en<jupyter_output>Python programlama dili, dünyada eğitim amacıyla en<jupyter_text>Özel Karakterlerden KaçmaMetin katarları içerisinde tek ve çift tırnak kullanımı kimi zaman sorunlara yol açmaktadır. Bu karakterin metin katarları içerisinde kullanılabilmesi için "Ters Eğik Çizgi" ile birlikte kullanılırlar. Örneğin: 'Önümüzdeki ay "Ankara'da Python Eğitimi" gerçekleştirilecek' cümlesindeki tek tırnak kullanımı soruna yol açacağından 'Önümüzdeki ay "Ankara\'da Python Eğitimi" gerçekleştirilecek' şeklinde kullanılmalıdır.**İpucu:** Tek tırnaklı metin katarlarından kaçmak için çift tırnak ya da tam tersi kullanılabilir. **Örnek Uygulama**```metin = 'Önümüzdeki ay "Ankara\'da Python Eğitimi" gerçekleştirilecektir.'print(metin) Çıktı: Önümüzdeki ay "Ankara'da Python Eğitimi" gerçekleştirilecektir.metin = 'Önümüzdeki ay "Ankara'da Python Eğitimi" gerçekleştirilecektir.'print(metin)  Çıktı: Geçersiz söz dizimi hatası dönecektir. ```<jupyter_code># Örnek uygulamayı çalıştır

metin = 'Önümüzdeki ay "Ankara\'da Python Eğitimi" gerçekleştirilecektir.'
print(metin)
# Örnek uygulamadaki hatayı gözlemle

metin = 'Önümüzdeki ay "Ankara'da Python Eğitimi" gerçekleştirilecektir.'
print(metin)<jupyter_output><empty_output><jupyter_text>**Görev:** Metin katarındaki cümlede yer alan noktalama işaretlerinden uygun şekilde kaçarak cümleyi ekrana yazdırın!<jupyter_code>metin = "Bilimsel çalışmalarda 'Python' kullanımı Türkiye'de çok yaygınlaştı!"
print(metin)<jupyter_output>Bilimsel çalışmalarda 'Python' kullanımı Türkiye'de çok yaygınlaştı!<jupyter_text>Basit Metin Katarı MetodlarıPython içinde birçok yerleşik metin katarı fonksiyonu vardır. En çok kullanılan fonksiyonlardan bazıları olarak;* tüm harfleri büyük harfe dönüştüren *upper()*,* tüm harfleri küçük harfe dönüştüren *lower()*,* sadece cümlenin ilk harfini büyük hale getiren *capitalize()* sayılabilir.**İpucu:** Python'daki yerleşik fonksiyonların bir listesini görüntüleyebilmek için metin katarından sonra bir nokta (.) koyulur ve uygun olan fonksiyonlar arayüz tarafından otomatik olarak listelenir. Bu yardımcı işlevi tetiklemek için CTRL + Bolşuk tuş kombinasyonu da kullanılabilir. **Örnek Uygulama**```metin = "Python Programlama Dili"print(metin.lower())     Çıktı: python programlama diliprint(metin.upper())     Çıktı: PYTHON PROGRAMLAMA DILIprint(metin.capitalize())     Çıktı: Python programlama dili```<jupyter_code># Örnek uygulamayı çalıştır

metin = "Python Programlama Dili"
print(metin.lower())
print(metin.upper())
print(metin.capitalize())<jupyter_output>python programlama dili
PYTHON PROGRAMLAMA DILI
Python programlama dili<jupyter_text>**Görev:** *anahtarKelime* ve *arananKelime* değişkenlerinde yer alan metinler karşılaştırıldığında birbirlerine eşit (==) olmalarını sağlayın ve dönen değerin "True" olmasını sağlayın!<jupyter_code>anahtarKelime = "Makine Öğrenmesi"
arananKelime = "makine öğrenmesi"

print(anahtarKelime.lower() == arananKelime) # Çıktı: True
print(anahtarKelime.lower())<jupyter_output>True
makine öğrenmesi<jupyter_text>Metin Katarı BiçimlendirmeBir metin katarından sonraki % operatörü, bir metin katarını değişkenlerle birleştirmek için kullanılır. % operatörü, bir metin katarıdanki % s öğesini, arkasından gelen değişkenle değiştirir. % d sembolü ise, sayısal veya ondalık değerler için yer tutucu olarak kullanılır. **Örnek Uygulama**```adsoyad = "<NAME>"dogumTarihi = 1976print("Merhaba, ben %s!" % adsoyad)   Çıktı: Merhaba, ben Orçun Madran!print("Ben %d doğumluyum" % dogumTarihi)   Ben 1976 doğumluyum.ad = "Orçun"soyad = "Madran"print("Merhaba, ben %s %s!" % (ad, soyad))   Çıktı: Merhaba, ben Orçun Madran!```<jupyter_code># Örnek uygulamayı çalıştır

adsoyad = "<NAME>"
dogumTarihi = 1976

print("Merhaba, ben %s!" % adsoyad)
print("Ben %d doğumluyum" % dogumTarihi)
# Örnek uygulamayı çalıştır

ad = "Orçun"
soyad = "Madran"

print("Merhaba, ben %s %s!" % (ad, soyad))<jupyter_output>Merhaba, ben Orçun Madran!<jupyter_text>**Görev:** "<NAME>, bu dönemki dersiniz 'Programlama Dilleri'. Başarılar!" cümlesini ekrana biçimlendirmeyi kullanarak (artı işaretini kullanmadan) yazdırın!<jupyter_code>ad = "Orçun"
soyad = "Madran"
ders = "Programlama Dilleri"
print("Merhaba ben %s %s, bu dönemki dersiniz '%s'.Başarılar!" % (ad, soyad, ders))

# Çıktı: <NAME>, bu dönemki dersiniz "Programlama Dilleri". Başarılar!<jupyter_output>Merhaba ben Or<NAME>, bu dönemki dersiniz 'Programlama Dilleri'.Başarılar!<jupyter_text>21 ŞUBAT 2022 PAZARTESİ (Buraya kadar geldik.) ---<jupyter_code>ad = "Yaren"
soyad = "Gozutok"
ders = "Python"
print("Merhaba ben %s %s, bu dönemki dersim '%s' . Başarılı olacağım!" % (ad, soyad, ders))<jupyter_output>Merhaba ben <NAME>, bu dönemki dersim 'Python' . Başarılı olacağım!<jupyter_text>Bölüm 04: Veri YapılarBu bölümde:*   Listeler,*   Liste işlemleri,*   Liste öğeleri,*   Demetler (Tuples),*   Sözlükler,*   Sözlük değerleri ve anahtarları,*   In anahtar kelimesinin kullanımı yer almaktadır.  ListelerListe, birden fazla değeri tek bir değişken adı altında saklamak için kullanabileceğiniz bir veri yapısıdır. Bir liste köşeli parantez arasında virgülle ayrılmış değerler dizisi olarak yazılır. Ör: liste = [deger1, deger2].Listeler farklı türden öğeler içerebilir, ancak genellikle listedeki tüm öğeler aynı türdedir. Metin katarları gibi listeler de dizine eklenebilir ve dilimlenebilir. (Bkz. Bölüm 3). **Örnek Uygulama**```acikListe = ["Açık Bilim", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]    acikListe adında yeni bir liste oluştururprint(acikListe)  Çıktı: ['Açık Bilim', 'Açık Erişim', 'Açık Veri', 'Açık Eğitim', 'Açık Kaynak']```<jupyter_code># Örnek uygulamayı çalıştır

acikListe = ["Açık Bilim", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]
print(acikListe)<jupyter_output><empty_output><jupyter_text>**Görev 1:** acikListe içinde yer alan 3. liste öğesini ekrana yazıdırın!<jupyter_code>acikListe = ["Açık Bilim", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]
print(acikListe[2])<jupyter_output>Açık Veri<jupyter_text>**Görev 2:** acikListe içinde yer alan 4. ve 5. liste öğesini ekrana yazıdırın!<jupyter_code>acikListe = ["A<NAME>", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]
print(acikListe[3:5])<jupyter_output>['Açık Eğitim', 'Açık Kaynak']<jupyter_text>Liste İşlemleriappend() fonksiyonunu kullanarak ya da artırılmış atama operatörü ( += ) yardımıyla listenin sonuna yeni öğeler (değerler) eklenebilir.  Listelerin içindeki öğeler güncellenebilir, yani liste[indeksNo] = yeni_deger kullanarak içeriklerini değiştirmek mümkündür. **Örnek Uygulama**```acikListe = ["A<NAME>", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]    acikListe adında yeni bir liste oluştururprint(acikListe)  Çıktı: ['Açık Bilim', 'Açık Erişim', 'Açık Veri', 'Açık Eğitim', 'Açık Kaynak']acikListe += ["Açık Donanım", "Açık İnovasyon"]     listeye iki yeni öğe eklerprint(acikListe)  Çıktı: ['Açık Bilim', 'Açık Erişim', 'Açık Veri', 'Açık Eğitim', 'Açık Kaynak', 'Açık Donanım', 'Açık İnovasyon']acikListe.append("Açık Veri Gazeteciliği")    listeye yeni bir öğe eklerprint(acikListe)  Çıktı: ['Açık Bilim', 'Açık Erişim', 'Açık Veri', 'Açık Eğitim', 'Açık Kaynak', 'Açık Donanım', 'Açık İnovasyon', 'Açık Veri Gazeteciliği']acikListe[4] = "Açık Kaynak Kod"  listenin 5. öğesini değiştirirprint(acikListe)  Çıktı: ['Açık Bilim', 'Açık Erişim', 'Açık Veri', 'Açık Eğitim', 'Açık Kaynak Kod', 'Açık Donanım', 'Açık İnovasyon', 'Açık Veri Gazeteciliği']```<jupyter_code># Örnek uygulamayı çalıştır

acikListe = ["Açık Bilim", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]
print(acikListe)
 
acikListe += ["Açık Donanım", "Açık İnovasyon"] 
print(acikListe)
 
acikListe.append("Açık Veri Gazeteciliği")
print(acikListe)
 
acikListe[4] = "Açık Kaynak Kod"
print(acikListe)
#Arkadaş Listesi

Liste = ["Yaren"]
print(Liste)

yeni = input("Arkadaşının adı: ")
Liste.append(yeni)

yeni = input("Arkadaşının adı: ")
Liste.append(yeni)

print(Liste)
#Arkadaş Listesi

liste = ["<NAME>"]
ad = input("Adınızı giriniz: ")
soyad = input("Soyadınızı giriniz: ")
adsoyad = ad + " " + soyad
liste.append(adsoyad)
print(liste)
liste[0]= "Yeni Arkadaş"

print(liste)<jupyter_output>Adınızı giriniz: Bayezıt
Soyadınızı giriniz: Uyanır
['<NAME>', 'Bay<NAME>yanır']
['Yeni Arkadaş', 'Bayezıt Uyanır']<jupyter_text>**Görev:** bilgiBilim adlı bir liste oluşturun. Bu listeye bilgi bilim disiplini ile ilgili 3 adet anahtar kelime ya da kavram ekleyin. Bu listeyi ekrana yazdırın. Listeye istediğiniz bir yöntem ile (append(), +=) 2 yeni öğe ekleyin. Ekrana listenin son durumunu yazdırın. Listenizdeki son öğeyi değiştirin. Listenin son halini ekrana yazıdırn.<jupyter_code>#bilgiBilim

liste = ["Açık Erişim", "Açık Kaynak", "Açık Veri"]
print(liste)

yeni = input("Eklemek istediğiniz kelimeyi girin: ")
liste.append(yeni)

yeni = input("Eklemek istediğiniz kelimeyi girin: ")
liste.append(yeni)

print(liste)<jupyter_output>['Açık Erişim', 'Açık Kaynak', 'Açık Veri']
Eklemek istediğiniz kelimeyi girin: Kamu malı
Eklemek istediğiniz kelimeyi girin: açık lisans
['Açık Erişim', 'Açık Kaynak', 'Açık Veri', 'Kamu malı', 'açık lisans']<jupyter_text>Liste Öğeleri Liste öğelerini dilimleme (slice) yaparak da atamak mümkündür. Bu bir listenin boyutunu değiştirebilir veya listeyi tamamen temizleyebilir. **Örnek Uygulama**```acikListe = ["A<NAME>", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]    acikListe adında yeni bir liste oluştururprint(acikListe)  Çıktı: ['Açık Bilim', 'Açık Erişim', 'Açık Veri', 'Açık Eğitim', 'Açık Kaynak']acikListe[2:4] = ["Açık İnovasyon"]     "Açık Veri" ve "Açık Eğitim" öğelerinin yerine tek bir öğe eklerprint(acikListe)  Çıktı:  ["A<NAME>im", "Açık Erişim", "Açık İnovasyon", "Açık Kaynak"]acikListe[:2] = []      listenin ilk iki öğesini silerprint(acikListe)  Çıktı:  ["Açık İnovasyon", "Açık Kaynak"]acikListe[:] = []  listeyi temizler print(acikListe)  Çıktı: []```<jupyter_code># Örnek uygulamayı çalıştır

acikListe = ["A<NAME>", "Açık Erişim", "Açık Veri", "Açık Eğitim", "Açık Kaynak"]
print(acikListe)

acikListe[2:4] = ["Açık İnovasyon"]
print(acikListe)

acikListe[:2] = []
print(acikListe)

acikListe[:] = []
print(acikListe)<jupyter_output>['Açık Bilim', 'Açık Erişim', 'Açık Veri', 'Açık Eğitim', 'Açık Kaynak']
['Açık Bilim', 'Açık Erişim', 'Açık İnovasyon', 'Açık Kaynak']
['Açık İnovasyon', 'Açık Kaynak']
[]<jupyter_text>**Görev:** Önceki görevde oluşturulan "bilgiBilim" adlı listenin istediğiniz öğesini silerek listenin güncel halini ekrana yazdırın. Listeyi tamamen temizleyerek listenin güncel halini ekrana yazdırın.<jupyter_code>#bilgiBilim
liste = ["Açık Erişim", "Açık Kaynak", "Açık Veri", "Açık Lisans", "Kamu Malı"]
print(liste)

liste [2:4] = ["Açık İnovasyon"]
print(liste)

liste [:2] = []
print(liste)

liste[:] = []
print(liste)<jupyter_output>['Açık Erişim', 'Açık Kaynak', 'Açık Veri', 'Açık Lisans', 'Kamu Malı']
['Açık Erişim', 'Açık Kaynak', 'Açık İnovasyon', 'Kamu Malı']
['Açık İnovasyon', 'Kamu Malı']
[]<jupyter_text>Demetler (Tuples) Demetler neredeyse listelerle aynı. Demetler ve listeler arasındaki tek önemli fark, demetlerin değiştirilememesidir. Demetlere öğe eklenmez, öğe değiştirilmez veya demetlerden öğe silinemez. Demetler, parantez içine alınmış bir virgül operatörü tarafından oluşturulur. Ör: demet = ("deger1", "deger2", "deger3"). Tek bir öğe demetinde ("d",) gibi bir virgül olmalıdır. **Örnek Uygulama**```ulkeKodlari = ("TR", "US", "EN", "JP")print(ulkeKodlari)    Çıktı: ('TR', 'US', 'EN', 'JP')```<jupyter_code># Örnek uygulamayı çalıştır

ulkeKodlari = ("TR", "US", "EN", "JP")
print(ulkeKodlari)<jupyter_output><empty_output><jupyter_text>**Görev:** Kongre Kütüphanesi konu başlıkları listesinin kodlarından oluşan bir demet oluşturun ve ekrana yazdırın! Oluşturulan demet içindeki tek bir öğeyi ekrana yazdırın!<jupyter_code>#konuBasliklari
baslıkkodları = ("CB", "CC", "CT")
print(baslıkkodları)


print(baslıkkodları[2])<jupyter_output>('CB', 'CC', 'CT')
CT<jupyter_text>SözlüklerSözlük, listeye benzer, ancak sözlük içindeki değerlere indeks numarası yerine bir anahtara ile erişilebilir. Bir anahtar herhangi bir metin katarı veya rakam olabilir. Sözlükler ayraç içine alınır. Ör: sozluk = {'anahtar1': "değer1", 'anahtar2': "değer2"}. **Örnek Uygulama**```adresDefteri = {"Hacettepe Üniversitesi": "hacettepe.edu.tr", "ODTÜ": "odtu.edu.tr", "Bilkent Üniversitesi": "bilkent.edu.tr"}  yeni bir sözlük oluştururprint(adresDefteri)  Çıktı: {'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.edu.tr'}adresDefteri["Ankara Üniversitesi"] = "ankara.edu.tr" sözlüğe yeni bir öğe eklerprint(adresDefteri)   Çıktı: {'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.edu.tr', 'Ankara Üniversitesi': 'ankara.edu.tr'}del adresDefteri ["Ankara Üniversitesi"] sözlükten belirtilen öğeyi silerprint(adresDefteri)  Çıktı: {'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.edu.tr'}```<jupyter_code># Örnek uygulamayı çalıştır

adresDefteri = {"Hacettepe Üniversitesi": "hacettepe.edu.tr", "ODTÜ": "odtu.edu.tr", "Bilkent Üniversitesi": "bilkent.edu.tr"}
print(adresDefteri)

adresDefteri["Ankara Üniversitesi"] = "ankara.edu.tr"
print(adresDefteri)

del adresDefteri ["Ankara Üniversitesi"]
print(adresDefteri)<jupyter_output>{'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.edu.tr'}
{'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.edu.tr', 'Ankara Üniversitesi': 'ankara.edu.tr'}
{'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.<EMAIL>'}<jupyter_text>**Görev:** İstediğin herhangi bir konuda 5 öğeye sahip bir sözlük oluştur. Sözlüğü ekrana yazdır. Sözlükteki belirli bir öğeyi ekrana yazdır. Sözlükteki belirli bir öğeyi silerek sözlüğün güncel halini ekrana yazdır!<jupyter_code>#Bilim Sözlüğü

sozluk = {"Açık Erişim": "Kamu Kaynakları..." , "Açık Veri": "Açık olarak..."}
print(sozluk)

sozluk["Açık İnovasyon"] = "Aİ......."
print(sozluk)

del sozluk["Açık Erişim"]
print(sozluk)
sozluk["Açık İnovasyon"] = "Aİ22......."
print(sozluk)

print(sozluk["Açık Veri"])<jupyter_output>{'Açık Erişim': 'Kamu Kaynakları...', 'Açık Veri': 'Açık olarak...'}
{'Açık Erişim': 'Kamu Kaynakları...', 'Açık Veri': 'Açık olarak...', 'Açık İnovasyon': 'Aİ.......'}
{'Açık Veri': 'Açık olarak...', 'Açık İnovasyon': 'Aİ.......'}
{'Açık Veri': 'Açık olarak...', 'Açık İnovasyon': 'Aİ22.......'}
Açık olarak...<jupyter_text>Sözlük Değerleri ve AnahtarlarıSözlüklerde values() ve keys() gibi birçok yararlı fonksiyon vardır. Bir sozlük adı ve ardından noktadan sonra çıkan listeyi kullanarak geri kalan fonksiyolar incelenebilir. **Örnek Uygulama**```adresDefteri = {"Hacettepe Üniversitesi": "hacettepe.edu.tr", "ODTÜ": "odtu.edu.tr", "Bilkent Üniversitesi": "bilkent.edu.tr"}  yeni bir sözlük oluştururprint(adresDefteri)  Çıktı: {'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.edu.tr'}print(adresDefteri.values())  Çıktı: dict_values(['hacettepe.edu.tr', 'odtu.edu.tr', 'bilkent.edu.tr'])print(adresDefteri.keys())  Çıktı: dict_keys(['Hacettepe Üniversitesi', 'ODTÜ', 'Bilkent Üniversitesi'])```<jupyter_code># Örnek uygulamayı çalıştır

adresDefteri = {"Hacettepe Üniversitesi": "hacettepe.edu.tr", "ODTÜ": "odtu.edu.tr", "Bilkent Üniversitesi": "bilkent.edu.tr"}
print(adresDefteri)

print(adresDefteri.values())

print(adresDefteri.keys())<jupyter_output>{'Hacettepe Üniversitesi': 'hacettepe.edu.tr', 'ODTÜ': 'odtu.edu.tr', 'Bilkent Üniversitesi': 'bilkent.edu.tr'}
dict_values(['hacettepe.edu.tr', 'odtu.edu.tr', 'bilkent.edu.tr'])
dict_keys(['Hacettepe Üniversitesi', 'ODTÜ', 'Bilkent Üniversitesi'])<jupyter_text>**Görev:** İstediğin bir konuda istediğin öğe saysına sahip bir sözlük oluştur. Sözlükler ile ilgili farklı fonksiyoları dene. Sonuçları ekrana yazdır!<jupyter_code>#yeniSozluk

sozluk = {"Açık Erişim" : "Kamu kaynakları...", "Açık Veri": "Açık verilere erişim..."}
print(sozluk)

print(sozluk.values())

print(sozluk.keys())<jupyter_output>{'Açık Erişim': 'Kamu kaynakları...', 'Açık Veri': 'Açık verilere erişim...'}
dict_values(['Kamu kaynakları...', 'Açık verilere erişim...'])
dict_keys(['Açık Erişim', 'Açık Veri'])<jupyter_text>In Anahtar Kelimesi"In" anahtar sözcüğü, bir listenin veya sözlüğün belirli bir öğe içerip içermediğini kontrol etmek için kullanılır. Daha önce metin katarlarındaki kullanıma benzer bir kullanımı vardır. "In" anahtar sözcüğü ile öğe kontrolü yapıldıktan sonra sonuç, öğe listede ya da sözlükte yer alıyorsa *True* yer almıyorsa *False* olarak geri döner.**Dikkat**: Aranan öğe ile liste ya da sözlük içinde yer alan öğelerin karşılaştırılması sırasında büyük-küçük harf duyarlılığı bulunmaktadır. Ör: "Bilgi" ve "bilgi" iki farklı öğe olarak değerlendirilir. **Örnek Uygulama**```bilgiKavramları = ["indeks", "erişim", "koleksiyon"]    yeni bir liste oluştururprint("Erişim" in bilgiKavramları)     Çıktı: FalsebilgiSozlugu = {"indeks": "index", "erişim": "access", "koleksiyon": "collection"}    yeni bir sozluk oluştururprint("koleksiyon" in bilgiSozlugu.keys())    çıktı: True```<jupyter_code># Örnek uygulamayı çalıştır

bilgiKavramları = ["indeks", "erişim", "koleksiyon"]
print("Erişim" in bilgiKavramları)

bilgiSozlugu = {"indeks": "index", "erişim": "access", "koleksiyon": "collection"}
print("koleksiyon" in bilgiSozlugu.keys())<jupyter_output>False
True<jupyter_text>**Görev:** Bir liste ve bir sözlük oluşturun. Liste içinde istediğiniz kelimeyi aratın ve sonucunu ekrana yazdırın! Oluşturduğunuz sözlüğün içinde hem anahtar kelime (keys()) hem de değer (values()) kontrolü yaptırın ve sonucunu ekrana yazdırın!<jupyter_code>#yeniListe
dersler = ["Bilgi Erişim", "Bilgi Hizmetleri", "Bilginin Düzenlenmesi"]
print("Bilgi Hizmetleri" in dersler)

#yeniSozluk
derssozlugu = {"Bilgi Erişim":"Bilgiye kolay eriştirme...", "Bilginin Düzenlenmesi": "AACR ve Marc..."}
print(derssozlugu.values())
print(derssozlugu.keys())<jupyter_output>True
dict_values(['Bilgiye kolay eriştirme...', 'AACR ve Marc...'])
dict_keys(['<NAME>', '<NAME>'])<jupyter_text>Bölüm 05: Koşullu İfadelerBu bölümde:*   Mantıksal operatörler,*   If cümleciği,*   Else ve elif kullanımı yer almatadır. Mantıksal OperatörlerMantıksal operatörler ifadeleri karşılaştırır ve sonuçları *True* ya da *False* değerleriyle döndürür. Python'da üç tane mantıksal operatör bulunur:1. "and" operatörü: Her iki yanındaki ifadeler doğru olduğunda *True* değerini döndürür.2. "or" operatörü: Her iki tarafındaki ifadelerden en az bir ifade doğru olduğunda "True" değerini döndürür.3. "not" operatörü: İfadenin tam tersi olarak değerlendirilmesini sağlar. **Örnek Uygulama**```kullaniciAdi = "orcunmadran"sifre = 123456print(kullaniciAdi == "orcunmadran" and sifre == 123456)  Çıktı: TruekullaniciAdi = "orcunmadran"sifre = 123456print(kullaniciAdi == "orcunmadran" and not sifre == 123456)  Çıktı: FalsecepTel = "05321234567"ePosta = "<EMAIL>"print(cepTel == "" or ePosta == "<EMAIL>" )  Çıktı: True```<jupyter_code># Örnek uygulamayı çalıştır

kullaniciAdi = "orcunmadran"
sifre = 123456
print(kullaniciAdi == "orcunmadran" and sifre == 123456)

kullaniciAdi = "orcunmadran"
sifre = 123456
print(kullaniciAdi == "orcunmadran" and not sifre == 123456)

cepTel = "05321234567"
ePosta = "<EMAIL>"
print(cepTel == "" or ePosta == "<EMAIL>" )<jupyter_output>True
False
True<jupyter_text>**Görev:** Klavyeden girilen kullanıcı adı ve şifrenin kayıtlı bulunan kullanıcı adı ve şifre ile uyuşup uyuşmadığını kontrol edin ve sonucu ekrana yazdırın!<jupyter_code>#Sistemde yer alan bilgiler:
sisKulAdi = "yonetici"
sisKulSifre = "bby162"

#Klavyeden girilen bilgiler:
girKulAdi = input("Kullanıcı Adı: ")
girKulSifre = input("Şifre: ")

#Kontrol
sonuc = sisKulAdi == girKulAdi and sisKulSifre == girKulSifre

#Sonuç
print(sonuc)
kuladı = "yaren"
kulsifre = "12345"

girkuladı = input("Kullanıcı Adı: ")
girkulsifre = input("Şifre: ")

sonuc = kuladı == girkuladı and kulsifre == girkulsifre

print(sonuc)<jupyter_output>Kullanıcı Adı: yaren
Şifre: 12345
True<jupyter_text>Birden fazla koşulu and ile birleştirebiliyoruz 28 ŞUBAT 2022 PAZARTESİ (Buraya kadar geldik.)  If Cümleciği"If" anahtar sözcüğü, verilen ifadenin doğru olup olmadığını kontrol ettikten sonra belirtilen kodu çalıştıran bir koşullu ifade oluşturmak için kullanılır. Python'da kod bloklarının tanımlanması için girinti kullanır. and ve or ile farklı kurgulanabiliyor. **Örnek Uygulama**```acikKavramlar = ["bilim", "erişim", "veri", "eğitim"]kavram = input("Bir açık kavramı yazın: ")if kavram in acikKavramlar:  print(kavram + " açık kavramlar listesinde yer alıyor!")``` : ile if cümleciği kapatılıyor.kendine ait olan alt satırların devreye girip girmemesini kontrol ediyor.<jupyter_code>#Örnek derste
deger= 1
deger2= 2
if deger == deger2:
  print("birbirine eşit")

if deger != deger2:
  print("birbirine eşit değil")


#kendi örneğim

deger = 1453
deger2 = 1071
if deger == deger2:
  print("birbirine eşit")

if deger != deger2:
  print("birbirine eşit değil")
# Örnek uygulamayı çalıştır

acikKavramlar = ["bilim", "erişim", "veri", "eğitim"]
kavram = input("Bir açık kavramı yazın: ")
if kavram in acikKavramlar:
  print(kavram + " açık kavramlar listesinde yer alıyor!")<jupyter_output>Bir açık kavramı yazın: bilim
bilim açık kavramlar listesinde yer alıyor!<jupyter_text>**Görev:** "acikSozluk" içinde yer alan anahtarları (keys) kullanarak eğer klavyeden girilen anahtar kelime sözlükte varsa açıklamasını ekrana yazdırın!<jupyter_code>acikSozluk = {
    "<NAME>" : "B<NAME> kamu malıdır. Bilimsel yayınlara ve verilere açık erişim bir haktır." ,
    "Açık Erişim" : "Kamu kaynakları ile yapılan araştırmalar sonucunda üretilen yayınlara ücretsiz erişim" ,
    "Açık Veri" : "Kamu kaynakları ile yapılan araştırma sonucunda üretilen verilere ücretsiz ve yeniden kullanılabilir biçimde erişim" 
    }
anahtar = input("Anahtar Kelime: ")
if anahtar in acikSozluk:
  print(anahtar + " Açık sözlükte yer alıyor!")

#If<jupyter_output>Anahtar Kelime: Açık Veri
Açık Veri Açık sözlükte yer alıyor!<jupyter_text>Else ve Elif Kullanımı"If" cümleciği içinde ikinci bir ifadenin doğruluğunun kontrolü için "Elif" ifadesi kullanılır. Doğruluğu sorgulanan ifadelerden hiçbiri *True* döndürmediği zaman çalışacak olan kod bloğu "Else" altında yer alan kod bloğudur.  **Örnek Uygulama**```gunler = ["Pazartesi", "Çarşamba", "Cuma"]girilen = input("Gün giriniz: ")if girilen == gunler[0]:  print("Programlama Dilleri")elif girilen == gunler[1]:  print("Kataloglama")elif girilen == gunler[2]:  print("Bilimsel İletişim")else :  print("Kayıtlı bir gün bilgisi girmediniz!")```<jupyter_code># Örnek uygulamayı çalıştır

gunler = ["Pazartesi", "Çarşamba", "Cuma"]
girilen = input("Gün giriniz: ")
if girilen == gunler[0]:
  print("Programlama Dilleri")
elif girilen == gunler[1]:
  print("Kataloglama")
elif girilen == gunler[2]:
  print("Bilimsel İletişim")
else :
  print("Kayıtlı bir gün bilgisi girmediniz!")
gunler = ["Pazartesi", "Salı", "Çarşamba", "Perşembe"]
girilen = input("Gün giriniz: ")
if girilen == gunler[0]:
  print("Programlama Dilleri")
elif girilen == gunler[1]:
  print("Türk Dili")
elif girilen == gunler[2]:
  print("Bilimsel İletişim ve Bilgi Erişim")
elif girilen == gunler[3]:
  print("Bilginin Düzenlenmesi")

else :
  print("Kayıtlı bir gün girmediniz! ")<jupyter_output>Gün giriniz: Salı
<NAME><jupyter_text>Elif birden fazla durum kontrol etmek için kullanılıyor. **Görev:** Klavyeden girilen yaş bilgisini kullanarak ekrana aşağıdaki mesajları yazdır:*   21 yaş altı ve 64 yaş üstü kişilere: "Sokağa çıkma yasağı bulunmaktadır!"*   Diğer tüm kişilere: "Sokağa çıkma yasağı yoktur!"*   Klavyeden yaş harici bir bilgi girişi yapıldığında: "Yaşınızı rakam olarak giriniz!"<jupyter_code>yas = int(input("Yaşınızı giriniz: "))
if yas < 21:
  print("Sokağa çıkma yasağı bulunmaktadır!")
elif yas > 64:
  print("Sokağa çıkma yasağı bulunmaktadır!")
else:
  print("Sokağa çıkma yasağı yoktur!")<jupyter_output><empty_output><jupyter_text>7 MART PAZARTESİ (Buraya kadar geldik.)  Bölüm 06: DöngülerBu bölümde:*   for döngüsü,*   Metin katarlarında for döngüsü kullanımı,*   while döngüsü,*   break anahtar kelimesi,*   continue anahtar kelimesi yer almaktadır.  for Döngüsüfor döngüleri belirli komut satırını ya da satırlarını yinelemek (tekrar etmek) için kullanılır. Her yinelemede, for döngüsünde tanımlanan değişken listedeki bir sonraki değere otomatik olarak atanacaktır. **Örnek Uygulama**```for i in range(5):   i değerine 0-4 arası indeks değerleri otomatik olarak atanır    print(i)   Çıktı: Bu komut satırı toplam 5 kere tekrarlanır ve her satırda yeni i değeri yazdırılırkonular = ["<NAME>", "Açık Erişim", "Açık Veri"]    yeni bir liste oluştururfor konu in konular:    print(konu) Çıktı: Her bir liste öğesi alt alta satırlara yazdırılır```<jupyter_code># Örnek uygulmayı çalıştır

for i in range(5):
    print(i+1) #Sıfırı ekranda görmemek için +1 ekledik. 
#Ders örneği
liste = []
for i in range(3):
  veri = input("Giriş yap: ")
  liste.append(veri)
  print(liste)
!range for sonraası indeks numarası atıyor
range kullanmadığımızda listenin elemanlarını ekliyor
# Örnek uygulmayı çalıştır

konular = ["<NAME>", "Açık Erişim", "Açık Veri", "Açık Donanım"]

for konu in konular:
    print(konu)<jupyter_output><NAME>
Açık Erişim
Açık Veri
Açık Donanım<jupyter_text>! Liste içindeki eleman sayısı kadar otomatik for döngüsü yapabilir. **Görev:** Bir liste oluşturun. Liste öğelerini "for" döngüsü kullanarak ekrana yazdırın!<jupyter_code>#liste
liste = ["elma", "armut", "kivi", "muz"]
for yazdır in liste:
  print(yazdır)<jupyter_output>elma
armut
kivi
muz<jupyter_text>Metin Katarlarında for Döngüsü KullanımıMetin Katarları üzerinde gerçekleştirilebilecek işlemler Python'daki listelerle büyük benzerlik taşırlar. Metin Katarını oluşturan öğeler (harfler) liste elemanları gibi "for" döngüsü yardımıyla ekrana yazdırılabilir.  **Örnek Uygulama**```cumle = "Bisiklet hem zihni hem bedeni dinç tutar!"for harf in cumle:     Cümledeki her bir harfi ekrana satır satır yazdırır    print(harf)```<jupyter_code># Örnek uygulamayı çalıştır

cumle = "Bisiklet hem zihni, hem bedeni dinç tutar!"
 
for harf in cumle:
    print(harf)<jupyter_output>B
i
s
i
k
l
e
t
 
h
e
m
 
z
i
h
n
i
,
 
h
e
m
 
b
e
d
e
n
i
 
d
i
n
ç
 
t
u
t
a
r
!<jupyter_text>**Görev:** İçinde metin katarı bulunan bir değişken oluşturun. Bu değişkende yer alan her bir harfi bir satıra gelecek şekilde "for" döngüsü ile ekrana yazdırın!<jupyter_code>#degisken
cumle = "<NAME>"
for harf in cumle:
  print(harf)<jupyter_output>B
e
n
i
m
 
a
d
ı
m
 
Y
a
r
e
n<jupyter_text>while Döngüsü"While" döngüsü "if" cümleciğinin ifade şekline benzer. Koşul doğruysa döngüye bağlı kod satırı ya da satırları yürütülür (çalıştırılır). Temel fark, koşul doğru (True) olduğu olduğu sürece bağlı kod satırı ya da satırları çalışmaya devam eder. **Örnek Uygulama**```deger = 1while deger <= 10:    print(deger)     Bu satır 10 kez tekrarlanacak    deger += 1       Bu satır da 10 kez tekrarlanacakprint("Program bitti")   Bu satır sadece bir kez çalıştırılacak```<jupyter_code># Örnek uygulamayı çalıştır

deger = 1

while deger <= 10:
    print(deger)
    deger += 1
    
print("Program bitti")<jupyter_output>1
2
3
4
5
6
7
8
9
10
Program bitti<jupyter_text>break Anahtar KelimesiAsla bitmeyen döngüye sonsuz döngü adı verilir. Döngü koşulu daima doğru (True) olursa, böyle bir döngü sonsuz olur. "Break" anahtar kelimesi geçerli döngüden çıkmak için kullanılır. **Örnek Uygulama**```sayi = 0while True:   bu döngü sonsuz bir döngüdür    print(sayi)    sayi += 1    if sayi >= 5:        break    sayı değeri 5 olduğunda döngü otomatik olarak sonlanır```<jupyter_code># Örnek Uygulamayı çalıştır

sayi = 0

while True:
    print(sayi)
    sayi += 1
    if sayi >= 5:
        break<jupyter_output>0
1
2
3
4<jupyter_text>continue Anahtar Kelimesi"continue" anahtar kelimesi, o anda yürütülen döngü için döngü içindeki kodun geri kalanını atlamak ve "for" veya "while" deyimine geri dönmek için kullanılır. ```for i in range(5):    if i == 3:        continue    i değeri 3 olduğu anda altta yer alan "print" komutu atlanıyor.    print(i)```<jupyter_code># Örnek Uygulamayı çalıştır

for i in range(5):
    if i == 3:
        continue
    print(i)<jupyter_output>0
1
2
4<jupyter_text>Belirli bir kısmı atlamak için de kullanıyorduk. **Görev: Tahmin Oyunu**"while" döngüsü kullanarak bir tahmin oyunu tasarla. Bu tahmin oyununda, önceden belirlenmiş olan kelime ile klavyeden girilen kelime karşılaştırılmalı, tahmin doğru ise oyun "Bildiniz..!" mesajı ile sonlanmalı, yanlış ise tahmin hakkı bir daha verilmeli.<jupyter_code>#Tahmin Oyunu
kelime = "bilgi"
tahmin = ""
print("Kelime tahmin oyununa hoş geldiniz! ")

oyuncuismi = input("İsminizi giriniz: ")

kelime = "erişim"
tahmin = input("Tahmininizi giriniz: " )
while tahmin == kelime:
  print("Bildiniz")
  break
else:
  print("Bilemediniz")<jupyter_output>Kelime tahmin oyununa hoş geldiniz! 
İsminizi giriniz: Yaren
Tahmininizi giriniz: kkk
Bilemediniz<jupyter_text>Bölüm 07: Fonksiyonlar  Fonksiyon Tanımlama (Definition)Fonksiyonlar, yazılan kodu faydalı bloklara bölmenin, daha okunabilir hale getirmenin ve tekrar kullanmaya yardımcı olmanın kullanışlı bir yoludur. Fonksiyonlar "def" anahtar sözcüğü ve ardından fonksiyonun adı kullanılarak tanımlanır. **Örnek Uygulama**```def merhaba_dunya():   fonksiyon tanımlama, isimlendirme    print("Merhaba Dünya!") fonksiyona dahil kod satırlarıfor i in range(5):    merhaba_dunya()    fonksiyon 5 kere çağırılacak```<jupyter_code># Örnek uygulamayı çalıştır

def merhaba_dunya():  # fonksiyon tanımlama, isimlendirme
    print("Merhaba Dünya!") #fonksiyona dahil kod satırları

for i in range(5):
    merhaba_dunya()   # fonksiyon 5 kere çağırılacak<jupyter_output><empty_output><jupyter_text>Fonksiyolarda Parametre KullanımıFonksiyon parametreleri, fonksiyon adından sonra parantez () içinde tanımlanır. Parametre, iletilen bağımsız değişken için değişken adı görevi görür. **Örnek Uygulama**```def foo(x):     x bir fonksiyon parametresidir    print("x = " + str(x))foo(5)    5 değeri fonksiyona iletilir ve değer olarak kullanılır.```<jupyter_code># Örnek uygulamayı çalıştır

def foo(x):
    print("x = " + str(x))

foo(5)<jupyter_output>x = 5<jupyter_text>**Görev:** *karsila* fonksiyonunun tetiklenmesi için gerekli kod ve parametleri ekle!<jupyter_code>def karsila(kAd, kSoyad):
  print("Hoşgeldin, %s %s" % (kAd, kSoyad))<jupyter_output><empty_output><jupyter_text>Return DeğeriFonksiyonlar, "return" anahtar sözcüğünü kullanarak fonksiyon sonucunda bir değer döndürebilir. Döndürülen değer bir değişkene atanabilir veya sadece örneğin değeri yazdırmak için kullanılabilir. **Örnek Uygulama**```def iki_sayi_topla(a, b):    return a + b     hesaplama işleminin sonucu değer olarak döndürülüyorprint(iki_sayi_topla(3, 12))   ekrana işlem sonucu yazdırılacak```<jupyter_code># Örnek uygulamayı çalıştır

def iki_sayi_topla(a, b):
    return a + b

print(iki_sayi_topla(3, 12))<jupyter_output>15<jupyter_text>Varsayılan ParametrelerBazen bir veya daha fazla fonksiyon parametresi için varsayılan bir değer belirtmek yararlı olabilir. Bu, ihtiyaç duyulan parametrelerden daha az argümanla çağrılabilen bir fonksiyon oluşturur. **Örnek Uygulama**```def iki_sayi_carp(a, b=2):    return a * bprint(iki_sayi_carp(3, 47))  verilen iki degeri de kullanır print(iki_sayi_carp(3))     verilmeyen 2. değer yerine varsayılanı kullanır```<jupyter_code># Örnek uygulamayı çalıştır

def iki_sayi_carp(a, b=2):
    return a * b

print(iki_sayi_carp(3, 47))
print(iki_sayi_carp(3))<jupyter_output>141
6<jupyter_text>**Örnek Uygulama: Sayısal Loto**Aşağıda temel yapısı aynı olan iki *sayısal loto* uygulaması bulunmaktadır: Fonksiyonsuz ve fonksiyonlu.İlk sayısal loto uygulamasında herhangi bir fonksiyon kullanımı yoktur. Her satırda 1-49 arası 6 adet sayının yer aldığı 6 satır oluşturur.İkinci sayısal loto uygulamsında ise *tahminEt* isimli bir fonksiyon yer almaktadır. Bu fonksiyon varsayılan parametrelere sahiptir ve bu parametreler fonksiyon çağırılırken değiştirilebilir. Böylece ilk uygulamadan çok daha geniş seçenekler sunabilir bir hale gelmiştir.<jupyter_code>#Sayısal Loto örnek uygulama (fonksiyonsuz)

from random import randint
i = 0
secilenler = [0,0,0,0,0,0]
for rastgele in secilenler:
    while i < len(secilenler):
        secilen = randint(1, 49)
        if secilen not in secilenler:
            secilenler[i] = secilen
            i+=1
    print(sorted(secilenler))
    i=0
#Sayısal Loto örnek uygulama (fonksiyonlu)

from random import randint
def tahminEt(rakam=6, satir=6, baslangic=1, bitis=49):
  i = 0
  secilenler = []
  for liste in range(rakam):
    secilenler.append(0)
  for olustur in range(satir):
      while i < len(secilenler):
          secilen = randint(baslangic, bitis)
          if secilen not in secilenler:
              secilenler[i] = secilen
              i+=1
      print(sorted(secilenler))
      i=0
tahminEt(10,6,1,60)<jupyter_output><empty_output><jupyter_text>**Görev:** Bu görev genel olarak fonksiyon bölümünü kapsamaktadır.Daha önce yapmış olduğunuz "<NAME>" projesini (ya da aşağıda yer alan örneği) fonksiyonlar kullanarak oyun bittiğinde tekrar başlatmaya gerek duyulmadan yeniden oynanabilmesine imkan sağlayacak şekilde yeniden kurgulayın.Oyunun farklı sekansları için farklı fonksiyonlar tanımlayarak oyunu daha optimize hale getirmeye çalışın.Aşağıda bir adam asmaca oyununun temel özellikerine sahip bir örnek yer almaktadır.<jupyter_code>#Fonksiyonsuz <NAME>

from random import choice

adamCan = 3

kelimeler = ["bisiklet", "triatlon", "yüzme", "koşu"]
secilenKelime = choice(kelimeler)
print(secilenKelime)
dizilenKelime = []
for diz in secilenKelime:
    dizilenKelime.append("_")
print(dizilenKelime)

while adamCan > 0:
    girilenHarf = input("Bir harf giriniz: ")
    canKontrol = girilenHarf in secilenKelime
    if canKontrol == False:
        adamCan-=1
    i = 0
    for kontrol in secilenKelime:
        if secilenKelime[i] == girilenHarf:
            dizilenKelime[i] = girilenHarf
        i+=1
    print(dizilenKelime)
    print("Kalan can: "+ str(adamCan))
#Fonksiyonlu <NAME><jupyter_output><empty_output><jupyter_text>Bölüm 08: Sınıflar ve NesnelerBu bölümde:*   Sınıf ve nesne tanımlama,*   Değişkenlere erişim,*   self parametresi,*   init metodu yer almaktadır.  Sınıf ve Nesne TanımlamaBir nesne değişkenleri ve fonksiyonları tek bir varlıkta birleştirir. Nesneler değişkenlerini ve fonksiyonlarını sınıflardan alır. Sınıflar bir anlamda nesnelerinizi oluşturmak için kullanılan şablonlardır. Bir nesneyi, fonksiyonların yanı sıra veri içeren tek bir veri yapısı olarak düşünebilirsiniz. Nesnelerin fonksiyonlarına yöntem (metod) denir.**İpucu:** Sınıf isimlerinin baş harfi büyük yazılarak Python içindeki diğer öğelerden (değişken, fonksiyon vb.) daha rahat ayırt edilmeleri sağlanır. **Örnek Uygulama**```class BenimSinifim:  yeni bir sınıfın tanımlanması        bsDegisken = 4   sınıf içinde yer alan bir değişken    def bsFonksiyon(self): sınıf içinde yer alan bir fonksiyon        print("Benim sınıfımın fonksiyonundan Merhaba!")benimNesnem = BenimSinifim()``` Değişkenlere ve Fonksiyonlara ErişimSınıftan örneklenen bir nesnenin içindeki bir değişkene ya da fonksiyona erişmek için öncelikle nesnenin adı daha sonra ise değişkenin ya da fonkiyonun adı çağırılmalıdır (Ör: nesneAdi.degiskenAdi). Bir sınıfın farklı örnekleri (nesneleri) içinde tanımlanan değişkenlerin değerleri değiştirebilir. **Örnek Uygulama 1**```class BenimSinifim:    yeni bir sınıf oluşturur    bsDegisken = 3     sınıfın içinde bir değişken tanımlar    def bsFonksiyon(self):  sınıfın içinde bir fonksiyon tanımlar        print("Benim sınıfımın fonksiyonundan Merhaba!")benimNesnem = BenimSinifim()  sınıftan yeni bir nesne oluştururfor i in range(benimNesnem.bsDegisken):    oluşturulan nesne üzerinden değişkene ve fonksiyona ulaşılır  benimNesnem.bsFonksiyon()benimNesnem.bsDegisken = 5    sınıfın içinde tanımlanan değişkene yeni değer atanmasıfor i in range(benimNesnem.bsDegisken):  benimNesnem.bsFonksiyon()```<jupyter_code># Örnek uygulama 1'i gözlemleyelim

class BenimSinifim:   
    bsDegisken = 3
    def bsFonksiyon(self):
        print("Benim sınıfımın fonksiyonundan Merhaba!")

benimNesnem = BenimSinifim()

for i in range(benimNesnem.bsDegisken):
  benimNesnem.bsFonksiyon()

benimNesnem.bsDegisken = 5

for i in range(benimNesnem.bsDegisken):
  benimNesnem.bsFonksiyon()<jupyter_output>Benim sınıfımın fonksiyonundan Merhaba!
Benim sınıfımın fonksiyonundan Merhaba!
Benim sınıfımın fonksiyonundan Merhaba!
Benim sınıfımın fonksiyonundan Merhaba!
Benim sınıfımın fonksiyonundan Merhaba!
Benim sınıfımın fonksiyonundan Merhaba!
Benim sınıfımın fonksiyonundan Merhaba!
Benim sınıfımın fonksiyonundan Merhaba!<jupyter_text>Programı yaz belirli bölümlerini tekrar lkullanma ihtiyacı sınıf. (Büyük parça) **Örnek Uygulama 2**```class Bisiklet:    renk = "Kırmızı"    vites = 1    def ozellikler(self):        ozellikDetay = "Bu bisiklet %s renkli ve %d viteslidir." % (self.renk, self.vites)        return ozellikDetaybisiklet1 = Bisiklet()bisiklet2 = Bisiklet()print("Bisiklet 1: " + bisiklet1.ozellikler())bisiklet2.renk = "Sarı"bisiklet2.vites = 22print("Bisiklet 2: " + bisiklet2.ozellikler())```<jupyter_code># Örnek uygulama 2'i gözlemleyelim

class Bisiklet:
    renk = "Kırmızı"
    vites = 1
    def ozellikler(self):
        ozellikDetay = "Bu bisiklet %s renkli ve %d viteslidir." % (self.renk, self.vites)
        return ozellikDetay

bisiklet1 = Bisiklet()
bisiklet2 = Bisiklet()

print("Bisiklet 1: " + bisiklet1.ozellikler())

bisiklet2.renk = "Sarı"
bisiklet2.vites = 22

print("Bisiklet 2: " + bisiklet2.ozellikler())<jupyter_output><empty_output><jupyter_text>self Parametresi"self" parametresi bir Python kuralıdır. "self", herhangi bir sınıf yöntemine iletilen ilk parametredir. Python, oluşturulan nesneyi belirtmek için self parametresini kullanır. **Örnek Uygulama**Aşağıdaki örnek uygulamada **Bisiklet** sınıfının değişkenleri olan *renk* ve *bisiklet*, sınıf içindeki fonksiyonda **self** parametresi ile birlikte kullanılmaktadır. Bu kullanım şekli sınıftan oluşturulan nesnelerin tanımlanmış değişkenlere ulaşabilmeleri için gereklidir.```class Bisiklet:    renk = "Kırmızı"    vites = 1    def ozellikler(self):        ozellikDetay = "Bu bisiklet %s renkli ve %d viteslidir." % (self.renk, self.vites)        return ozellikDetay```<jupyter_code># Örnek uygulamada "self" tanımlaması yapılmadığı zaman döndürülen hata kodunu inceleyin

class Bisiklet:
    renk = "Kırmızı"
    vites = 1
    def ozellikler(self):
        ozellikDetay = "Bu bisiklet %s renkli ve %d viteslidir." % (renk, vites) #tanımlama eksik
        return ozellikDetay

bisiklet1 = Bisiklet()
bisiklet2 = Bisiklet()

print("Bisiklet 1: " + bisiklet1.ozellikler())

bisiklet2.renk = "Sarı"
bisiklet2.vites = 22

print("Bisiklet 2: " + bisiklet2.ozellikler())<jupyter_output><empty_output><jupyter_text>__init__ Metodu__init__ fonksiyonu, oluşturduğu nesneleri başlatmak için kullanılır. init "başlat" ın kısaltmasıdır. __init__() her zaman yaratılan nesneye atıfta bulunan en az bir argüman alır: "self". **Örnek Uygulama**Aşağıdaki örnek uygulamada *sporDali* sınıfının içinde tanımlanan **init** fonksiyonu, sınıf oluşturulduğu anda çalışmaya başlamaktadır. Fonksiyonun ayrıca çağırılmasına gerek kalmamıştır.```class sporDali:  sporlar = ["Yüzme", "Bisiklet", "Koşu"]  def __init__(self):    for spor in self.sporlar:      print(spor + " bir triatlon branşıdır.")triatlon = sporDali()```<jupyter_code># Örnek uygulamayı çalıştır

class sporDali:
  sporlar = ["Yüzme", "Bisiklet", "Koşu"]
  def __init__(self):
    for spor in self.sporlar:
      print(spor + " bir triatlon branşıdır.")

triatlon = sporDali()
# Örnek uygulamayı > Duatlon

class sporDali:
  sporlar = ["Yüzme", "Bisiklet", "Koşu"]
  def __init__(self):
    for spor in self.sporlar:
      print(spor + " bir triatlon branşıdır.")

triatlon = sporDali()<jupyter_output>Yüzme bir triatlon branşıdır.
Bisiklet bir triatlon branşıdır.
Koşu bir triatlon branşıdır.<jupyter_text>Bölüm 09: Modüller ve Paketler Modülün İçe AktarılmasıPython'daki modüller, Python tanımlarını (sınıflar, fonksiyonlar vb.) ve ifadelerini (değişkenler, listeler, sözlükler vb.) içeren .py uzantısına sahip Python dosyalarıdır.Modüller, *import* anahtar sözcüğü ve uzantı olmadan dosya adı kullanılarak içe aktarılır. Bir modül, çalışan bir Python betiğine ilk kez yüklendiğinde, modüldeki kodun bir kez çalıştırılmasıyla başlatılır. **Örnek Uygulama**```bisiklet.py adlı modülün içeriği"""Bu modül içinde Bisiklet sınıfı yer almaktadır."""class Bisiklet:    renk = "Kırmızı"    vites = 1    def ozellikler(self):        ozellikDetay = "Bu bisiklet %s renkli ve %d viteslidir." % (self.renk, self.vites)        return ozellikDetay``````bisikletler.py adlı Python dosyasının içeriğiimport bisikletbisiklet1 = bisiklet.Bisiklet()print("Bisiklet 1: " + bisiklet1.ozellikler())``` **PyCharm Örneği**![bisiklet.py](http://www.madran.net/wp-content/uploads/2020/05/bisikletPY.png) bisiklet.py---![alt text](http://www.madran.net/wp-content/uploads/2020/05/bisikletlerPY.png)bisikletler.py Colab'de Modülün İçe AktarılmasıBir önceki bölümde (Modülün İçe Aktarılması) herhangi bir kişisel bilgisayarın sabit diski üzerinde çalışırken yerleşik olmayan (kendi yazdığımız) modülün içe aktarılması yer aldı.Bu bölümde ise Colab üzerinde çalışırken yerleşik olmayan bir modülü nasıl içe aktarılacağı yer almakta. **Örnek Uygulama**Aşağıda içeriği görüntülenen *bisiklet.py* adlı Python dosyası Google Drive içerisinde "BBY162_Python_a_Giris.ipynb" dosyasının ile aynı klasör içinde bulunmaktadır.```bisiklet.py adlı modülün içeriği"""Bu modül içinde Bisiklet sınıfı yer almaktadır."""class Bisiklet:    renk = "Kırmızı"    vites = 1    def ozellikler(self):        ozellikDetay = "Bu bisiklet %s renkli ve %d viteslidir." % (self.renk, self.vites)        return ozellikDetay```<jupyter_code># Google Drive'ın bir disk olarak görülmesi 
from google.colab import drive
drive.mount('gdrive') # bağlanan diskin 'gdrive' adı ile tanımlanması.

import sys # bağlanan diskin fiziksel yolunun tespit edilmesi ve bağlantı yoluna eklenmesi
sys.path.append('/content/gdrive/My Drive/Colab Notebooks/BBY162 - Programlama ve Algoritmalar/')

import bisiklet # bisiklet.py içerisindeki 'bisiklet' modülünün içe aktarılması

bisiklet1 = bisiklet.Bisiklet()
print("Bisiklet 1: " + bisiklet1.ozellikler())<jupyter_output><empty_output><jupyter_text>Yerleşik Modüller (built-in)Python aşağıdaki bağlantıda yer alan standart modüllerle birlikte gelir. Bu modüllerin *import* anahtar kelimesi ile çağrılması yeterlidir. Ayrıca bu modüllerin yüklenmesine gerek yoktur.[Python Standart Modülleri](https://docs.python.org/3/library/) **Örnek Uygulama**```import datetimeprint(datetime.datetime.today())```<jupyter_code># Örnek uygulamayı çalıştır 

import datetime
print(datetime.datetime.today())<jupyter_output>2022-05-03 20:28:29.347449<jupyter_text>from import Kullanımıİçe aktarma ifadesinin bir başka kullanım şekli *from* anahtar kelimesinin kullanılmasıdır. *from* ifadesi ile modül adları paketin içinde alınarak direkt kullanıma hazır hale getirilir. Bu şekilde, içe aktarılan modül, modül_adı öneki olmadan doğrudan kullanılır. **Örnek Uygulama**```bisiklet.py adlı modülün içeriği"""Bu modül içinde Bisiklet sınıfı yer almaktadır."""class Bisiklet:    renk = "Kırmızı"    vites = 1    def ozellikler(self):        ozellikDetay = "Bu bisiklet %s renkli ve %d viteslidir." % (self.renk, self.vites)        return ozellikDetay```<jupyter_code># Google Drive'ın bir disk olarak görülmesi 
from google.colab import drive
drive.mount('gdrive') # bağlanan diskin 'gdrive' adı ile tanımlanması.

import sys # bağlanan diskin fiziksel yolunun tespit edilmesi ve bağlantı yoluna eklenmesi
sys.path.append('/content/gdrive/My Drive/Colab Notebooks/BBY162 - Programlama ve Algoritmalar/')

from bisiklet import Bisiklet # bisiklet.py içerisindeki 'bisiklet' sınıfının içe aktarılması

bisiklet1 = Bisiklet() # bisiklet ön tanımlamasına gerek kalmadı
print("Bisiklet 1: " + bisiklet1.ozellikler())<jupyter_output><empty_output><jupyter_text>Bölüm 10: Dosya İşlemleri Dosya OkumaPython, bilgisayarınızdaki bir dosyadan bilgi okumak ve yazmak için bir dizi yerleşik fonksiyona sahiptir. **open** fonksiyonu bir dosyayı açmak için kullanılır. Dosya, okuma modunda (ikinci argüman olarak "r" kullanılarak) veya yazma modunda (ikinci argüman olarak "w" kullanılarak) açılabilir. **open** fonksiyonu dosya nesnesini döndürür. Dosyanın saklanması için kapatılması gerekir. **Örnek Uygulama**```Google Drive Bağlantısıfrom google.colab import drivedrive.mount('/gdrive')dosya = "/gdrive/My Drive/Colab Notebooks/BBY162 - Programlama ve Algoritmalar/metin.txt"f = open(dosya, "r") for line in f.readlines():    print(line)f.close()```Dosyanın sağlıklı şekilde okunabilmesi için Google Drive ile bağlantının kurulmuş olması ve okunacak dosyanın yolunun tam olarak belirtilmesi gerekmektedir.![Google Drive Colab Klasörü](http://www.madran.net/wp-content/uploads/2020/05/driveMetin.png)<jupyter_code>#Google Drive Bağlantısı
from google.colab import drive
drive.mount('/gdrive')

dosya = "/gdrive/My Drive/Colab Notebooks/BBY162 - Programlama ve Algoritmalar/metin.txt"

f = open(dosya, "r") 

for line in f.readlines():
    print(line)

f.close()
from google.colab import drive
drive.mount('/content/drive')<jupyter_output>Mounted at /content/drive<jupyter_text>Dosya YazmaBir dosyayı ikinci argüman olarak "w" (yazma) kullanarak açarsanız, yeni bir boş dosya oluşturulur. Aynı ada sahip başka bir dosya varsa silineceğini unutmayın. Mevcut bir dosyaya içerik eklemek istiyorsanız "a" (ekleme) değiştiricisini kullanmalısınız. **Örnek Uygulama**Aşağıdaki örnekte dosya 'w' parametresi ile açıldığı için var olan dosyanın içindekiler silinir ve yeni veriler dosyaya yazılır. Dosyanın içindeki verilerin kalması ve yeni verilerin eklenmesi isteniyorsa dosya 'a' parametresi ile açılmalıdır.```Google Drive Bağlantısıfrom google.colab import drivedrive.mount('/gdrive') dosya = "/gdrive/My Drive/Colab Notebooks/BBY162 - Programlama ve Algoritmalar/cikti.txt"f = open(dosya, 'w')  Mevcut veriye ek veri yazılması için parametre: 'a'f.write("test")  Her yeni verinin bir alt satıra yazdırılması "test\n"f.close()```Kod çalıştırıldıktan sonra eğer *cikti.txt* adında bir dosya yoksa otomatik olarak oluşturulur ve istenilen içerik yazılır.![Google Drive Colab Klasörü](http://www.madran.net/wp-content/uploads/2020/05/driveColab.png)<jupyter_code>#Google Drive Bağlantısı
from google.colab import drive
drive.mount('/gdrive')
 
dosya = "/gdrive/My Drive/Colab Notebooks/BBY162 - Programlama ve Algoritmalar/cikti.txt"

f = open(dosya, 'w') # Mevcut veriye ek veri yazılması için parametre: 'a'
f.write("test") # Her yeni verinin bir alt satıra yazdırılması "test\n"
f.close()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10569991861411464, 'fraction_numerical': 0.010536565515637716, 'mean_word_length': 6.140085088720556, 'pattern_counts': {'":': 23, '<': 346, '<?xml version=': 0, '>': 348, 'https://': 5, 'lorem ipsum': 0, 'www.': 4, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '86', 'dir': 'jupyter-structured-clean-dedup', 'id': '7155', 'license': 'MIT', 'n_tokens_mistral': 34030, 'n_tokens_neox': 31493, 'n_words': 6808, 'path': 'Python_101-2022.ipynb', 'repo_name': 'yarengozutok/hu-bby162-2022', 'size': '69095'}