{ "cells": [ { "cell_type": "markdown", "id": "e98f2229-fab1-4825-8a7e-0dd4405db377", "metadata": {}, "source": [ "PYTHON İLE PROGRAMLAMA\n", "***\n", "> H.N. ÇETİNKAYA - Güncelleme: 21.11.2022
\n", "***" ] }, { "cell_type": "markdown", "id": "8edbf03d-b020-42b1-b8ac-63bd8415bd50", "metadata": {}, "source": [ "İçindekiler\n", "--" ] }, { "cell_type": "markdown", "id": "e1299f4d", "metadata": {}, "source": [ "# Algoritma Nedir?" ] }, { "cell_type": "markdown", "id": "0a5b8e14-be11-435b-afc2-c07c57cc9cb9", "metadata": {}, "source": [ "**Algoritma,** belirli bir problemi çözmek veya belirli bir amaca ulaşmak için çözüm yolunun adım adım tasarlanmasıdır. Daha iyi anlamak için Josh Darnit'in (2017) çocuklarıyla yaptığı 'Kesin Talimatlar' videosunu izleyebilirsiniz. Algoritmalar doğal dil (satır kod), sözde kod veya akış şeması ile ifade edilebilirler. Örnekler aşağıda verilmiştir.
\n", "**Algoritma Yazım Örnekleri**

\n", "**Akış Şeması Örneği** (Torun, 2021)

\n", "
Etkinlik: Elinde kalem olan bir kişiye, yüzü duvara dönük veya gözü kapalı olan başka bir kişi hazırladığı algoritmik komutları dikdörtgen çizmesi (yazı tahtasına veya kağıda) için verir. Etkinlik roller değiştirilerek tekrarlanır.
\n", "Etkinlik: Bir öğrenciye 1 ile 100 arasında aklından bir sayı tutturulur ve başka bir öğrenci bir sayıyı 'Evet', 'Hayır' soruları sorarak aldığı cevaplara göre bulur.
" ] }, { "cell_type": "markdown", "id": "17734022", "metadata": {}, "source": [ "
Araştırma Ödevi: Google'ın \"Bunu mu demek istediniz?\" öneri algoritması hangi tür algoritmalarla çalışıyor?
\n", "Araştırma Ödevi: Netflix Prize nedir, araştırınız?
" ] }, { "cell_type": "markdown", "id": "51106353", "metadata": {}, "source": [ "# Proglamlama Dili Nedir?" ] }, { "cell_type": "markdown", "id": "f24e4965", "metadata": {}, "source": [ "**Programlama Dili,** bir **algoritmayı** ifade etmek amacıyla, bilgisayara ne yapmasını istediğini anlattığımız (kodladığımız) yoldur. Programlama dilleri ile yazdığımız kodlar makine koduna (binary (yani 0 ve 1)) çevrilir ve kodladığımız algoritma bilgisayar tarafından çalıştırılır.\n", "
Etkinlik: T.C. Kimlik numaranızı Sezar Şifreleme ile şifreledikten sonra 16'lık sayı sistemi ile saklayınız. Kalem-Kağıt etkinliğidir.
\n", "Programlama dilleri, makine koduna çevrilmesi yönünden ikiye ayrılır:
" ] }, { "cell_type": "markdown", "id": "90908d4b-31f6-4899-be59-434c5f35a3bb", "metadata": {}, "source": [ "**1. Derlenen (Compiler) Diller:** Yazımı(syntax) makine diline yakın olan dillerdir. Dilin yazım şekli makine diline yakın olduğu için yazılmış kodun bütünü hızlıca makine koduna (binary) çevrilir. C, C++, Fortran, R dilleri derlenen dillere örnektir.
\n", "**2. Yorumlanan (Interpreter) Diller:** Yazımı(syntax) makine diline yakın olmayan ama yazımı kolay olan böylelikle daha karmaşık ve zor programlamaları kolayca yapabilmemize imkan sağlayan dillerdir. Bu diller önce yorumlama dediğimiz işlemle kısım kısım (satır satır) kodları makine dilinde dener, hata bulursa derlemeyi durdurur, hata yoksa kodların tamamı makine koduna (binary) çevrilmiş olur. Python, Ruby, Java, C# bu dillere örnektir.
\n", "
Tarihte kabul edilen ilk programlamanın 1883 yılında Ada LOVELACE tarafından sayısal olarak yazıldığını biliyor muydunuz?
" ] }, { "cell_type": "markdown", "id": "b1d1616c-2238-4c83-a441-314a7e92ffe4", "metadata": {}, "source": [ "## Neden Python?\n", "1. Unix, Linux, Mac, Windows vb. birçok işletim sistemiyle uyumlu bir şekilde çalışması.\n", "1. Açık kaynak kodlu, ücretsiz, sade yazım ve büyük bir topluluk desteğinin olması.\n", "1. Hızlı ve kod yazımı-bakımı işlerinin kolay olması.\n", "1. Yorumlanan dil olduğu için hata ayıklamanın rahat olması.\n", "1. Google, IBM, NASA, Dropbox, Yahoo, Instagram, Youtube, Mozilla vb. sponsor ve desteğinin olması.\n", "1. Masaüstü, mobil veya web yazılımları geliştirebilme.\n", "1. Veri Bilimi, Veri Madenciliği, Veri Görselleştirme, Makine Öğrenmesi, Yapay Zeka uygulamalarında basitçe kullanılabilmesi.\n", "1. Robotik uygulamalarında bile kullanılabilmesi (microPython)\n", "1. IoT cihazlarda kullanılabilmesi.\n", "1. Sahip olduğu çok geniş kütüphanelerinin bulunması. Bu kütüphanelere erişimlerin tüm platformlardan yapılabilmesi." ] }, { "cell_type": "markdown", "id": "8457cbd6-1398-4400-b57f-3228a3dca10e", "metadata": {}, "source": [ "## Python Kurulumu\n", "Windows Python kurulumu için; python'un resmi sitesi olan https://www.python.org/ adresine giriniz. Aşağıdaki site açılacaktır.

\n", "
Ardından kırmızı kutu içinde gördüğünüz 'Downloads' menüsünün üzerine geliniz. Açılan menüdeki 'Download for Windows' yazısının altında bulunan python butonuna tıklayınız. Python inmeye başlayacaktır. Python indikten sonra çalıştırınız. Karşınıza gelen ilk pencerede 'Add to PATH' seçeneğinin seçili olmasına dikkat ediniz. Ardından 'İnstall Now' seçeneği ile python'u kurunuz. Kurulum bittikten sonraki pencerede 'Successfull' ifadesini görmüş olmamız gerekir. Bu pencerede 'Disable path length limit' seçeneğine tıklamanızı öneririm. 'Close' tuşu ile pencereyi kapatınız. Artık python kurdunuz.
\n", "Başlat tuşuna basınız ve 'IDLE' yazınız. 'IDLE (Python)' programını açınız. Bu kabuk python kodlarını çalıştırmaktadır. 'IDLE' kabuğunu açtıktan sonra üst menüdeki 'File' menüsünden 'New File' ile kendinize yeni boş bir dosya açabilirsiniz. Daha önceden varolan dosyalarınız için aynı menüdeki 'Open' menüsü ile varolan dosyanızı açılan dialog penceresinden bularak açabilirsiniz. 'New File' ile açtığınız boş dosyadaki kodları çalıştırmak için üst menüdeki 'Run' menüsünden 'Run Module' seçeneğini kullanınız. Unutmamanız gerekir ki yeni bir python dosyasının çalıştırılabilmesi için öncelikle diskinize kaydedilmesi gerekir. Python kodlamak için farklı ide'ler de kurabilirsiniz. Bunlar için araştırma yaparak kurabilirsiniz: Visual Studio Code, Atom, Sublime Text, Notepad++, PyCharm, Spyder bunlardan bazılarıdır.

\n", "Diğer işletim sistemlerine kurulum için; Ubuntu ve Mac OS X için sistem ayarlarında bulunan 'Yazılım & Güncelleme (Software & Update)' ile işletim sisteminizin size sağladığı repository içinde aratıp kurabilirsiniz.
\n", "Sisteminize Python kurulumu YAPAMIYORSANIZ kod yazmak için kullanılabilecek tamamen ücretsiz olan bulut (online) uygulamalar mevcut. Bunlar:
\n", "1. Google Colab - https://colab.research.google.com/\n", "2. Replit - https://replit.com/ (Mobil uygulamaları marketlerde de mevcut)\n", "3. Trinket - https://trinket.io/\n", "4. GeeksForGeeks - https://ide.geeksforgeeks.org/\n", "5. One Compiler - https://onecompiler.com/python\n", "6. Programiz - https://www.programiz.com/python-programming/online-compiler/\n", "7. PyDroid - Android için. Marketten indirebilirsiniz." ] }, { "cell_type": "markdown", "id": "0a578137", "metadata": {}, "source": [ "# Python Programlama Dili" ] }, { "cell_type": "markdown", "id": "c49b9966", "metadata": {}, "source": [ "Python 1991 yılında Guido Van Rossum tarafından geliştirilen bir yüksek seviyeli programlama dilidir.
Python, diğer programlama dillerine göre daha kolay bir sözdizim (syntax: yazım kuralı) yapısına sahiptir. Bu sebeple python yıllar içinde popüler hale gelmiştir.
\n", "Programlama dillerinin kullanımına göre yaygınlık sıralamasını TIOBE (Programalama Topluluğu Dizini) sitesinden öğrenebilirsiniz.\n", "Hemen hemen tüm programlama dilleri sözdizimi, komut, değişken, operatör, ifade, fonksiyon ve metot konseptinden oluşur." ] }, { "cell_type": "markdown", "id": "2e72c3dc", "metadata": {}, "source": [ "## Söz Dizimi (Syntax)\n", "Programlama dillerinin yazım kurallarına sözdizimi (syntax) denir. Dile ait tüm öğeler (komutlar, parantezler, tırnak işareti vb. tüm noktalama işaretleri, işleçler, ...) yazım kuralları içerisinde yazılmak zorundadır. Uygun yazılmaz ise programdan hata alınır. Programlama dillerine göre örnek syntax'lar aşağıda verilmiştir.
\n", "`\n", "-----------------------------------------------------\n", "# Java Syntax Örneği\n", "```\n", "public class Main {\n", " public static void main(String[] args) {\n", " System.out.println(\"Merhaba Dünya\");\n", " }\n", "}\n", "```\n", "-----------------------------------------------------\n", "# C# Syntax Örneği\n", "```\n", "using System;\n", "namespace MerhabaDunya\n", "{\n", " class Program\n", " {\n", " static void Main(string[] args)\n", " {\n", " Console.WriteLine(\"Merhaba Dünya\"); \n", " }\n", " }\n", "}\n", "```\n", "-----------------------------------------------------\n", "# Python Syntax Örneği\n", "```\n", "print(\"Merhaba Dünya!\")\n", "```\n", "-----------------------------------------------------\n", "`\n", "## Deyim (Komut) (Statement)\n", "Programlama dilinde **anahtar sözcüklerle (if ..., for ..., while ..., def, is, ,in vb.) oluşturulan anlamlı öbeklere deyim (komut)** denir. Genelde her satır kod bir anlamlı öbektir yani sözdizimsel deyimdir.
\n", "## Değişken (Variable)\n", "Programlama dilinde **verileri bellekte tutmak için kullanılan hafıza birimleridir.** Değişkenler sayı, metin, karakterler, listeler vb. gibi değerleri içerebilir. İçerdiği veri tipi nedeniyle değişken tipleri de mevcuttur.
\n", "## Operatörler (İşleçler) (Operators)\n", "Değerler veya değişkenler üzerinde **işlem yapıp sonuçlandıran öğelere operatörler(işleçler)** denir. Örneğin; toplama, çıkarma vb. sayısal işlemler ve \"aynı mı?\", \"aynı değil mi?\" gibi işlemler.
\n", "## Fonksiyonlar (Functions)\n", "Ana programa **belirli bir değer(ler) dönderen veya görevleri gerçekleştiren deyimler (komutlar) bütününe fonksiyon** denir. Örneğin `print()` bir fonksiyondur, print(3+5) yazarsak bize 8 değerini döndürür ve ekrana yazar.
\n", "## Metot (Method)\n", "Programlama diline ait **öğeler (değişken, deyim vb.) ile bağımlı olan alt fonksiyonlara metot** denir.
\n", "## İfade (Expressions)\n", "Değeri hesaplanabilen (değerlendirilebilen) sözdizimsel deyimlere (komutlara) **ifade** denir. 3+5 gibi basit bir deyim de ifade olabilirken birden çok fonksiyon ve deyim içeren ifadeler de olabilir.
" ] }, { "cell_type": "markdown", "id": "2103bbc8-5887-4537-8267-853f41c7d35f", "metadata": {}, "source": [ "# Print() Fonksiyonu ile \"Merhaba Dünya!\"\n", "`print()` fonksiyonu ekrana yazdırma(bastırma) işlevidir. Parantez arasına yazılanlar ekrana basılır." ] }, { "cell_type": "code", "execution_count": null, "id": "97146a76", "metadata": {}, "outputs": [], "source": [ "print (\"Merhaba Dünya\")" ] }, { "cell_type": "markdown", "id": "b8b94ed9", "metadata": {}, "source": [ "
Etkinlik: print() fonksiyonu ile ekrana \"Merhaba Dünya\" yazınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "16f3dcb9-59c5-46c3-a4fb-15305990c27f", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "print (\"Merhaba Dünya!\")" ] }, { "cell_type": "markdown", "id": "baf2c7d2-5d40-4339-8bf1-a63ded4a5133", "metadata": {}, "source": [ "## Print() Fonksiyonunun Kullanımları" ] }, { "cell_type": "markdown", "id": "def98cf9", "metadata": {}, "source": [ "Eğer `print()` ile yazacağınız metinde zaten çift tırnak (\") kullanmanız gerekiyorsa tek tırnak işaretiyle de print komutunu kullanabilirsiniz." ] }, { "cell_type": "code", "execution_count": null, "id": "9c952325", "metadata": {}, "outputs": [], "source": [ "print ('Bastığın yerleri \"toprak!\" diyerek geçme, tanı!')" ] }, { "cell_type": "markdown", "id": "ed20c107", "metadata": {}, "source": [ "Çok satırlı bir çıktınız varsa üç tırnak işareti ile yapabilirsiniz." ] }, { "cell_type": "code", "execution_count": null, "id": "f17a58e5", "metadata": {}, "outputs": [], "source": [ "print(\"\"\"\n", "Dalgalan sen de şafaklar gibi ey şanlı hilâl;\n", "Olsun artık dökülen kanlarımın hepsi helâl.\n", "Ebediyen sana yok, ırkıma yok izmihlâl:\n", "Hakkıdır, hür yaşamış bayrağımın hürriyet;\n", "Hakkıdır, Hakk’a tapan milletimin istiklâl!\n", "\"\"\")" ] }, { "cell_type": "markdown", "id": "41b734de", "metadata": {}, "source": [ "Sayıları tırnaksız yazabilir,aynı satır içinde virgülle ayrılmış şekilde çift tırnaklar kullanabilirsiniz." ] }, { "cell_type": "code", "execution_count": null, "id": "753b5cfd", "metadata": {}, "outputs": [], "source": [ "print(\"Türkiye Cumhuriyeti\",23,\"Nisan\",\"1923\",\"yılında kurulmuştur.\")" ] }, { "cell_type": "markdown", "id": "cb772c47", "metadata": {}, "source": [ "Virgülle ayrılmış yazımlarda `sep` deyimi ile aralara ayıraç (seperator) tanımlayabilirsiniz." ] }, { "cell_type": "code", "execution_count": null, "id": "dc06fc63", "metadata": {}, "outputs": [], "source": [ "print(\"www\",\"meb\",\"gov\",\"tr\",sep=\".\")" ] }, { "cell_type": "markdown", "id": "56b44e6a", "metadata": {}, "source": [ "
Etkinlik: TBMM kelimesindeki her haften sonra sep metodu ile nokta koyunuz ve ekrana yazınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "e2711563-485b-4881-b342-c8adc805c729", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "print(\"T\",\"B\",\"M\",\"M\",\"\",sep=\".\")\n", "#veya\n", "print(*\"TBMM \",sep=\".\")" ] }, { "cell_type": "markdown", "id": "24e1e44a", "metadata": {}, "source": [ "Alt alta yazmak için üç tane çift tırnak kullanmak istemezseniz **kaçış dizilerinden** \"\\n\" ile alt satıra geçme kaçış dizisini kullanabilirsiniz." ] }, { "cell_type": "code", "execution_count": null, "id": "a4f4de64", "metadata": {}, "outputs": [], "source": [ "print(\"Korkma, sönmez bu şafaklarda yüzen al sancak;\",\"Sönmeden yurdumun üstünde tüten en son ocak\",sep=\"\\n\")" ] }, { "cell_type": "code", "execution_count": null, "id": "e78a1c63", "metadata": {}, "outputs": [], "source": [ "print(\"Birinci Satır\",\"İkinci Satır\",\"Üçüncü Satır\",sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "cef5c2be", "metadata": {}, "source": [ "
Etkinlik: Aile bireylerinizin adını ekrana alt alta bastıran kodu yazınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "7b76cc87-5468-4a69-965c-4aedcba346c1", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "print(\"Baba\",\"Anne\",\"Abi\",\"Abla\",\"Kız Kardeş\",\"Erkek Kardeş\",sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "7803d025-08d7-4b3c-93bd-78ffac901f83", "metadata": {}, "source": [ "**
KAÇIŞ DİZİLERİ
(Bir metin yazarken `\\` kullanacaksanız kaçış dizisine çarpmamaya dikkat ediniz.)
**" ] }, { "cell_type": "markdown", "id": "cc6e816c-b932-40d5-b26f-966b038d8a56", "metadata": {}, "source": [ "| **KAÇIŞ DİZİSİ** | **İŞLEVİ** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-:|:-:|\n", "| **\\n** | **Satırbaşı** | `print('O benimdir O benim\\nMilletimindir ancak')`| O benimdir O benim
Milletimindir ancak|\n", "| **\\t** | **Sekme
(Yatay)** | `print('Adınız\\t:')`| Adınız :
|\n", "| **`\\\\`** | **Ters Eğik Çizgi** | `print(\"C:\\\\Windows\\\\System32\\\\\")`| C:\\Windows\\System32\\ |\n", "| **\\b** | **İmleci Bir Sola Alma
(Geriye doğru silme)** | `print('Python\\br:')`| Pythor:|\n", "| **\\r** | **Aynı Satırda Satırbaşı
(Geriye doğru satırbaşına gelme)** | `print('Python\\rB')`| Bython|\n", "| **r** | **Kaçış Dizilerini İptal Etme** | `print(r'Python\\nMerhaba:')`| Python\\nMerhaba:|" ] }, { "cell_type": "markdown", "id": "2a4d963a-0a30-4e86-a08a-e39b2c617da1", "metadata": {}, "source": [ "Bunlar dışında `\\` ile birlikte 'u', 'U', 'n', 'N', 'x', 'a' ve 'f' kaçış dizileri de vardır. Bunlara çarpmamak için 'r' yöntemini kullanınız." ] }, { "cell_type": "markdown", "id": "7e63578c", "metadata": {}, "source": [ "Print ile yazılan satırın sadece sonunda gerçekleşmesini istediklerimizi şöyle tanımlayabiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "4a08f5ce", "metadata": {}, "outputs": [], "source": [ "print(\"Ben ezelden\",\"beridir hür yaşadım,\",\"hür yaşarım.\",end='\\t')\n", "print (\"Hangi çılgın\",\"bana zincir vuracakmış?\",\"Şaşarım!\",end='')\n", "print (\"Kükremiş sel gibiyim; bendimi çiğner, aşarım;\")" ] }, { "cell_type": "markdown", "id": "2f83c7cb", "metadata": {}, "source": [ "Tırnak içinde yazılan metnin her karakteriyle birbirinden ayrıymış gibi işlem yaptırmak için * işlecini kullanabiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "9124ec37", "metadata": {}, "outputs": [], "source": [ "print(*\"TBMM\",sep=\".\")\n", "print(*\"TÜRKİYE\",sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "743f07d5", "metadata": {}, "source": [ "Dinamik metinler için kıvırcıklı parantezler ile format metodunu kullanabiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "d5cd6814", "metadata": {}, "outputs": [], "source": [ "print(\"{} programlama dili {} türden bir dilidir ve {} yılında kullanıma sunulmuştur.\".format(\"Python\",\"yorumlanan\",1994))" ] }, { "cell_type": "markdown", "id": "37b9bca6-888f-49f3-bbeb-d4362b30ee8b", "metadata": {}, "source": [ "Dinamik metinler için format metodundan daha kullanışlı olan 'f string' yöntemi değişkenler konusu ile anlatılacaktır.
\n", "Python programlama dilindeki öğelerin sahip olduğu tüm metotları görmek için `dir()` fonksiyonunu çalıştırabilirsiniz." ] }, { "cell_type": "code", "execution_count": null, "id": "b7bce0fe", "metadata": {}, "outputs": [], "source": [ "print(*dir(print),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "8b6f3063", "metadata": {}, "source": [ "
Etkinlik: print() fonksiyonu ile * sembolünü kullanarak ekrana 5 satırlık içi dolu bir dikdörtgen-kare çiziniz.
\n" ] }, { "cell_type": "code", "execution_count": null, "id": "831ac128-49a2-4a91-9056-c6131502a69b", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "print(\"* \"*5,\"* \"*5,\"* \"*5,\"* \"*5,\"* \"*5,sep=\"\\n\") #5X5 Kare için\n", "print(\"-------\")\n", "print(\"* \"*8,\"* \"*8,\"* \"*8,\"* \"*8,\"* \"*8,sep=\"\\n\") #5X8 Dörtgen için" ] }, { "cell_type": "markdown", "id": "3eb8ff16-3696-4591-bda1-b88fdc8ba2a9", "metadata": {}, "source": [ "
Etkinlik: print() fonksiyonu ile * sembolünü kullanarak ekrana 5 satırlık içi dolu bir dik üçgen çiziniz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "c4735cd0-4c1a-4001-9fca-d0d691b56c83", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "print(\"* \"*1,\"* \"*2,\"* \"*3,\"* \"*4,\"* \"*5,sep=\"\\n\") #her satırda * işareti artan olarak gider" ] }, { "cell_type": "markdown", "id": "73f2281b-6fc4-4df8-b95c-68355adde8fc", "metadata": {}, "source": [ "# Python'da Turtle Kütüphanesi ile Algoritmik İşlemler" ] }, { "cell_type": "markdown", "id": "ec63c998-9ec5-472b-a123-eef7e4f729a1", "metadata": {}, "source": [ "Turtle öğretim amaçlı 2 Boyutlu çizim kütüphanesidir. Geometrik çizimler yapmamızı sağlayan fonksiyonları barındırır. `import turtle` olarak Python'a çekilir. Varsayılan olarak turtle 0° (sağa dönük) ve kalem basılı olarak başlar. Not: Jupyter Notbeook ile kullanılınca son satıra `turtle.done()` yazılmalıdır yoksa her çalıştırmada hata alınır." ] }, { "cell_type": "markdown", "id": "fe3b7f15-be43-4823-85f9-05ce5a90cdf6", "metadata": {}, "source": [ "## Turtle Kütüphanesi ile Gelen Bazı Fonskiyonlar" ] }, { "cell_type": "markdown", "id": "b5df47c5-a118-49f8-a7dd-5ae7bae7663d", "metadata": {}, "source": [ "- Bulunduğu derece yönüne doğru belirlenen pixel büyüklüğünde çizgi çizmek için `turtle.forward()` fonskiyonu kullanılır. Örnek: `turtle.forward(100)`(sağa doğru 100 pixel çizgi çizdi)\n", "- Bulunduğu derecenin tersi yönüne doğru belirlenen pixel büyüklüğünde çizgi çizmek için `turtle.backward()` fonskiyonu kullanılır. Örnek: `turtle.backward(100)` (sola doğru 100 pixel çizgi çizdi)\n", "- Bulunduğu dereceden belirlenen değerde sola döndürmek için `turtle.left()` fonskiyonu kullanılır.\n", "- Bulunduğu dereceden belirlenen değerde sağa döndürmek için `turtle.right()` fonskiyonu kullanılır.\n", "- Kalem kalınlığını değiştirmek için `turtle.pensize()` fonskiyonu kullanılır.\n", "- Kalem rengini değiştirmek için `turtle.color()` fonskiyonu kullanılır. Örnek renker, \"red\", \"blue\" vb.\n", "- (Renkle) Doldurma işlemini başlatmak için `turtle.begin_fill()` fonskiyonu kullanılır. Parametresiz kullanılır. Kalem renginde doldurur.\n", "- (Renkle) Doldurma işlemini bitirmek için `turtle.end_fill()` fonskiyonu kullanılır.\n", "- Belirlenen yarıçap değerinde daire çizmek için `turtle.circle()` fonskiyonu kullanılır.\n", "- Çizme hızını belirlemek için `turtle.speed()` fonskiyonu kullanılır.\n", "- Kalemi kaldırmak (çizmemesi) için `turtle.penup()` fonskiyonu kullanılır.\n", "- Kalemi bastırmak (çizmesi) için `turtle.pendown()` fonskiyonu kullanılır.\n", "- Ekrandaki bir noktaya direkt hareket etmek için `turtle.goto(x,y)` fonskiyonu kullanılır. (setx, sety ve xcor, ycor fonksiyonları da var.)\n", "- Ekranı temizlemek için `turtle.clear()` fonskiyonu kullanılır.\n", "- Ekran boyutunu ayarlamak için `turtle.screensize(canvwidth=genişlik, canvheight=yükseklik, bg=\"renk\")` fonskiyonu kullanılır. Örnek: turtle.screensize(canvwidth=400, canvheight=300, bg=\"blue\")" ] }, { "cell_type": "markdown", "id": "d3bf0bc7-80e2-4fc0-99b2-6dbf2f244162", "metadata": {}, "source": [ "
Etkinlik: Bir Kare çiziniz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "2a2b3524-973e-4d6a-ad5f-f40ffdaa4b42", "metadata": {}, "outputs": [], "source": [ "#Etkinlik Çözümü\n", "import turtle\n", "turtle.forward(75)\n", "turtle.right(90)\n", "turtle.forward(75)\n", "turtle.right(90)\n", "turtle.forward(75)\n", "turtle.right(90)\n", "turtle.forward(75)\n", "turtle.done()" ] }, { "cell_type": "markdown", "id": "dc1d3943-6ea3-4004-ba7e-38829f9c0c29", "metadata": {}, "source": [ "
Etkinlik: İçi dolu olan bir daire çiziniz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "f7a78185-0171-4a3f-9aaa-ca9e2d260788", "metadata": {}, "outputs": [], "source": [ "#Etkinlik Çözümü\n", "import turtle\n", "turtle.color(\"red\")\n", "turtle.begin_fill()\n", "turtle.circle(75)\n", "turtle.end_fill()\n", "turtle.done()" ] }, { "cell_type": "markdown", "id": "63dfd2d2", "metadata": {}, "source": [ "# Değişken, Değişkeni İsimlendirme, Değişkene Değer Atama" ] }, { "cell_type": "markdown", "id": "876def4d", "metadata": {}, "source": [ "**Değişken (variable),** bir programda verilerin veya bilgilerin saklandığı **hafıza birimleridir**.
\n", "**Değişkene isim verirken**, programlama diline ait öğeler kullanılamaz. Örneğin \"print\" adında bir değişkeniniz olamaz.
\n", "Yasaklı diğer öğeleri de listelemek için pythonda şu kodu yazabiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "d14ec5a1", "metadata": {}, "outputs": [], "source": [ "import keyword\n", "print(keyword.kwlist)" ] }, { "cell_type": "markdown", "id": "2a273f24", "metadata": {}, "source": [ "Ayrıca değişken isimleri **rakamla başlayamaz, Türkçe karakterler (ÜĞİŞÇÖ, üğışçö) genelde kullanılamaz, tüm özel karakterler (alt çizgi _ hariç) de kullanılamaz.** Python Türkçe karakterleri kullanmaya izin verir, bu konuda nadir dillerden biridir. Bir diğer özelliği de büyük-küçük harf duyarlı olmasıdır. Yani 'ad' değişkeni ile 'AD' değişkeni birbirinden farklı değişkenler olarak kullanılabilir.
\n", "**Değişkene değer atama** \"=\" operatörü (işleci) ile yapılır sağdaki veriyi soldaki değişkene atar (tanımlar)." ] }, { "cell_type": "code", "execution_count": null, "id": "5ea56057", "metadata": {}, "outputs": [], "source": [ "#Doğru değişken isimlendirmeleri\n", "degisken1 = \"Hakkıdır\"\n", "degisken_1 = \"Hür Yaşamış\"\n", "DEGISKEN = \"Bayrağımın\"\n", "_degisken = \"Hürriyet!\"\n", "\n", "print(degisken1,degisken_1,DEGISKEN,_degisken)" ] }, { "cell_type": "code", "execution_count": null, "id": "1ad69e33", "metadata": {}, "outputs": [], "source": [ "#Yanlış değişken isimlendirmeleri\n", "1degisken = \"Yanlış\"\n", "degisken-1 = \"Değişken\"\n", "D E.GI/S*KEN = \"İsimlendirmesi\"" ] }, { "cell_type": "markdown", "id": "985931df", "metadata": {}, "source": [ "
Etkinlik: Doğru bir değişken adı ile TC Kimlik numaranızı, Adınızı ve e-posta adresinizi bir değişkene atayınız ve ekrana bastırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "fd41d81e-4175-4a6f-bb3e-1f79508a179d", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "tcNo = 12345678900\n", "adSoyad = \"Ahmet Yüksel ÖZEMRE\"\n", "e_posta = \"ornek1@mail.k12.tr\"\n", "print (tcNo,adSoyad,e_posta,sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "c25f3ff1", "metadata": {}, "source": [ "Değişkenleri isimlendirirken sonrasında **kolay hatırlayacağımız, basit, anlaşılır ve mantığa uygun** isimler vermek önemlidir. Bu sebeple değişken isimlendirme standartları (teamülleri) vardır. Bunlar:" ] }, { "cell_type": "code", "execution_count": null, "id": "5cbaf413", "metadata": {}, "outputs": [], "source": [ "#1.Pascal Standartı: Değişkenin her kelimesini büyük harfle yazmak.\n", "MeclisKurulusYili = \"1920\"\n", "print(MeclisKurulusYili)\n", "\n", "#2.Deve Standartı: Değişkenin ilk harfini küçük diğer kelimelerin ilk harfini büyük yazmak.\n", "meclisKurulusYili = 1920\n", "print(meclisKurulusYili)\n", "\n", "#3.Yılan Standartı: Değişkenin her kelimesinin arasına alt tire (_) koymak.\n", "meclis_kurulus_yili = '1920' #veya\n", "iMeclis_Kurulus_Yili = 1920 #veya\n", "MECLIS_KURULUS_YILI = \"1920\"\n", "print(meclis_kurulus_yili,Meclis_Kurulus_Yili,MECLIS_KURULUS_YILI)" ] }, { "cell_type": "markdown", "id": "1b2f0a1d", "metadata": {}, "source": [ "# Değişken Tipleri" ] }, { "cell_type": "markdown", "id": "dfe0cec6-05e5-42d8-b135-c10351efc47b", "metadata": {}, "source": [ "## String (str) " ] }, { "cell_type": "markdown", "id": "73f12c3c", "metadata": {}, "source": [ "Karakter dizisi, metin, dize demektir. Çift tırnak (\" \") veya tek tırnak (' ') arasında yazılan herşey string olur." ] }, { "cell_type": "code", "execution_count": null, "id": "353dd363", "metadata": {}, "outputs": [], "source": [ "#Örnek string tipinde değişkenler\n", "karakterDizisi1 = \"M.Ö. 209 yılında Mete Han tarafından kurulan Türk Ordusu 'Kurtuluş Savaşı'ndan beri hep muzafferdir.\"\n", "karakterDizisi2 = 'Kurtuluş Savaşı \"1919-1923\" yılları arasında gerçekleşmiştir.'\n", "print(karakterDizisi1,karakterDizisi2)" ] }, { "cell_type": "markdown", "id": "ae7ddf56", "metadata": {}, "source": [ "Tipini bilmediğimiz değişken tipini öğrenmek-almak için kullanılan `type()` fonksiyonunu kullanarak tipini görüntüleyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "7f9e258f", "metadata": {}, "outputs": [], "source": [ "dTipi1 = \"TÜRKİYE\"\n", "dTipi2 = '1923'\n", "print(type(dTipi1))\n", "print(type(dTipi2))" ] }, { "cell_type": "markdown", "id": "c8db5d13", "metadata": {}, "source": [ "Karakter dizisi (string) olmayan bir değişkeni stringe dönüştürmek için `str()` fonksiyonu kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "6321826b", "metadata": {}, "outputs": [], "source": [ "degisken = 1923 #Tırnak arasına yazılmadığı için string değildir.\n", "print(type(degisken),type(str(degisken)),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "a6479c23", "metadata": {}, "source": [ "Karakter dizilerinin (string) uzunluğunu `len()` fonksiyonu ile öğrenebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "ffebb86d", "metadata": {}, "outputs": [], "source": [ "misra = \"\"\"\n", "Arkadaş! Yurduma alçakları uğratma sakın;\n", "Siper et gövdeni, dursun bu hayâsızca akın.\n", "Doğacaktır sana va’dettiği günler Hakk’ın...\n", "Kim bilir, belki yarın... belki yarından da yakın.\n", "\"\"\"\n", "print(len(misra))" ] }, { "cell_type": "markdown", "id": "48943e38", "metadata": {}, "source": [ "
Etkinlik: Adınızın karakter uzunluğunu len fonksiyonu ile bulunuz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "8b635f22-ea15-4264-8bb1-121080d5c50b", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "adSoyad = \"Ahmet Yüksel ÖZEMRE\"\n", "uzunluk = len(adSoyad)\n", "print (adSoyad,\"ismi\",uzunluk,\"karakterdir.\")\n", "\n", "#veya format metodu ile\n", "print (\"{} ismi {} karakterdir.\".format(adSoyad,uzunluk))\n", "\n", "#veya f string yöntemi ile\n", "print (f'{adSoyad} ismi {uzunluk} karakterdir.')" ] }, { "cell_type": "markdown", "id": "7f0e6ad6", "metadata": {}, "source": [ "Çok sık kullanılan bir yöntem olan `print(f' ')` yöntemi stringler ile kullanılabilir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "519e54d2", "metadata": {}, "outputs": [], "source": [ "isim=\"TÜRKİYE\"\n", "dogumYili=1923\n", "dogumYeri=\"Ankara\"\n", "print(f'{isim} Cumhuriyeti {dogumYili} yılında {dogumYeri} şehrinde kurulmuştur.')" ] }, { "cell_type": "markdown", "id": "0db9ef5c", "metadata": {}, "source": [ "### Input() Fonksiyonu ile Kullanıcıdan Veri Alma" ] }, { "cell_type": "markdown", "id": "727b7ffd-7741-473c-8cf2-73632256f408", "metadata": {}, "source": [ "`input()` fonksiyonu kullanıcıdan veri almamızı sağlar. Kullanıcının verisini girmesini bekler, veri girildikten sonra enter(giriş) tuşuna basınca girilen veriyi hafızaya alır. Input ile alınan veri bir değişkene atanırsa, girilen değer değişkene atanır.
\n", "**Input fonksiyonu ile kullanıcıdan alınan her veri string veri türündedir.**" ] }, { "cell_type": "code", "execution_count": null, "id": "8a82ce70", "metadata": {}, "outputs": [], "source": [ "girilenVeri = input(\"Lütfen Yaşınızı Giriniz: \")\n", "print(\"{} yaşındasınız.\".format(girilenVeri))" ] }, { "cell_type": "markdown", "id": "5ea38871", "metadata": {}, "source": [ "
Etkinlik: Kullanıcıdan aldığınız isim, yaş, meslek bilgilerini .format() metodu ile ekrana tek satırda yazınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "17a2b959-4652-4efb-ab29-cf828377df31", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "isim = input(\"İsminizi Giriniz: \")\n", "yas = input(\"Yaşınızı Giriniz: \")\n", "meslek = input(\"Mesleğinizi Giriniz: \")\n", "print (\"{} isiminde ve {} yaşında bir {}.\".format(isim,yas,meslek))" ] }, { "cell_type": "markdown", "id": "21d87697", "metadata": {}, "source": [ "### String (str) Değişkeninin Metotları:" ] }, { "cell_type": "markdown", "id": "3c886547-0062-4955-8982-d0faff9a3cc8", "metadata": {}, "source": [ "Karakter dizisini (stringi) tamamen büyük harf, küçük harf, sadece ilk harfi büyük, sadece kelimelerin ilk harfi büyük veya tersine(büyüğü küçük-küçüğü büyük) olacak şekilde değiştirebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "a0593c6c", "metadata": {}, "outputs": [], "source": [ "metin = \"PytHON pRoGrAmLaMa dİLİ\"\n", "print(metin.upper())\n", "print(metin.lower()) #eğer Türkçe karakterler küçülmüyorsa casefold() metodunu kullanabilirsiniz.\n", "print(metin.capitalize())\n", "print(metin.title())\n", "print(metin.swapcase())" ] }, { "cell_type": "markdown", "id": "2108d6a7", "metadata": {}, "source": [ "
Etkinlik: \"Mavi VATAN Akdeniz\" sözcüğünü tamamen küçük, büyük vb. metodlarla işleyiniz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "c222ff51-530f-4d86-a253-5b99005b7e84", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "sozcuk = \"Mavi VATAN Akdeniz\"\n", "print(sozcuk.upper(),sozcuk.lower(),sozcuk.capitalize(),sozcuk.title(),sozcuk.swapcase(),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "8e3d6902", "metadata": {}, "source": [ "Karakter dizisindeki (string) harfleri `replace()` metodu ile değiştirebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "e11d9a4a", "metadata": {}, "outputs": [], "source": [ "vatan = \"TÜRKİYE\"\n", "print(vatan.replace(\"ÜRKİYE\", \"ürkiye\"))\n", "print(vatan.replace(\"İYE\", \"\"))\n", "\n", "#Bir karakter birden çok ise kaç kez tekrarlayacağını da metotta parametre olarak girebiliriz.\n", "palindrom = \"KAZAK\"\n", "print(palindrom.replace(\"A\",\"I\",1))" ] }, { "cell_type": "markdown", "id": "10ba9a5b", "metadata": {}, "source": [ "
Etkinlik: input() foknsiyonu ile kullanıcıdan adını alarak büyük harf yapın, ardından kullanıcının adındaki Ç'leri C olarak, Ğ'leri G olarak, İ'leri I olarak, Ö'leri O olarak, Ü'leri U olarak değiştiriniz ve ekrana yeniden yazdırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "f65528ba-5c66-479d-bdac-5bc16227502a", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "sozcuk = input(\"Adınızı Giriniz: \").upper()\n", "sozcuk = sozcuk.replace(\"Ç\",\"C\")\n", "sozcuk = sozcuk.replace(\"Ğ\",\"G\")\n", "sozcuk = sozcuk.replace(\"İ\",\"I\")\n", "sozcuk = sozcuk.replace(\"Ö\",\"O\")\n", "sozcuk = sozcuk.replace(\"Ş\",\"S\")\n", "sozcuk = sozcuk.replace(\"Ü\",\"U\")\n", "print(sozcuk)\n", "\n", "#veya sıralı şekilde\n", "sozcuk = input(\"Adınızı Giriniz: \").upper()\n", "print(sozcuk.replace(\"Ç\",\"C\").replace(\"Ğ\",\"G\").replace(\"İ\",\"I\").replace(\"Ö\",\"O\").replace(\"Ş\",\"S\").replace(\"Ü\",\"U\"))" ] }, { "cell_type": "markdown", "id": "9df7feff", "metadata": {}, "source": [ "String tipinde bir değişkeni `del` deyimi (komutu) ile hafızadan silebiliriz. Esasında bu deyim (komutu) her tipte değişken için geçerlidir." ] }, { "cell_type": "code", "execution_count": null, "id": "f6738d86", "metadata": {}, "outputs": [], "source": [ "dil = \"Python\"\n", "del dil\n", "print(dil)" ] }, { "cell_type": "markdown", "id": "3bd4ca98", "metadata": {}, "source": [ "String tipinde bir değişkende bir karakter veya karakter dizisinden ne kadar var `count()` metodu ile sayabiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "7df11346", "metadata": {}, "outputs": [], "source": [ "ornekMetin = \"Dal sarkar kartal kalkar, kartal kalkar dal sarkar, dal kalkar kantar tartar.\"\n", "print(ornekMetin.count(\"a\"))\n", "print(ornekMetin.count(\"kartal\"))" ] }, { "cell_type": "markdown", "id": "f3b80cc2-ccb8-49a8-be04-921dd60e8475", "metadata": {}, "source": [ "
Etkinlik: İstiklal Marşımızın ilk kıtasında kaç tane \"a\" harfi var bulunuz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "a041c3ad-b1f2-4b01-853a-e625e91c43a3", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "ilkKita = \"\"\"\n", "Korkma, sönmez bu şafaklarda yüzen al sancak;\n", "Sönmeden yurdumun üstünde tüten en son ocak.\n", "O benim milletimin yıldızıdır, parlayacak;\n", "O benimdir, o benim milletimindir ancak.\n", "\"\"\"\n", "print(ilkKita.count(\"a\"))" ] }, { "cell_type": "markdown", "id": "823c7040", "metadata": {}, "source": [ "String tipinde bir değişkenin içindeki karakterin sırasını `find()` metodu ile bulabiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "d81537b4", "metadata": {}, "outputs": [], "source": [ "toprak = \"AAAAABBBBBBCCCCCCCCCCCCCCDDDDDDDDDDDDDDD\"\n", "print(toprak.index(\"C\")) #ilk geçtiği yeri bulmak için index kullanılır.\n", "print(toprak.rindex(\"A\")) #son geçtiği yeri bulmak için rindex kullanılır.\n", "print(toprak.find(\"X\")) #find metodu index'le aynı işe yarar fakat index metodu bulamazsa 'ValueError' hatası verir, find ise -1\n", "print(toprak.rfind(\"X\")) #find metodunun tersten arama yapanı." ] }, { "cell_type": "markdown", "id": "2ff8b90f-914b-460b-980f-05ae33d4a610", "metadata": {}, "source": [ "
Etkinlik: İstiklal Marşımızın ilk kıtasında \"a\" harfi geçen ilk sırayı ve son sırayı bulunuz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "64fb37c1-326d-4e13-8c5b-4392d10c89c3", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "ilkKita = \"\"\"\n", "Korkma, sönmez bu şafaklarda yüzen al sancak;\n", "Sönmeden yurdumun üstünde tüten en son ocak.\n", "O benim milletimin yıldızıdır, parlayacak;\n", "O benimdir, o benim milletimindir ancak.\n", "\"\"\"\n", "print(ilkKita.index(\"a\")) #ilk yer\n", "print(ilkKita.rindex(\"a\")) #son yer\n", "\n", "#veya\n", "print(ilkKita.find(\"a\")) #ilk yer\n", "print(ilkKita.rfind(\"a\")) #ilk yer" ] }, { "cell_type": "markdown", "id": "e770cf5f", "metadata": {}, "source": [ "String tipinde bir değişkenin başındaki veya sonundaki boşlukları `strip()` metodu ile silebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "58bfc69d", "metadata": {}, "outputs": [], "source": [ "ornekMetin = \" TÜRKİYE BÜYÜK MİLLET MECLİSİ \"\n", "print(ornekMetin.strip())" ] }, { "cell_type": "markdown", "id": "ddc35e6c", "metadata": {}, "source": [ "String tipinde bir değişkeni `split()` metodu ile istediğimiz yerden ayırarak bir listeye dönüştürebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "2ba46ab0-ffba-4c1a-bb7b-5ddb2c373c8d", "metadata": {}, "outputs": [], "source": [ "s1 = \"Türkiye Büyük Millet Meclisi\"\n", "s2 = \"Türkiye, 23 Ekim 1923, Ankara\"\n", "print(s1.split()) #split'in içini boş bırakırsan boşluklardan ayırır.\n", "print(s2.split(\", \")) #split'in içine tırnak içinde yazdığın ifadeyi baz alarak ayırır." ] }, { "cell_type": "markdown", "id": "89b2b58c-d515-4199-8ded-6de1ae67db22", "metadata": {}, "source": [ "
Etkinlik: \"İnsanın, gölgesiyle tanımlandığı bir çağda, marşlara düşer belki birkaç şey açıklamak\" mısrasını virgül+boşluk karakterinden \", \" ayırarak bir listeye dönüştürünüz ve alt alta yazdırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "5c5f7312-3031-4f0b-851f-0bfdae35b9f1", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "misra = \"İnsanın, gölgesiyle tanımlandığı bir çağda, marşlara düşer belki birkaç şey açıklamak\"\n", "misra = misra.split(\", \")\n", "print(*misra,sep=\"\\n\") #stringlerin başına gelen * sembolünün işlevini öncesinde görmüştük." ] }, { "cell_type": "markdown", "id": "fc71d61d", "metadata": {}, "source": [ "Karakter dizilerinin (string) karakterlerine `[ : ]` ile erişebiliriz. Köşeli parantezler arasına karakterin sıra (index) numarasını yazarız. Bu işlemlere **'dilimleme'** denir." ] }, { "cell_type": "code", "execution_count": null, "id": "2ca7eec6", "metadata": {}, "outputs": [], "source": [ "ornek = \"Pythhon\"\n", "print(ornek[0]) #tek karakter için o karakterin sırasını girmeliyiz (dizilerde sıra 0(sıfır)dan başlar)\n", "print(ornek[0:3]) #aralık için iki nokta ile başlama ve bitiş index'ini girmeliyiz\n", "print(ornek[:2]) #başlangıç belirtmeseniz ilk sıradan başlar\n", "print(ornek[3:]) #bitiş belirtmeseniz karakter dizisinin sonuna kadar alır" ] }, { "cell_type": "markdown", "id": "af40233c", "metadata": {}, "source": [ "
Etkinlik: Adınızı çeşitli şekillerde dilimleyiniz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "fdec6cc2-44d6-44a5-9b82-ed98d179e8a5", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "ad = input(\"Adınızı Giriniz: \")\n", "print(ad[:3],ad[3:],ad[::-1],sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "d20327cc", "metadata": {}, "source": [ "Karakter dizilerini (string) dilimlerken karakter ilerleme sırasını belirleyebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "0414d512", "metadata": {}, "outputs": [], "source": [ "ornek = \"TÜRKİYE\"\n", "print(ornek[0:8:2]) #0. indexten başlayarak 7.indexe kadar 2'şer karakter ilerledik.\n", "print(ornek[-1:-8:-1]) #Tersten sıraladık. -1. indexten başlayarak -7.indexe kadar tersten 1'er karakter ilerledik." ] }, { "cell_type": "markdown", "id": "2dce1b5a", "metadata": {}, "source": [ "
Etkinlik: input() foknsiyonu ile kullanıcıdan alınan T.C. Numarasını ekrana tersten yazdırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "83bd0f73-9d20-4419-8685-923523bbd367", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "vatandaslikNo = input(\"Vatandaşlık Numaranızı Giriniz: \")\n", "print(vatandaslikNo[::-1])" ] }, { "cell_type": "markdown", "id": "47251c9e", "metadata": {}, "source": [ "Karakter dizileri ile ilgili diğer operatör ve metotlara sonradan değineceğiz.
\n", "Karakter dizilerinin diğer metotlarını şöyle görüntüleyebilirsiniz:" ] }, { "cell_type": "code", "execution_count": null, "id": "63267ec8", "metadata": {}, "outputs": [], "source": [ "print(dir(str))" ] }, { "cell_type": "markdown", "id": "bc20e853", "metadata": {}, "source": [ "## Integer (int) " ] }, { "cell_type": "markdown", "id": "7a476733-e33c-4283-aea7-57c6920759ea", "metadata": {}, "source": [ "Tamsayı değişken tipidir. Matematiksel işlemler yapmada kullanılır. Pozitif veya negatif olabilir. Çift tırnak (\"\") veya tek tırnak ('') arasına **yazılmaz.** Örnek tamsayı tipinde değişkenler:" ] }, { "cell_type": "code", "execution_count": null, "id": "c8007d72", "metadata": {}, "outputs": [], "source": [ "i1 = 99\n", "i2 = -99\n", "print(i1,i2,sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "40eac104", "metadata": {}, "source": [ "Tipini bilmediğimiz değişkenler için tipini öğrenmek amacıyla `type()` foknsiyonunu kullanarak tipini görüntüleyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "c00838fa", "metadata": {}, "outputs": [], "source": [ "i = 1919\n", "print(type(i))" ] }, { "cell_type": "markdown", "id": "84c2fe25", "metadata": {}, "source": [ "Integer (int) olmayan bir değişkeni integer'a dönüştürmek için `int()` fonksiyonu kullanılır. Fakat dönüştürülmek istenen veri tamamen rakamlardan (nümerik) oluşmalıdır, aksi halde hata verir." ] }, { "cell_type": "code", "execution_count": null, "id": "cb451fd6", "metadata": {}, "outputs": [], "source": [ "metin = \"1923\"\n", "print(int(metin))\n", "print(type(int(metin)))" ] }, { "cell_type": "markdown", "id": "2daa3969-dadc-40fc-adbb-a3f5ae9c4924", "metadata": {}, "source": [ "
Etkinlik: input() foknsiyonu ile kullanıcıdan yaşını alınız ve değişken tipini type() fonksiyonu ile ekrana yazdırınız. Ardından bu veriyi tamsayıya çeviriniz ve yeniden değişken tipini ekrana bastırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "1ac5b174-0331-445c-aa89-44fad56a04ad", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "yas = input(\"Yaşınızı Giriniz: \")\n", "print(type(yas))\n", "yas = int(yas)\n", "print(type(yas))" ] }, { "cell_type": "markdown", "id": "67764571", "metadata": {}, "source": [ "### Integer (int) Değişkeninin Metotları" ] }, { "cell_type": "markdown", "id": "01615129-8bc0-432e-a530-fc55bfc19deb", "metadata": {}, "source": [ "Tam sayıların 2'lik sayı sistemindeki basamak uzunluklarını bulmak için `bit_length()` metodu kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "c608663a", "metadata": {}, "outputs": [], "source": [ "i = 155\n", "print(i.bit_length())" ] }, { "cell_type": "markdown", "id": "453d83f1", "metadata": {}, "source": [ "
Etkinlik: input() foknsiyonu ile kullanıcıdan yaşını alarak önce integer'a çeviriniz sonra da 2'lik sayı sistemindeki basamak sayısını bularak ekrana yazdırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "e867d2f6-9df2-42d6-9397-cbd8a6dce35d", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "yas = input(\"Yaşınızı Giriniz: \")\n", "print(int(yas).bit_length())" ] }, { "cell_type": "markdown", "id": "e008d103", "metadata": {}, "source": [ "Tam sayılar ile ilgili diğer operatör ve metotlara sonradan değineceğiz.
\n", "Tam sayıların diğer metotlarını şöyle görüntüleyebilirsiniz:" ] }, { "cell_type": "code", "execution_count": null, "id": "666b1a72", "metadata": {}, "outputs": [], "source": [ "print(dir(int))" ] }, { "cell_type": "markdown", "id": "d9a0df29", "metadata": {}, "source": [ "## Float (float)" ] }, { "cell_type": "markdown", "id": "026732bb-9c73-4086-8d6f-3caea68ba905", "metadata": {}, "source": [ "Ondalıklı sayı değişken tipidir. **Ondalık ayıracı nokta (.) dır.** Matematiksel işlemler yapmada kullanılır. Pozitif veya negatif olabilir.
Çift tırnak (\" \") veya tek tırnak (' ') arasına **yazılmaz.** Örnek ondalıklı sayı tipinde değişkenler:" ] }, { "cell_type": "code", "execution_count": null, "id": "548c0813", "metadata": {}, "outputs": [], "source": [ "f1 = 15.75\n", "f2 = -15.75\n", "print (f1,f2,sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "d935046a", "metadata": {}, "source": [ "Tipini bilmediğimiz değişkenler için tipini öğrenmek amacıyla `type()` foknsiyonunu kullanarak tipini görüntüleyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "7248d051", "metadata": {}, "outputs": [], "source": [ "f = 1923.0\n", "print(type(f))" ] }, { "cell_type": "markdown", "id": "fcbf0710-fc57-4d3f-8e41-e68cbde3f354", "metadata": {}, "source": [ "
Etkinlik: Yaşınızı ondalıklı olarak bir değişkene atayın. Ondalıklı olarak hesaplarken örnek olarak 11 tam 5/12 (11 yaşımdan 5 ay büyüğüm) olarak hesaplayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "94d5b477-6f63-475e-b486-ebb1986ca3e5", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "yas = 11+8/12\n", "print(yas,type(yas),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "229830d3", "metadata": {}, "source": [ "Float (float) olmayan bir değişkeni float'a dönüştürmek için `float()` foknsiyonu kullanılır. Fakat dönüştürülmek istenen veri tamamen rakamlardan (nümerik) oluşmalıdır, aksi halde hata verir." ] }, { "cell_type": "code", "execution_count": null, "id": "162be4d8", "metadata": {}, "outputs": [], "source": [ "i = 1923\n", "print(float(i))\n", "print(type(float(i)))" ] }, { "cell_type": "markdown", "id": "e6f8422c", "metadata": {}, "source": [ "### Float (float) Değişkeninin Metotları\n", "Birbirine bölününce ondalıklı sayıyı veren tam sayıları bulmak için `as_integer_ratio()` metodu kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "5f442e8b", "metadata": {}, "outputs": [], "source": [ "f1 = 7.5\n", "print(f1.as_integer_ratio())" ] }, { "cell_type": "markdown", "id": "3359616f", "metadata": {}, "source": [ "
Etkinlik-6.13: Float (ondalıklı) olarak hesapladığınız yaşınızın hangi sayıları bölünce ortaya çıktığını as_integer_ratio metodu ile öğreniniz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "cf50ea9c-092e-445d-9aec-305094382283", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "yas = 15.6 #burayı float sayılarla değiştirerek sonucu gözlemleyebilirsiniz\n", "print(yas.as_integer_ratio())" ] }, { "cell_type": "markdown", "id": "565d383c", "metadata": {}, "source": [ "Ondalıklı sayılar ile ilgili diğer operatör ve metotlara sonradan değineceğiz.
\n", "Ondalıklı sayıların diğer metotlarını şöyle görüntüleyebilirsiniz:" ] }, { "cell_type": "code", "execution_count": null, "id": "f58e962e", "metadata": {}, "outputs": [], "source": [ "print(dir(float))" ] }, { "cell_type": "markdown", "id": "b6048428", "metadata": {}, "source": [ "## Boolean (bool)" ] }, { "cell_type": "markdown", "id": "8506fbbe-9df5-4925-b427-5192bd7606f2", "metadata": {}, "source": [ "Mantıksal veri tipidir. Sadece 'True' (doğru) ve 'False' (yanlış) değerini alır. Esasında bir sorgulama sonucudur. Mantıksal bütün sorguların sonucu True veya False olur. Örnek boolean tipi sorgulamalar:" ] }, { "cell_type": "code", "execution_count": null, "id": "70e83769", "metadata": {}, "outputs": [], "source": [ "b1 = True\n", "b2 = False\n", "print(b1,b2,sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "7389cf15-9c2b-459a-97b5-2023a3cda3f6", "metadata": {}, "source": [ "Bir değişkeni boolean veri tipine çevirmek için `bool()` fonksiyonu kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "515c093d-514f-49d8-a94d-12d33085b612", "metadata": {}, "outputs": [], "source": [ "ornek1 = \"Türkiye\"\n", "ornek2 = \"\"\n", "ornek3 = 0\n", "ornek4 = 1923\n", "\n", "ornek1=bool(ornek1)\n", "ornek2=bool(ornek2)\n", "ornek3=bool(ornek3)\n", "ornek4=bool(ornek4)\n", "\n", "print(ornek1,ornek2,ornek3,ornek4,sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "8f2449de-cf99-42db-9791-503d697acfb5", "metadata": {}, "source": [ "
Etkinlik: Sayı olan sıfır (0) ve sıfırdan farklı herhangi bir sayıyı boolean veri tipinde ekrana bastırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "04c523bd-5bb8-48fb-990a-ce186d50529c", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "bir = 1\n", "sifir = 0\n", "print(bool(sifir),bool(bir),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "6c91629b", "metadata": {}, "source": [ "Tipini bilmediğimiz değişkenler için tipini öğrenmek amacıyla `type()` foknsiyonunu kullanarak tipini görüntüleyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "4d558c30", "metadata": {}, "outputs": [], "source": [ "b1 = True\n", "b2 = False\n", "print(type(b1),type(b2),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "d3480cbf", "metadata": {}, "source": [ "## List (list) " ] }, { "cell_type": "markdown", "id": "a6c66699-b2a9-44ba-bb73-debc8174f489", "metadata": {}, "source": [ "Liste demektir, elemanlardan oluşan çok değişkenli veri tipidir. Listeler köşeli parantez [ ] ile başlar ve biter. İlk elemanın sırası (index) 0'dır. Listedeki elemanların arasında virgül (,) konur. Listede str, int, float, bool veya list elemanları aynı anda olabilir.
\n", "**Özellikleri:**
\n", "- Listedeki elemanların sırası(index) vardır ve sıraları değiştirilebilir.
\n", "- Listeye eleman ekleme-çıkarma veya listeyi başka bir liste ile birleştirme yapılabilir.
\n", "- Aynı elemandan birkaç tane (duplicate) olabilir.\n", "- String veri tipinin **dilimleme** metotları aynen uygulanabilir.\n", "- Sonradan eleman girilmek üzere boş bir liste ( [ ] ) oluşturulabilir.
\n", "Örnek liste değişken tipinde veri:" ] }, { "cell_type": "code", "execution_count": null, "id": "dea1cd75", "metadata": {}, "outputs": [], "source": [ "liste = [\"Python\",1994,3.10,True,[\"En Popüler\",\"Programlama Dili\",1]]\n", "print(liste)\n", "print(liste[2])\n", "print(liste[1:4])\n", "print(type(liste))" ] }, { "cell_type": "markdown", "id": "32f51f47", "metadata": {}, "source": [ "Sadece string veri tipi bir listeye dönüştürülebilir. Bunun için `list()` foknsiyonu kullanılır. Diğer veri tiplerini listeye çevirmek için önce `str()` ile stringe çeviriniz." ] }, { "cell_type": "code", "execution_count": null, "id": "2fd141e6", "metadata": {}, "outputs": [], "source": [ "s = \"Türkiye 2023\"\n", "print(list(s),type(list(s)),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "bb73ec5d", "metadata": {}, "source": [ "Bir sayı listesi oluşturmak için `range()` (aralık) foknsiyonu ile sayı listesi oluşturulabilir. Bunun için `list()` ve `range()` fonksiyonu kullanılır. `range()` fonksiyonu liste tipinden bağımsız başka işlemlerle de kullanılmaktadır." ] }, { "cell_type": "code", "execution_count": null, "id": "49fd3a15", "metadata": {}, "outputs": [], "source": [ "l = list(range(1,16))\n", "print(l)" ] }, { "cell_type": "markdown", "id": "4652121e", "metadata": {}, "source": [ "
Etkinlik-6.15: -5 ile +5 arasındaki sayılardan oluşan bir liste oluşurunuz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "b60cb631-f780-4490-9078-227723ad1824", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü:\n", "liste = [-5,-4,-3,-2,-1,0,1,2,3,4,5]\n", "print(liste)" ] }, { "cell_type": "markdown", "id": "f0b4a6e9", "metadata": {}, "source": [ "Listelerin (list) eleman sayısını `len()` foknsiyonu ile öğrenebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "f5a81309", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "print(len(l))" ] }, { "cell_type": "markdown", "id": "0e748497", "metadata": {}, "source": [ "### List (list) Değişkeninin Metotları" ] }, { "cell_type": "markdown", "id": "91c7a1ce-277b-4fb9-82db-3d0bf4168d3a", "metadata": {}, "source": [ "Listelere `append()` metodu ile **listenin sonuna** eklenmek üzere yeni eleman eklenebilir." ] }, { "cell_type": "code", "execution_count": null, "id": "15058a57", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\"]\n", "l.append(\"Pazar\")\n", "print(l)" ] }, { "cell_type": "markdown", "id": "b7d81ded", "metadata": {}, "source": [ "Listedeki bir elemanın sırası `index()` metodu ile bulunabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "a84f190b", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\"]\n", "print(l.index(\"Perşembe\"))" ] }, { "cell_type": "markdown", "id": "bd4f5849", "metadata": {}, "source": [ "
Etkinlik: Adınızı list() foknsiyonu ile listeye çevirdikten sonra listenin sonuna yaşınızı sayı olarak ekleyiniz ve yaşınızın listedeki sırasını bulunuz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "d4b5589e-2c00-4c2d-8d65-ccbb5b84a3cc", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "isim = \"TÜRKİYE\"\n", "isim = list(isim)\n", "isim.append (100)\n", "print(isim)\n", "print(isim.index(100))" ] }, { "cell_type": "markdown", "id": "ac3d1c11", "metadata": {}, "source": [ "Listelere `insert()` metodu ile **listenin istenilen sırasına(index)** eklenmek üzere yeni eleman eklenebilir. Insert metodu `insert(sıra,değer)` olarak çalışmaktadır." ] }, { "cell_type": "code", "execution_count": null, "id": "a73580bb", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\"]\n", "l.insert(1,\"Salı\")\n", "l.insert(6,\"Pazar\")\n", "print(l)" ] }, { "cell_type": "markdown", "id": "eeaca1e3", "metadata": {}, "source": [ "Listeden bir elemana değeriyle erişilerek silinebilir. Bunun için `remove()` metodu kullanılır. Remove metodunu kullanırken silmek istediğiniz değerin listedeki sırasını bilmenize gerek yoktur. Eğer aynı değerden birkaç tane varsa sırası (index) en küçük olanı (ilk sırada olanı) siler." ] }, { "cell_type": "code", "execution_count": null, "id": "ff78a890", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\",\"Ocak\",\"Şubat\",\"Ocak\"]\n", "l.remove(\"Ocak\")\n", "print(l)" ] }, { "cell_type": "markdown", "id": "26ff92af", "metadata": {}, "source": [ "Listeden bir elemanı sırasına(index) erişilerek silinebilir. Bunun için iki yöntem vardır; `pop()` ve `del()` metotları kullanılır.
\n", "Pop metodu ile belirttiğiniz sıradaki(index) eleman silinir. İndex numarası belirtilmezse listenin sonundaki elemanı siler.
\n", "Del metodu ile belirttiğiniz sıradaki(index) eleman silinir. İndex numarası belirtilmezse **ilgili liste değişkenini tamamen ortadan kaldırır.**" ] }, { "cell_type": "code", "execution_count": null, "id": "b06ead02", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\",\"Ocak\",\"Ocak\"]\n", "l.pop(7)\n", "del l[0]\n", "print(l)" ] }, { "cell_type": "markdown", "id": "8894f25b", "metadata": {}, "source": [ "
Etkinlik: 1'den 10'a kadar tamsayıların bulunduğu bir listeden 7 sayısını siliniz ve aynı sıraya tekrar ekleyiniz.
" ] }, { "cell_type": "code", "execution_count": null, "id": "db6d1358-57c2-4a14-a840-f49be9537bf9", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "sayilar = [1,2,3,4,5,6,7,8,9,10]\n", "sayilar.pop(6)\n", "print(sayilar)\n", "sayilar.insert(6,7)\n", "print(sayilar)" ] }, { "cell_type": "markdown", "id": "4c846016", "metadata": {}, "source": [ "Listedeki tüm elemanları `clear()` metodu ile silebiliriz. Bu metodla listenin içi boşalır ve ilgili liste değişkeni kullanılmaya devam edilir. Yani liste değişkeni ortadan kalkmaz." ] }, { "cell_type": "code", "execution_count": null, "id": "21638f61", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "l.clear()\n", "print(l)" ] }, { "cell_type": "markdown", "id": "80933f4b", "metadata": {}, "source": [ "Liste elemanları başka bir değişkene `copy()` metodu ile liste olarak kopyalanabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "fe70cc1d", "metadata": {}, "outputs": [], "source": [ "l1 = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "l2 =l1.copy()\n", "print(l2)" ] }, { "cell_type": "markdown", "id": "1ccaef26", "metadata": {}, "source": [ "Liste elemanları `sort()` metodu ile A'dan Z'ye veya küçükten büyüğe doğru sıralanabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "2aea5c10", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "l.sort()\n", "print(l)" ] }, { "cell_type": "code", "execution_count": null, "id": "47a0b97c", "metadata": {}, "outputs": [], "source": [ "l = [3,4,5,1,2,6,7]\n", "l.sort()\n", "print(l)" ] }, { "cell_type": "markdown", "id": "e7e03a86", "metadata": {}, "source": [ "Liste elemanları `sort()` metodu ile Z'den A'ya veya büyükten küçüğe doğru da sıralanabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "c2a08027-03c5-4933-bc16-d2eca8d576db", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "l.sort(reverse=True)\n", "print(l)" ] }, { "cell_type": "code", "execution_count": null, "id": "a56bb919", "metadata": {}, "outputs": [], "source": [ "l = [3,4,5,1,2,6,7]\n", "l.sort(reverse=True)\n", "print(l)" ] }, { "cell_type": "markdown", "id": "6ed622c6", "metadata": {}, "source": [ "Liste elemanları `reverse()` metodu ile tersine çevrilebilir." ] }, { "cell_type": "code", "execution_count": null, "id": "11b51ea3", "metadata": {}, "outputs": [], "source": [ "l = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "l.reverse()\n", "print(l)" ] }, { "cell_type": "markdown", "id": "3e600ac0", "metadata": {}, "source": [ "
Etkinlik: Adınızı list() foknsiyonu ile listeye çevirdikten sonra isminizdeki harfleri A'dan Z'ye, Z'den A'ya ve tersten olmak üzere farklı şekillerde sıralayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "cb167de0-4ac2-4562-9626-e0e6c7e22b36", "metadata": {}, "outputs": [], "source": [ "# Etkinlik Çözümü\n", "isim = \"TÜRKİYE\"\n", "isim = list(isim)\n", "isim.sort()\n", "print(isim)\n", "isim.sort(reverse=True)\n", "print(isim)" ] }, { "cell_type": "markdown", "id": "7c43897e", "metadata": {}, "source": [ "Listedeki elemanlardan kaçar tane olduğu `count()` metodu ile bulunabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "7df64b49", "metadata": {}, "outputs": [], "source": [ "l = [1,1,1,1,2,2,2,2,2,3,3,3,3,3,3,4,5,6,7]\n", "print(l.count(1))\n", "print(l.count(5))" ] }, { "cell_type": "markdown", "id": "efda8250", "metadata": {}, "source": [ "Listedeki elemanlardan sayısal olarak en büyük veya alfabetik olarak en sonda olan `max()` foknsiyonu ile, sayısal olarak en küçük veya alfabetik olarak en önde olan `min()` foknsiyonu ile bulunabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "700a0aab", "metadata": {}, "outputs": [], "source": [ "l = [\"A\",\"B\",\"C\",\"D\",\"E\",\"F\",\"G\",\"Z\"]\n", "print(max(l))\n", "print(min(l))" ] }, { "cell_type": "code", "execution_count": null, "id": "0fc4e598", "metadata": {}, "outputs": [], "source": [ "l = [101,345,543,786,908,123,434]\n", "print(max(l))\n", "print(min(l))" ] }, { "cell_type": "markdown", "id": "f8f1e938", "metadata": {}, "source": [ "## Tuple (tuple)" ] }, { "cell_type": "markdown", "id": "781d3a3f-af36-4011-94cc-127301fa1e0e", "metadata": {}, "source": [ "Demet demektir. Liste değişken tipi gibi elemanlardan oluşan çok değişkenli veri tipidir. Demetler normal parantez ( ) ile başlar ve biter. İlk elemanın sırası (index) 0'dır. Demetteki elemanların arasında virgül (,) konur. Demette str, int, float, bool veya list elemanları aynı anda olabilir.
\n", "**Özellikleri:**
\n", "- Demetteki elemanların sırası(index) vardır ve sıraları **değiştirilemez**.
\n", "- Demete eleman ekleme-çıkarma **yapılamaz** ama başka bir demetle ile birleştirme yapılabilir.
\n", "- Aynı elemandan birkaç tane (duplicate) olabilir.
\n", "- String veri tipinin **dilimleme** metotları aynen uygulanabilir.
\n", "Örnek demet veri tipi değişkeni:" ] }, { "cell_type": "code", "execution_count": null, "id": "f4e2385c", "metadata": {}, "outputs": [], "source": [ "yazAylari = (\"Haziran\",\"Temmuz\",\"Ağustos\")\n", "print(yazAylari)\n", "print(yazAylari[1])\n", "print(yazAylari[0:2])\n", "print(type(yazAylari))" ] }, { "cell_type": "markdown", "id": "60aee67c", "metadata": {}, "source": [ "Sadece string veya liste veri tipi bir demete dönüştürülebilir. Bunun için `tuple()` foknsiyonu kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "6e300736", "metadata": {}, "outputs": [], "source": [ "d = \"Tükiye 2023\"\n", "print(tuple(d),type(tuple(d)),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "10d79e56", "metadata": {}, "source": [ "Demetlerin eleman sayısı `len()` foknsiyonu ile bulunabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "279fe223", "metadata": {}, "outputs": [], "source": [ "d = (\"Aralık\",\"Ocak\",\"Şubat\")\n", "print(len(d))" ] }, { "cell_type": "markdown", "id": "ce87179b", "metadata": {}, "source": [ "### Tuple (tuple) Değişkeninin Metotları" ] }, { "cell_type": "markdown", "id": "2a6fa6bf-524a-4db2-b2e0-df753f02e9e5", "metadata": {}, "source": [ "Demetlerde `index()` metodu ile elemanın sırası bulunabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "95cf83de", "metadata": {}, "outputs": [], "source": [ "d = (\"Aralık\",\"Ocak\",\"Şubat\")\n", "print(d.index(\"Ocak\"))" ] }, { "cell_type": "markdown", "id": "91501d8a", "metadata": {}, "source": [ "Demetlerde `count()` metodu ile hangi elemandan kaç tane olduğu bulunabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "6868afa2", "metadata": {}, "outputs": [], "source": [ "d = (1,1,1,1,2,2,2,3,3,3,3,3,3,3,4,4,4,5)\n", "print(d.count(3))" ] }, { "cell_type": "markdown", "id": "2bf8773d-4f70-4476-95d0-30fda63d9338", "metadata": {}, "source": [ "
Etkinlik: Bir programcı kayıt esnasında sırasıyla TC, Ad, Soyad ve Doğum Yılı verilerini alacaktır. Bu sıranın daha sonra da hackerlar tarafından değiştirilmemesi için tuple yöntemiyle alıyor. Bu şekilde çalışacak algoritmayı kodlayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "942b2cb6-ef5f-4d61-b963-05ad59546bb1", "metadata": {}, "outputs": [], "source": [ "#Etkinlik Çözümü\n", "tc = input(\"Vatandaşlık Numaranızı Giriniz: \")\n", "ad = input(\"Tam Adınızı Giriniz: \")\n", "dogum = input(\"Doğum Tarihinizi Giriniz: \")\n", "veriler = (tc,ad,dogum)\n", "print(veriler)" ] }, { "cell_type": "markdown", "id": "cdb54bc1", "metadata": {}, "source": [ "## Set (set) " ] }, { "cell_type": "markdown", "id": "12d43893-149a-4896-be17-2a78d25b86db", "metadata": {}, "source": [ "Küme demektir. Liste değişken tipi gibi elemanlardan oluşan çok değişkenli veri tipidir. Kümeler kıvırcıklı parantez { } ile başlar ve biter. Küme elemanlarında sıra (index) yoktur. Kümedeki elemanların arasında virgül (,) konur. Kümede str, int, float veya bool elemanları aynı anda olabilir.
\n", "**Özellikleri:**
\n", "- Kümedeki elemanların **sırası(index) yoktur** ve sıraları **değiştirilemez**.
\n", "- Kümeye eleman ekleme-çıkarma veya başka bir küme ile birleştirme yapılabilir.
\n", "- **Aynı elemandan birkaç tane (duplicate) olamaz.**
\n", "- **Dilimleme** metotları **uygulanamaz**.
\n", "- Kümelerin içinde list veya tuple tipinde elemanları **olamaz.**
\n", "Örnek küme veri tipi değişkeni:" ] }, { "cell_type": "code", "execution_count": null, "id": "3ad60072", "metadata": {}, "outputs": [], "source": [ "k = {1,2,3,\"Türkiye\"}\n", "print(k,len(k),type(k),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "e5a08f28", "metadata": {}, "source": [ "Sadece string, list veya tuple veri tipi bir kümeye dönüştürülebilir. Bunun için `set()` foknsiyonu kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "e522d596", "metadata": {}, "outputs": [], "source": [ "s = \"Python\"\n", "l =[1,2,3]\n", "t=(\"a\",\"b\",\"c\")\n", "print(set(s))\n", "print(set(l))\n", "print(set(d))" ] }, { "cell_type": "markdown", "id": "316b6491", "metadata": {}, "source": [ "Bir sayı kümesi tanımlamak için `range()` (aralık) foknsiyonu ile küme tanımlanabilir. Bunun için `set()` ve `range()` foknsiyonları kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "822a63a7", "metadata": {}, "outputs": [], "source": [ "k = set(range(1,10)) #1'den 10'a kadar olan sayılardan bir küme oluşturduk.\n", "print(k)" ] }, { "cell_type": "markdown", "id": "46505ac6", "metadata": {}, "source": [ "### Set (set) Değişkeninin Metotları" ] }, { "cell_type": "markdown", "id": "32f7ab9f-8a21-4377-8c1b-b6f0ee439757", "metadata": {}, "source": [ "Kümelere `add()` metodu ile eleman eklenebilir." ] }, { "cell_type": "code", "execution_count": null, "id": "4c4bcb40", "metadata": {}, "outputs": [], "source": [ "k = {\"T\",\"Ü\",\"R\",\"K\",\"İ\",\"Y\",\"E\"}\n", "k.add(1923)\n", "print(k)" ] }, { "cell_type": "markdown", "id": "b63a0338", "metadata": {}, "source": [ "Kümelerden `remove()` metodu ile eleman silinebilir. Silmek istediğiniz eleman yok ise **hata verir.**" ] }, { "cell_type": "code", "execution_count": null, "id": "69545cf8", "metadata": {}, "outputs": [], "source": [ "k = {\"T\",\"Ü\",\"R\",\"K\",\"İ\",\"Y\",\"E\",1923}\n", "k.remove(1923)\n", "print(k)" ] }, { "cell_type": "markdown", "id": "234e5997", "metadata": {}, "source": [ "Kümelerden `discard()` metodu ile de eleman silinebilir. Silmek istediğiniz eleman yok ise **hata vermez**." ] }, { "cell_type": "code", "execution_count": null, "id": "cdf812d0", "metadata": {}, "outputs": [], "source": [ "k = {\"T\",\"Ü\",\"R\",\"K\",\"İ\",\"Y\",\"E\",1923}\n", "k.discard(\"İ\")\n", "k.discard(\"Y\")\n", "k.discard(\"E\")\n", "k.discard(2023)\n", "print(k)" ] }, { "cell_type": "markdown", "id": "45c18c80", "metadata": {}, "source": [ "Kümeler `clear()` metodu ile temizlenebilir." ] }, { "cell_type": "code", "execution_count": null, "id": "df291bcb", "metadata": {}, "outputs": [], "source": [ "k = {\"T\",\"Ü\",\"R\",\"K\",\"İ\",\"Y\",\"E\",1923}\n", "k.clear()\n", "print(k)" ] }, { "cell_type": "markdown", "id": "4cb96ae5", "metadata": {}, "source": [ "Kümeler `update()` metodu ile birleştirilebilir veya `union()` ile birleşik yeni bir küme oluşturulabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "e533da88", "metadata": {}, "outputs": [], "source": [ "k1 = {\"T\",\"Ü\",\"R\",\"K\"}\n", "k2 = {\"İ\",\"Y\",\"E\"}\n", "k3 = k1.union(k2)\n", "print(k1,k3,sep=\"\\n\")\n", "\n", "k1.update(k2)\n", "print(k1)" ] }, { "cell_type": "markdown", "id": "2cd11285", "metadata": {}, "source": [ "Kümelerin `intersection()` metodu ile kesişimleri, `difference()` metodu ile farkları bulunabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "2fd2e7ac", "metadata": {}, "outputs": [], "source": [ "k1 = {\"P\",\"Y\",\"T\",\"H\",\"O\",\"N\"}\n", "k2 = {\"F\",\"A\",\"Y\",\"T\",\"O\",\"N\"}\n", "print(k1.intersection(k2))\n", "print(k1.difference(k2))" ] }, { "cell_type": "markdown", "id": "2858737b-97e3-4f17-9b46-a092c7135e23", "metadata": {}, "source": [ "
Etkinlik: Adam asmaca oyununda oyuncu kelimeyi tahmin etmeden önce oyuncudan 5 tane harf alınır ve bu harfler ile kelimede bulunan harfler karşılaştırılarak ikisinde de olanlar bulunur. Bu algoritmayı kodlayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "2bf18ce6-127e-4257-8d0f-b4f80ba3123d", "metadata": {}, "outputs": [], "source": [ "#Etkinlik Çözümü\n", "kelime = \"TÜRKİYE CUMHURİYETİ\"\n", "kelime = set(kelime)\n", "tahminler = []\n", "tahminler.append(input(\"1. Harfi Giriniz: \").upper())\n", "tahminler.append(input(\"2. Harfi Giriniz: \").upper())\n", "tahminler.append(input(\"3. Harfi Giriniz: \").upper())\n", "tahminler.append(input(\"4. Harfi Giriniz: \").upper())\n", "tahminler.append(input(\"5. Harfi Giriniz: \").upper())\n", "tahminler = set(tahminler)\n", "print(kelime.intersection(tahminler))\n" ] }, { "cell_type": "markdown", "id": "8945081e", "metadata": {}, "source": [ "## Frozenset (frozenset) " ] }, { "cell_type": "markdown", "id": "c0acc2d2-49ce-462c-9060-9a3ed89ffc5f", "metadata": {}, "source": [ "Kısıtlanmış küme demektir. Liste değişken tipi gibi elemanlardan oluşan çok değişkenli veri tipidir. Kısıtlanmış kümeler bir listenin başına `frozenset()` foknsiyonu girilmesi ile oluşur. Küme elemanlarında sıra (index) yoktur. Kümedeki elemanların arasında virgül (,) konur. Kümede str, int, float veya bool elemanları aynı anda olabilir.
\n", "**Özellikleri:**
\n", "- Kısıtlanmış kümedeki elemanların **sırası(index) yoktur** ve sıraları **değiştirilemez**.
\n", "- Kısıtlanmış kümeye eleman **ekleme-çıkarma veya başka bir liste tipi değişkenle birleştirme yapılamaz**.
\n", "- **Aynı elemandan birkaç tane (duplicate) olamaz.**
\n", "- **Dilimleme** metotları **uygulanamaz**.
\n", "- Kıtılanmış kümelerin içinde list veya tuple tipinde elemanları **olamaz.**
\n", "Örnek kısıtlanmış küme veri tipi değişkeni:" ] }, { "cell_type": "code", "execution_count": null, "id": "d0738134", "metadata": {}, "outputs": [], "source": [ "fs = frozenset([\"pazartesi\",\"salı\",\"çarşamba\",\"perşembe\",\"cuma\",\"cumartesi\",1,2,3,4,5,6])\n", "print (fs)" ] }, { "cell_type": "markdown", "id": "912dc2fe-66ec-49a4-a3c3-d4ca778967c3", "metadata": {}, "source": [ "
Etkinlik: Bir yazılım yapan Ali bu yazılım lisansla satıyor. Bu lisansları tuttuğu bir değişkeni var ve lisansların değiştirilmesini önlemek için bir yöntem buluyor. Bu algoritmayı kodlayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "6c5ee4cc-438c-4ca3-a0e9-7d6a4c00c2bd", "metadata": {}, "outputs": [], "source": [ "#Etkinlik Çözümü\n", "lisanslar = set([\"ABC-123-XYZ\",\"DEF-456-WYZ\",\"GHI-789-ZWX\"])\n", "print(lisanslar)" ] }, { "cell_type": "markdown", "id": "42bb73c6", "metadata": {}, "source": [ "## Dictionary (dict)" ] }, { "cell_type": "markdown", "id": "960a53f7-f480-4e1e-9dce-a7c4f1dbe5d5", "metadata": {}, "source": [ "Sözlük demektir. Küme değişken tipi gibi fakat 2 boyutlu elemanlardan oluşan çok değişkenli veri tipidir. Sözlükler kıvırcıklı parantez ile başlar ve biter. Sözlüklerde her eleman 2 öğeden oluşur. İlki 'key' (anahtar), ikincisi 'value' (değer)'dir. Öğelerin arasına : konur. Eleman sıraları değiştirilemez, ekleme çıkarma yapılabilir. Sözlüklerde öğelerin arasında virgül (,) konur. Sözlükte str, int, float veya bool elemanları aynı anda olabilir.
\n", "Örnek kısıtlanmış küme veri tipi değişkeni:" ] }, { "cell_type": "code", "execution_count": null, "id": "de063f11", "metadata": {}, "outputs": [], "source": [ "sozluk = {\"Python\":\"Bir programlama dilidir.\",\n", " \"Yazar\":\"Guido Van Rossum\",\n", " 1994:\"Python'ın yayınlandığı yıl.\",\n", " 2018:\"Van Rossum'un Python yönetiminiden istifa ettiği yıldır.\"}\n", "print (sozluk[\"Yazar\"])" ] }, { "cell_type": "markdown", "id": "3371f71b-6de9-4e32-94f1-9d67822abe94", "metadata": {}, "source": [ "Sözlüğe `sozluk[anahtar]=Değer` ile yeni eleman (anahtar:değer) (key:value) ikili olarak eklenir. Bu yöntemle eklenen değerler son eleman olarak eklenir." ] }, { "cell_type": "code", "execution_count": null, "id": "f1c76992-2245-488a-9727-4e8ac6e920b7", "metadata": {}, "outputs": [], "source": [ "sayilarinKaresi = {1:1,2:4,3:9,4:16}\n", "print(sayilarinKaresi)\n", "sayilarinKaresi[9]=81 #9 key'i ile 81 value'sini ekledik.\n", "print(sayilarinKaresi)" ] }, { "cell_type": "markdown", "id": "6dd74e73-944f-45cb-a9d8-8db45dc1cac8", "metadata": {}, "source": [ "Sözlükten `del` deyimi ile eleman silinebilir." ] }, { "cell_type": "code", "execution_count": null, "id": "422f0e6b-2864-406b-96ac-b836f363859a", "metadata": {}, "outputs": [], "source": [ "sayilarinKaresi = {1:1,2:4,3:9,4:16}\n", "del sayilarinKaresi[3]\n", "print(sayilarinKaresi)" ] }, { "cell_type": "markdown", "id": "89da84b4-275d-489e-9906-89565a1377a0", "metadata": {}, "source": [ "### Dictionary (dict) Değişkeninin Metotları" ] }, { "cell_type": "markdown", "id": "e42884d3-e003-418b-9543-748edc03cf56", "metadata": {}, "source": [ "Sözlükten eleman silmek için `pop()` metodu kullanılır. Bu metot kullanılırken parantez içine silincek anahtar(key) yazılır." ] }, { "cell_type": "code", "execution_count": null, "id": "aa1fea5f-7e16-4088-aa38-75b4ad4593d8", "metadata": {}, "outputs": [], "source": [ "sayilarinKaresi = {1:1,2:4,3:9,4:16}\n", "print(sayilarinKaresi)\n", "sayilarinKaresi.pop(3) #3 key'ine sahip eleman ikilisini sildik\n", "print(sayilarinKaresi)" ] }, { "cell_type": "markdown", "id": "8c8decf2-3f29-4db0-8acb-851a2d897c42", "metadata": {}, "source": [ "`update()` fonksşyonu ile bir sözlüğü başka bir sözlüğün verileriyle güncelleyebilir(ekleyebilir) bu işlemi string değerlerle de yapabilirsiniz." ] }, { "cell_type": "code", "execution_count": null, "id": "cd03741b-cf8a-4389-b9ed-b54f7e751fe9", "metadata": {}, "outputs": [], "source": [ "sayilarinKaresi = {1:1,2:4,3:9,4:16}\n", "eklenecekler = {5:25,6:36,7:49}\n", "sayilarinKaresi.update(eklenecekler)\n", "print(sayilarinKaresi)\n", "\n", "#update'i string değerlerle kullanabilirsiniz.\n", "sayilarinKaresi.update(Sekiz='AltmışDört', Dokuz='SeksenBir')\n", "print(sayilarinKaresi)" ] }, { "cell_type": "markdown", "id": "e8522d8e-6420-4f8c-9943-4c43cf9bd04d", "metadata": {}, "source": [ "Sözlükteki bir anahtarın değeri `get()` fonksiyonu ile alınabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "efc41be0-2121-41f2-b831-818e1b8a45d2", "metadata": {}, "outputs": [], "source": [ "sayilarinKaresi = {1:1,2:4,3:9,4:16}\n", "print(sayilarinKaresi.get(4))\n", "\n", "#bu içiçe (nested) bir şekilde de kullanılabilir\n", "matPuanlari = {\"Ada\":{\"1.Yazılı\":80,\"2.Yazılı\":90},\"Asya\":{\"1.Yazılı\":70,\"2.Yazılı\":85},\"Mete\":{\"1.Yazılı\":95,\"2.Yazılı\":100}}\n", "print(matPuanlari.get(\"Asya\").get(\"2.Yazılı\"))" ] }, { "cell_type": "markdown", "id": "0d555531-4d80-4de1-b594-05c6c4711865", "metadata": {}, "source": [ "
Etkinlik: Türk Devletlerinin başkentlerini bir sözlüğe kaydedediniz ve ülkeye göre çağırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "b127ce65-eca3-4b48-bbce-627a454847ee", "metadata": {}, "outputs": [], "source": [ "#Etkinliğin Çözümü\n", "baskentler = {\n", " \"Türkiye\":\"Ankara\",\n", " \"Azerbaycan\":\"Bakü\",\n", " \"Türkmenistan\":\"Aşkabat\",\n", " \"Kazakistan\":\"Astana\", #yanlış varsa update ile düzeltiniz.\n", " \"Özbekistan\":\"Taşkent\",\n", " \"Kırgızistan\":\"Bişkek\",\n", " \"Tataristan\":\"Kazan\"\n", "}\n", "print(baskentler.get(\"Tataristan\"))" ] }, { "cell_type": "markdown", "id": "d8be8677-6f37-4ec2-a241-07aa76d9e435", "metadata": {}, "source": [ "Bir liste türündeki (liste, demet, küme) değişken dizisi `fromkeys()` sözlük anahtarı olarak dönüştürülebilir. Hatta iki farklı liste türündeki değişken dizisi sözlük anahtarı ve değeri olarak birleştirilebilir." ] }, { "cell_type": "code", "execution_count": null, "id": "d7b1e43f-f5b4-499f-ad2f-e4e75456ae8e", "metadata": {}, "outputs": [], "source": [ "harfler = [\"A\",\"B\",\"C\",\"Ç\"]\n", "kod = (\"UTF-8\")\n", "harflerinKodu = dict.fromkeys(harfler,kod)\n", "print(harflerinKodu)" ] }, { "cell_type": "code", "execution_count": null, "id": "a7fb3376-5c5a-4c14-b8f2-73692c211b87", "metadata": {}, "outputs": [], "source": [ "harfler = [\"A\",\"B\",\"C\",\"Ç\"]\n", "harflerinKodu = dict.fromkeys(harfler) #ikinci parametre boş bırakılırsa value değeri boş olarak oluşur\n", "print(harflerinKodu)" ] }, { "cell_type": "code", "execution_count": null, "id": "44e9b0f2-2763-41f5-87f7-fe8ac2ab25a4", "metadata": {}, "outputs": [], "source": [ "harfler = [\"A\",\"B\",\"C\",\"Ç\"]\n", "harflerinKodu = dict.fromkeys(harfler,\"TÜRKÇE\") #ikinci parametre sabit olarak girilirse value değeri girilmiş olur.\n", "print(harflerinKodu)" ] }, { "cell_type": "markdown", "id": "045ad917-6db3-48e7-9374-7357a266aa8b", "metadata": {}, "source": [ "
Etkinlik: Bir yazılım yapan Ada bu yazılım ile günlük tutuyor. Tuttuğu günlüklerin anahtarı(key) tarih, değeri(value) ise o gün yazdıklarıdır. Sonra Ali geçmişe ait bir günün tarihini girerek o güne ait günceyi getiriyor. Bunu işlemi gerçekleştiren algoritmayı kodlayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "db74b4bf-a439-4db4-95b6-4ad2262be816", "metadata": {}, "outputs": [], "source": [ "#Etkinliğin Çözümü\n", "gunce = {\n", " 10.10.2022:\"Merhaba günlük bugün günlerde 3 Ekim ve Bilişim dersinde Python isimli bir dil olduğunu öğrendik.\",\n", " 17.10.2022:\"Merhaba günlük bugün her programlamada dilinde varolan temel kavramların olduğunu öğrendik.\",\n", " 24.10.2022:\"Merhaba günlük bugün değişkenlerin (verilerin) çeşitli tiplerde olabileceğini öğretti bize öğretmenimiz.\",\n", " 31.10.2022:\"Merhaba günlük bugün değişkenlerle çeşitli işlemler yapmayı öğredik. Mesela değer atama, toplama, birleştirme vb.\",\n", " 07.11.2022:\"Merhaba günlük bugün 'eğer öyleyse-değilse' karar yapısını öğrendik.\",\n", " 14.11.2022:\"Merhaba günlük bugün sürekli tekrlanan işleri döngüler ile yapmayı öğrendik.\",\n", "}\n", "print(gunce.get(31.10.2022))" ] }, { "cell_type": "markdown", "id": "053fea5d", "metadata": {}, "source": [ "# Operatörler (İşleçler)" ] }, { "cell_type": "markdown", "id": "4c550d0c", "metadata": {}, "source": [ "**Operatör (İşleç) :** Bilgisayarda işlemleri yürütüp gerçekleştiren (sonuçlandıran) öğelerdir. Python programlama dilinde:\n", "1. **Atama,**\n", "2. **Aritmetiksel (Matematiksel),**\n", "3. **Karşılaştırma (Kimlik-Üyelik),**\n", "4. **Mantıksal,**\n", "5. **Bit**
\n", "işleçleri bulunmaktadır. İşleçler sembol-simge olabileceği gibi bağlaç ve deyimlerden de oluşur." ] }, { "cell_type": "markdown", "id": "8bf3faeb-2af9-40c2-b0c1-2c4e1998cbe2", "metadata": {}, "source": [ "## Atama Operatörleri\n" ] }, { "cell_type": "markdown", "id": "847fdba9-eff4-49e6-af5b-af72d9f9d70a", "metadata": {}, "source": [ "Programlama dillerinde değişkenlerinin değerlerinin belirlenmesi için kullanılan operatörlerdir." ] }, { "cell_type": "markdown", "id": "e1d91489-4fae-40d2-a4b3-4291f171838b", "metadata": {}, "source": [ "| **OPERATÖR** | **İŞLEVİ** | **AÇIKLAMA** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-|:-:|:-:|\n", "| **=** | **Eşitle** | Değişkene yazılan değeri eşitler. Sağdaki değeri soldaki değişkene atar.| i=2|2|\n", "| **+=** | **Toplayarak Eşitle** | Değişkenin **varolan değerine** eşittirin sağındaki değeri ekleyerek eşitler.| i+=10|12|\n", "| **-=** | **Çıkararak Eşitle** | Değişkenin **varolan değerinden** eşittirin sağındaki değeri çıkararak eşitler.| i-=5|7|\n", "| *= | **Çarparak Eşitle** | Değişkenin **varolan değerini** eşittirin sağındaki değerle çarparak eşitler.| i*=8|56|\n", "| /= | **Bölerek Eşitle** | Değişkenin **varolan değerini** eşittirin sağındaki değere bölerek eşitler.| i/=4|14|\n", "| %= | **Kalana (Mod'a) Eşitle** | Değişkenin **varolan değerini** eşittirin sağındaki değere bölerek kalana eşitler.| i%=8|6|\n", "| //= | **Bölüm'e Eşitle** | Değişkenin **varolan değerini** eşittirin sağındaki değere bölerek bölüme eşitler.| i//=3|2|" ] }, { "cell_type": "markdown", "id": "5c13d3d0-adfb-4ed7-ada0-5f2fcaac09c9", "metadata": {}, "source": [ "Atama operatörleri için örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "f93d9321", "metadata": {}, "outputs": [], "source": [ "i=16\n", "print(i)\n", "i+=4\n", "print(i)\n", "i-=5\n", "print(i)\n", "i*=2\n", "print(i)\n", "i/=3\n", "print(i)\n", "i%=6\n", "print(i)\n", "i//=3\n", "print(i)" ] }, { "cell_type": "markdown", "id": "73373cf0-fc2e-4379-aa2c-1679be91b3d0", "metadata": {}, "source": [ "
Etkinlik: Üç basamaklı en büyük sayıdan iki basamaklı en büyük sayıyı çıkarınız, sonra çıkan sonucu en büyük rakama bölünüz, ardından çıkan sonucu 4 ile çarpınız, elde edilen sonucun yaşınıza bölümünden kalanını bulunuz, çıkan sonuca 5 ekleyiniz. Sonuç kaç?
" ] }, { "cell_type": "code", "execution_count": null, "id": "d84c42e8-5b12-4f73-a8ca-ec93fff07f02", "metadata": {}, "outputs": [], "source": [ "#Etkinliğin Çözümü\n", "enBuyuk3 = 999\n", "enBuyuk2 = 99\n", "enBuyuk1 = 9\n", "yas = int(input(\"Yaşınızı giriniz: \"))\n", "print(((enBuyuk3-enBuyuk2)/enBuyuk1*4)%yas+5)" ] }, { "cell_type": "markdown", "id": "d7e5dddd", "metadata": {}, "source": [ "## Aritmetiksel (Matematiksel) Operatörler" ] }, { "cell_type": "markdown", "id": "497d4efe-254b-4753-8575-21082b748c18", "metadata": {}, "source": [ "Programlama dillerinde aritmetik (matematiksel) işlemlerinin yapılabilmesi için kullanılan operatörlerdir." ] }, { "cell_type": "markdown", "id": "068d37f0", "metadata": {}, "source": [ "| **OPERATÖR** | **İŞLEVİ** | **AÇIKLAMA** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-|:-:|:-:|\n", "| **+** | **Toplama** | Sayısal değişkenleri (integer, float vd.) matematiksel olarak toplar, sayısal olmayanları (string, list vd.) birleşitirir.| 3+5
\"3\"+\"5\"|8
'35'|\n", "| **-** | **Çıkarma** | Sayısal değişkenleri (integer, float vd.) matematiksel olarak çıkarır, sayısal olmayanlarda (string, list vd.) **hata verir**.| 2023-1923|100|\n", "| * | **Çarpma** | Sayısal değişkenleri (integer, float vd.) matematiksel olarak çarpar, sayısal olmayanlarda (string, list vd.) değişkeni kere yazdırır.| $$10*5$$
$$\"C\"*3$$| 50

'CCC'|\n", "| / | **Bölme** | Sayısal değişkenleri (integer, float vd.) matematiksel olarak böler, bölme işleminin sonucu her zaman 'float' tipidir.| 8/4|2.0|\n", "| // | **Bölüm** | Sayısal değişkenleri (integer, float vd.) matematiksel olarak böler ve bölüm kısmını verir. İşleminin sonucu her zaman işleme sokulan veri tipidir.| 13//5
13.5//5|2
2.0|\n", "| % | **Kalan** | Diğer adı mod almadır. Sayısal değişkenleri (integer, float vd.) matematiksel olarak böler ve kalan kısmını verir. İşleminin sonucu her zaman işleme sokulan veri tipidir.| 13%5|3|\n", "| ** | **Üssü** | Sayısal değişkenleri (integer, float vd.) matematiksel olarak kuvvetini verir. İşleminin sonucu her zaman işleme sokulan veri tipidir.| 5**3|125|" ] }, { "cell_type": "markdown", "id": "7837feb5", "metadata": {}, "source": [ "Aritmetiksel operatörler için örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "2aac5d7d", "metadata": {}, "outputs": [], "source": [ "toplam = 16+5\n", "birlestirme = \"16\"+\"5\" #string olan verileri '+' işleci ile kullanırsak stringleri yanyana birleştirir.\n", "fark = 16-5\n", "carpim = 16*5\n", "cogaltma = \"16\"*5 #string olan verileri integerler ile çarparsak string'i integer kadar yazmış oluruz.\n", "bolme = 16/5\n", "bolum = 16//5\n", "kalan = 16%5\n", "karesi = 16**2\n", "\n", "print (\"Toplam:{}\\nBirleştirme:{}\\nFark:{}\\nÇarpım: {}\\nBölme: {}\\nBölüm: {}\\nKalan: {}\\nKaresi; {}\\nÇoğaltılmış String: {}\"\n", " .format(toplam,birlestirme,fark,carpim,bolme,bolum,kalan,karesi,cogaltma))" ] }, { "cell_type": "markdown", "id": "95fea7cf", "metadata": {}, "source": [ "### Aritmetiksel Bazı Fonksiyonlar\n", "#### Gömülü Fonksiyonlar\n", "**(Kütüphane eklemeye gerek kalmadan kullanılabilecekler)**" ] }, { "cell_type": "markdown", "id": "70db288d-0e01-4502-93f3-b585722170e5", "metadata": {}, "source": [ "- Verilen bir sayı dizisinin (integer tipi) toplamı `sum()` fonskiyonu ile alınır. Örnek: sum(1,3,5,7,12)\n", "- Bir sayı kümesindeki en büyük değeri bulmak için `max()` fonskiyonu kullanılır.\n", "- Bir sayı kümesindeki en küçük değeri bulmak için `min()` fonskiyonu kullanılır.\n", "- Bir sayının mutlak değeri (pozitif değeri) `abs()` fonskiyonu ile alınır.\n", "- Bir sayının hem bölümünü hem de kalanını aynı anda bulmak için `divmod()` fonskiyonu kullanılır. Örnek: divmod(10,3) yazarsak (3,1) olarak sonuç çıkar.\n", "- Bir sayıyı yuvarlamak için `round()` fonskiyonu kullanılır. Ondalık kısmı 5 ve 5'ten yukarı ise yukarı değilse aşağı yuvarlar.\n", "- Bir sayının üssünü almak için `pow()` fonskiyonu kullanılır. Örnek: pow(5,2)\n", "- Bir aralıktaki sayıları ele almak için `range()` fonskiyonu kullanılır. Örnek: range(-10,10)\n", "- Bir sayının 2'li sayı sistemindeki değerini bulmak için `bin()` fonskiyonu kullanılır.\n", "- Bir sayının 8'li sayı sistemindeki değerini bulmak için `oct()` fonskiyonu kullanılır.\n", "- Bir sayının 16'lı sayı sistemindeki değerini bulmak için `hex()` fonskiyonu kullanılır." ] }, { "cell_type": "markdown", "id": "7247cf28", "metadata": {}, "source": [ "
Etkinlik: Dünyanın en hızlı roketi ile dünyanın ekvator çevresinde bir tam turu toplam kaç dakikada tamamlanır? Roket hızını internetten araştırınız(Pi=3.14, Dünyanın ekvatoral yarıçapı: 6378 km)
" ] }, { "cell_type": "code", "execution_count": null, "id": "5bf73f58", "metadata": {}, "outputs": [], "source": [ "#Roket Etkinliğinin Çözümü\n", "rokethizi = 532000\n", "ekvator = 6378\n", "pi = 3.14\n", "\n", "cevre = 2*pi*ekvator\n", "esure = 60*cevre/rokethizi #dakikaya çevirmek için ile çarptım.\n", "print (\"Dünyanın ekvator hizasındaki çevresini\",esure,\"dakikada tamamlar.\")\n", "\n", "#Roket Etkinliğinin Şık Çözümü\n", "h,r,p = 532000,6378,3.14\n", "print (\"Dünyanın ekvator hizasındaki çevresini\",round(60*2*p*r/h,2),\"dakikada tamamlar.\")" ] }, { "cell_type": "markdown", "id": "5a94c2b3", "metadata": {}, "source": [ "
Etkinlik: Babanızın yaşından annenizin yaşını çıkardıktan sonra kendi yaşınızı ekleyiniz ve evde yaşayan kişi sayısıyla çarpınız. Çıkan sayıyı kendi yaşınıza bölününce kalanın karesini alınız. Sonuç kaç?
" ] }, { "cell_type": "code", "execution_count": null, "id": "30e8a228-bf69-490d-b1e8-d8653a195280", "metadata": {}, "outputs": [], "source": [ "#Etkinliğin Çözümü\n", "baba = int(input(\"Babanızın yaşını giriniz: \"))\n", "anne = int(input(\"Annenizin yaşını giriniz: \"))\n", "kendim = int(input(\"Kendi yaşınızı giriniz: \"))\n", "mevcut = int(input(\"Evde toplam kaç kişi yaşıyor: \"))\n", "print(((baba-anne+kendim)*mevcut)%kendim**2)" ] }, { "cell_type": "markdown", "id": "1a3d3bc3-52e1-4a01-b00c-768199b760d7", "metadata": {}, "source": [ "#### Math Kütüphanesi ile Gelen Fonksiyonlar" ] }, { "cell_type": "markdown", "id": "8984702c-f848-4814-abe3-5822ce529893", "metadata": {}, "source": [ "Gömülü olarak kullanamadığımız matematiksel fonksiyonları barındırır. `import math` veya `from math import *` olarak aktarılabilir." ] }, { "cell_type": "markdown", "id": "465cf11e-094b-4f83-bd43-d8e9b85f7a94", "metadata": {}, "source": [ "- Bir sayıyı aşağı yuvarlamak için `math.ceil()` fonskiyonu kullanılır.\n", "- Bir sayıyı yukarı yuvarlamak için `math.floor()` fonskiyonu kullanılır.\n", "- Bir sayının işaretini (+,-) başka bir sayıya aktarmak için `math.copysign()` fonskiyonu kullanılır. Örneğin math.copysign(5,-12) yazarsak sonuç -5 olur.\n", "- Bir sayının float olarak mutlak değeri `math.fabs()` fonskiyonu ile alınır.\n", "- Bir sayının faktöriyelini bulmak için `math.factorial()` fonskiyonu kullanılır.\n", "- Bir sayının başka bir sayıya bölümünden kalanı flolat olarak bulmak için `math.fmod()` fonskiyonu kullanılır. Özellikle negatif sayılarda doğru sonuç verir.\n", "- Flolat tipindeki sayıların toplamını bulmak için `math.fsum()` fonskiyonu kullanılır.\n", "- Verilen sayıların EBOB'unu bulmak için `math.gcd()` fonskiyonu kullanılır. Örnek: math.gcd(sayi1,sayi2,sayi3)\n", "- Pi sayısını kullanmak için `math.pi()` fonskiyonu kullanılır.\n", "- Bir karekökünü bulmak için `math.sqrt()` fonskiyonu kullanılır." ] }, { "cell_type": "markdown", "id": "31994fb1-9e65-4d76-8fda-16b65ffd078e", "metadata": {}, "source": [ "
Etkinlik: Kendi yaşınızı float olarak hesaplayıp (örn: (2022-2004)+5/12) yaşınızı aşağı ve yukarı yuvarlayınız.
" ] }, { "cell_type": "markdown", "id": "6ccf1ac2-815f-428e-aed0-4e00b8d3e49a", "metadata": {}, "source": [ "
Etkinlik: Evinizde yaşayanların yaşlarını float olarak hesaplayıp (örn: (2022-2004)+5/12) yaşları toplayınız.
" ] }, { "cell_type": "markdown", "id": "b1cb23ab-fabc-4e74-8935-9bc53f4046bb", "metadata": {}, "source": [ "
Etkinlik: 7 sayısının faktöriyeli ile 4 sayısının faktöriyelinin EBOB'unu bulunuz.
" ] }, { "cell_type": "markdown", "id": "36800f3a-be43-4524-a12f-22b645d2812a", "metadata": {}, "source": [ "
Etkinlik: Bir çemberin çevresi 2*Pi sayısı*Çemberin Yarıçapıdır. Buna göre yarıçapı 19.23 olan çemberin çevresini hesaplayınız.
" ] }, { "cell_type": "markdown", "id": "f5b58329-4131-4201-b232-63cbc5343ba7", "metadata": {}, "source": [ "
Etkinlik: Cumhuriyetimizin yaşının karekökünü bulunuz.
" ] }, { "cell_type": "markdown", "id": "7b344933-bc4d-436a-8f67-805a050b809c", "metadata": {}, "source": [ "#### Random Kütüphanesi ile Gelen Fonksiyonlar" ] }, { "cell_type": "markdown", "id": "8596d79e-4a11-460e-b522-f420640e33b8", "metadata": {}, "source": [ "Rassalık (rasgele) işlemlerini yapmamızı sağlayan fonksiyonları barındırır. `import random` veya `from random import *` olarak aktarılabilir." ] }, { "cell_type": "markdown", "id": "756c806e-307a-4c63-aa9f-a32e59b9e249", "metadata": {}, "source": [ "- 0 ile 1 arasında rasgele bir sayı (float) üretmek için `random.random()` fonskiyonu kullanılır.\n", "- Bir aralıkta rasgele bir sayı (float) üretmek için `random.uniform()` fonskiyonu kullanılır. Örnek: random.uniform(1,20)\n", "- Bir aralıkta rasgele integer bir sayı üretmek için `random.randint()` fonskiyonu kullanılır. Örneğin random.randint(1,100) ile 1 ile 100 sayıları arasında rasgele bir sayı üretilir.\n", "- Bir aralıkta rasgele integer bir sayı üretmek için `random.randrange()` fonskiyonu kullanılır. randint()'ten farkı, aralıkta belirli bir artış vererek rassal sayı ihtimalini biçimlendiririz. Örneğin random.randrange(0,100,5) ile 0 ile 100 sayıları arasında 0'dan başlayarak 5'er 5'er artan sayılardan rasgele bir sayı üretilir.\n", "- Bir listedeki elemanları rasgele karıştırmak için `random.shuffle()` fonskiyonu kullanılır. Örnek random.shuffle(liste_adi)\n", "- Bir listedeki elemanlardan rasgele birini seçmek için `random.choice()` fonskiyonu kullanılır. Örnek random.choice(liste_adi)\n", "- Bir listedeki elemanlardan rasgele birkaçını seçmek için `random.sample()` fonskiyonu kullanılır. Örnek random.choice(liste_adi,secilecek_eleman_sayisi)" ] }, { "cell_type": "markdown", "id": "081c1fb7-455c-4bde-a5a3-812893ba59b6", "metadata": {}, "source": [ "
Etkinlik: Art arda 5 tane 1 ile 20 arasında rassal tam sayı oluşturunuz.
" ] }, { "cell_type": "markdown", "id": "6ecde0bb-e8fb-48dc-8d7d-85decafb9f34", "metadata": {}, "source": [ "
Etkinlik: 1 ile 50 arasında sadece çift sayılardan rassal tam sayı oluşturunuz.
" ] }, { "cell_type": "markdown", "id": "71e1dbf4-070c-4cd0-aa99-3941801d5da9", "metadata": {}, "source": [ "
Etkinlik: 0 ile 100 arasında sadece 13'ün katlarından rassal tam sayı oluşturunuz.
" ] }, { "cell_type": "markdown", "id": "4a5deb77-344f-4da9-8b38-04ea40d1ab30", "metadata": {}, "source": [ "
Etkinlik: Rasgele float oluşturduğunuz negatif bir sayıdan o sayının tam kısmını çıkararak -1'den büyük 0'dan küçük bir rasgele sayı oluşturunuz.
" ] }, { "cell_type": "markdown", "id": "ae0b3261-885c-4daa-91e3-c0ed9695e41f", "metadata": {}, "source": [ "
Etkinlik: Taş kağıt makas oyunu için oluşturulan liste tipi değişkenden makinenin seçimini rassal bir şekilde ekrana yazdırınız.
" ] }, { "cell_type": "markdown", "id": "cfca7d84-f2af-4586-9d0c-f84e97b8fb9b", "metadata": {}, "source": [ "#### Statistics Kütüphanesi ile Gelen Fonksiyonlar" ] }, { "cell_type": "markdown", "id": "df8d1bff-b99b-4523-a948-af6fdf041631", "metadata": {}, "source": [ "Matematikteki temel istatistiksel işlemleri (aritmetik ortalama, mod medyan vb.) içeren fonksiyonları barındırır. `import statistics` veya `from statistics import *` olarak aktarılabilir." ] }, { "cell_type": "markdown", "id": "66ba40db-c434-4cc3-a02e-1d8e3c7f8ac2", "metadata": {}, "source": [ "- Verilen sayı dizisinin ortalamasını bulmak için `statistics.mean()` fonskiyonu kullanılır.\n", "- Verilen sayı dizisinin ağırlıklandırılmış ortalamasını bulmak için `statistics.fmean()` fonskiyonu kullanılır. Örnek: statistics.fmean(sayilar,agirlıiklar)\n", "- Verilen sayı dizisinin geometrik ortalamasını bulmak için `statistics.geometric_mean()` fonskiyonu kullanılır.\n", "- Verilen sayı dizisinin harmonik ortalamasını bulmak için `statistics.harmonic_mean()()` fonskiyonu kullanılır.\n", "- Verilen sayı dizisinin modunu bulmak için `statistics.mode()` fonskiyonu kullanılır.\n", "- Verilen sayı dizisinin medyanını bulmak için `statistics.median()` fonskiyonu kullanılır.\n", "- Verilen sayı dizisinin küçük medyanını bulmak için `statistics.median_low()` fonskiyonu kullanılır.\n", "- Verilen sayı dizisinin büyük medyanını bulmak için `statistics.median_high()` fonskiyonu kullanılır.\n", "- Verilen sayı dizisinin gruplandırılmış örneklemde medyanı bulmak için `statistics.median_grouped()` fonskiyonu kullanılır.\n", "- Verilerin standart sapmasını bulmak için `statistics.stdev()` fonskiyonu kullanılır. Eğer popülasyon için hesaplanacaksa `statistics.pstdev()` kullanılır.\n", "- Verilerin varyansını bulmak için `statistics.variance()` fonskiyonu kullanılır. Eğer popülasyon için hesaplanacaksa `statistics.pvariance()` kullanılır.\n", "- İki değişken arasındaki kovaryansı bulmak için `statistics.covariance()` fonskiyonu kullanılır.\n", "- İki değişken arasındaki ilişkiyi bulmak için `statistics.correlation()` fonskiyonu kullanılır.\n", "- Bir değişkene göre başka bir değişkeni tahmin etmek için `statistics.linear_regression()` fonskiyonu kullanılır." ] }, { "cell_type": "markdown", "id": "92fb3133-a2b9-4915-a998-6f675770bdf1", "metadata": {}, "source": [ "
Etkinlik: Bir market müşterilerinin TC No ve alışveriş tutarlarını sözlük tipinde bir değişkenle tutmaktadır. Market 250 TL ve üzeri alışveriş yapan müşterilerinden rasgele 3'üne 500TL'lik hediye çeki verecektir. Bu akışı gerçekleştiren kodları yazınız.
" ] }, { "cell_type": "markdown", "id": "9ba3bf82", "metadata": {}, "source": [ "## Karşılaştırma Operatörleri" ] }, { "cell_type": "markdown", "id": "620ea27c-5b4b-4453-9357-abdbf13f86de", "metadata": {}, "source": [ "Programlama dillerinde değişkenleri&değerleri karşılaştırarak Doğru (True) veya Yanlış (False) bulma operatörüdür. Karşılaştırma işleçlerinden True veya False (boolean değer) haricinde bir çıktı olmaz." ] }, { "cell_type": "markdown", "id": "3b55012d", "metadata": {}, "source": [ "| **OPERATÖR** | **İŞLEVİ** | **AÇIKLAMA** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-|:-:|:-:|\n", "| **==** | **Eşit mi?** | Eşittirlerin sağındaki ve solundaki değerleri karşılaştırır. Eşitse True, değilse False değeri verir.| \"TR\"==\"TR\"
3==5|True
False|\n", "| **!=** | **Farklı mı?** | Eşittirlerin sağındaki ve solundaki değerleri karşılaştırır. Farklıysa True, değilse False değeri verir.| \"TR\"!=\"TR\"
3!=5|False
True|\n", "| **<** | **Küçük mü?** | Eşittirlerin sağındaki ve solundaki değerleri karşılaştırır. Soldaki sağdakinden küçükse True, değilse False değeri verir. Sadece sayısal değerler için kullanılır.| 3<5
5<3|True
False|\n", "| **<=** | **Küçük veya Eşit mi?** | Eşittirlerin sağındaki ve solundaki değerleri karşılaştırır. Soldaki sağdakinden küçük veya eşitse True, değilse False değeri verir.| 5<=5
5<=3|True
False|\n", "| **>** | **Büyük mü?** | Eşittirlerin sağındaki ve solundaki değerleri karşılaştırır. Soldaki sağdakinden büyükse True, değilse False değeri verir. Sadece sayısal değerler için kullanılır.| 3>5
5>3|False
True|\n", "| **>=** | **Büyük veya Eşit mi?** | Eşittirlerin sağındaki ve solundaki değerleri karşılaştırır. Soldaki sağdakinden büyük veya eşitse True, değilse False değeri verir.| 5>=5
5>=7|True
False|" ] }, { "cell_type": "markdown", "id": "e317bb7f", "metadata": {}, "source": [ "Karşılaştırma operatörleri için örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "b691655b", "metadata": {}, "outputs": [], "source": [ "sonuc = 3==5\n", "print(sonuc)\n", "sonuc = 3!=5\n", "print(sonuc)\n", "sonuc = \"TÜRKİYE\"==\"TR\"\n", "print(sonuc)\n", "sonuc = \"TÜRKİYE\"!=\"TR\"\n", "print(sonuc)\n", "print(\"------\")\n", "sonuc = 3<5\n", "print(sonuc)\n", "sonuc = 3>5\n", "print(sonuc)\n", "sonuc = 3<=5\n", "print(sonuc)\n", "sonuc = 3>=5\n", "print(sonuc)" ] }, { "cell_type": "markdown", "id": "08d22805", "metadata": {}, "source": [ "
Etkinlik: Türkiye'nin yıllık ekonomik büyüme oranı ile Dünya ekonomisinin ortalama büyümesi ile karşılaştırınız. Tüm karşılaştırma operatörleri ile deneyip ekrana önerme olarak yazdırınız.
" ] }, { "cell_type": "markdown", "id": "c2cdb2f4", "metadata": {}, "source": [ "### Kimlik ve Üyelik Türü Karşılaştırmalar" ] }, { "cell_type": "markdown", "id": "ea5ec01b-a397-4bc2-bd45-06e6284bdffd", "metadata": {}, "source": [ "Değişkenlerin veya değerlerinin 'ne' olduğu veya 'ne' içerdiği ile ilgili karşılaştırmalardır." ] }, { "cell_type": "markdown", "id": "25a2be3f", "metadata": {}, "source": [ "| **KARŞILAŞTIRMA** | **TİP** | **AÇIKLAMA** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-|:-:|:-:|\n", "| **is** | **Kimlik** | İki değişkenin veya nesnenin aynı olması durumunda TRUE değeri verir. Değilse False.| a is a|True|\n", "| **is not** | **Kimlik** | İki değişkenin veya nesnenin farklı olması durumunda TRUE değeri verir. Değilse False.| a is not a|False|\n", "| **in** | **Üyelik** | Solundaki değişken veya nesne, sağındaki değişkenin veya nesnenin içinde var ise TRUE değeri verir. Değilse False.| \"Türkiye\" in \"i\"|True|\n", "| **not in** | **Üyelik** | Solundaki değişken veya nesne, sağındaki değişkenin veya nesnenin içinde yok ise TRUE değeri verir. Değilse False.| \"Türkiye\" not in \"i\"|False|" ] }, { "cell_type": "markdown", "id": "51b3673a", "metadata": {}, "source": [ "Kimlik ve üyelik türü karşılaştırmalara örnekler verelim." ] }, { "cell_type": "code", "execution_count": null, "id": "04d22b9f", "metadata": {}, "outputs": [], "source": [ "s1 = \"İSTİKLAL HARBİ\"\n", "s2 = \"KURTULUŞ SAVAŞI\"\n", "q = \"U\"\n", "print(s1 is s2, s1 is not s2, s1 in q, s2 not in q)" ] }, { "cell_type": "markdown", "id": "0a7656c4", "metadata": {}, "source": [ "
Etkinlik: Kullanıcıdan aldığınız verinin her karakterini Türk alfabesi ile karşılaştırınız ve Türk alfabesinde olmayan değerleri ekrana yazdırınız.
" ] }, { "cell_type": "markdown", "id": "33a61ebc", "metadata": {}, "source": [ "### String Değişken Tipine Ait Bazı Karşılaştırma Metotları" ] }, { "cell_type": "markdown", "id": "45ae8909", "metadata": {}, "source": [ "| **KARŞILAŞTIRMA** | **TİP** | **AÇIKLAMA** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-|:-:|:-:|\n", "| **endswith()** | **string** | Değişken belirli bir değer ile bitiyorsa TRUE değeri verir. Değilse False.| \"TR\".endswith(\"R\")|False|\n", "| **startswith()** | **string** | Değişken belirli bir değer ile başlıyorsa TRUE değeri verir. Değilse False.| \"TR\".startswith(\"T\")|True|\n", "| **isalnum()** | **string** | Değişken tamamen harf veya rakamlardan oluşuyorsa TRUE değeri verir. Değilse False.| \"TR1923\".isalnum()|True|\n", "| **isalpha()** | **string** | Değişken tamamen harflerden oluşuyorsa TRUE değeri verir. Değilse False.| \"TR1923\".isalpha()|False|\n", "| **isnumeric()** | **string** | Değişken tamamen rakamlardan (float veya integer) oluşuyorsa TRUE değeri verir. Değilse False.| \"1920\".isnumeric()|True|\n", "| **isdecimal()** | **string** | Değişken tamamen ondalık sayılardan oluşuyorsa TRUE değeri verir. Değilse False.| \"19.23\".isdecimal()|True|\n", "| **isdigit()** | **string** | Değişken tamamen rakamlardan oluşuyorsa TRUE değeri verir. Değilse False.| \"1923\".isdigit()|True|\n", "| **islower()** | **string** | Değişkendeki tüm harfler küçükse TRUE değeri verir. Değilse False.| \"TR\".islower()|False|\n", "| **isupper()** | **string** | Değişkendeki tüm harfler büyükse TRUE değeri verir. Değilse False.| \"TR\".isupper()|True|\n", "| **istitle()** | **string** | Değişkendeki tüm harfler büyük harfle başlıyor ve diğerleri küçükse TRUE değeri verir. Değilse False.| \"TR\".istitle()|False|\n", "| **isspace()** | **string** | Değişken tamamen boşluklardan oluşuyorsa TRUE değeri verir. Değilse False.| \"TR\".isspace()|False|" ] }, { "cell_type": "code", "execution_count": null, "id": "fbd47c6e", "metadata": {}, "outputs": [], "source": [ "print(\"TÜRKİYE\".endswith(\"E\"))\n", "print(\"TÜRKİYE\".startswith(\"X\"))\n", "print(\"TÜRKİYE1923\".isalnum())\n", "print(\"TÜRKİYE\".isalpha())\n", "print(\"1923\".isnumeric())\n", "print(\"19.23\".isdecimal())\n", "print(\"1923\".isdigit())\n", "print(\"TÜRKİYE\".islower())\n", "print(\"TÜRKİYE\".isupper())\n", "print(\"Türkiye\".istitle())\n", "print(\" \".isspace())" ] }, { "cell_type": "markdown", "id": "75d3c191", "metadata": {}, "source": [ "
Etkinlik: Kullanıcıdan aldığınız verinin her karakterini Türk alfabesi ile karşılaştırınız ve Türk alfabesinde olmayan değerleri ekrana yazdırınız. Değerleri ekrana yazdırırken harf ve nümerikleri ayrı liste olarak yazdırınız.
" ] }, { "cell_type": "markdown", "id": "c8bc5ff7", "metadata": {}, "source": [ "## Mantıksal Operatörler" ] }, { "cell_type": "markdown", "id": "7e44984d-756e-41b7-8910-efe2bab14520", "metadata": {}, "source": [ "Birden fazla karşılaştırma işleci kullanılacağı zaman karşılaştırmaların birlikte test edilmesini sağlayan operatörlerdir. \"VE(and) (bütün durumlar birlikte doğruysa)\", \"VEYA(or) (bütün durumlardan en az biri doğruysa)\" ve \"DEĞİL(not) (durumun tersi)\" olarak 3 tanedir. Sonuçları her zaman True veya False olur." ] }, { "cell_type": "markdown", "id": "880926b6", "metadata": {}, "source": [ "| **OPERATÖR** | **İŞLEVİ** | **AÇIKLAMA** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-|:-:|:-:|\n", "| **and** | **VE** | Koşulların birlikte doğru olmasını test eder. Hepsi doğru ise True değeri verir. Herhangi birinin yanlış olması False değerini verir. | \"TR\"==\"TR\" and \"TR\"!=\"TC\"|True|\n", "| **or** | **VEYA** | Koşulların herhangi birinin doğru olmasını test eder. Herhangi biri doğru ise True değeri verir. Hiçbiri doğru değilse False değerini verir. | \"TR\"==\"TR\" or \"TR\"!=\"TC\"|True|\n", "| **not** | **DEĞİL** | Koşulun tersini test eder. Tersi doğru ise True değeri verir. Yanlış ise False değerini verir. | \"TR\"==\"TR\" or \"TR\"!=\"TC\"|True|" ] }, { "cell_type": "code", "execution_count": null, "id": "b9d59fb8", "metadata": {}, "outputs": [], "source": [ "i = 1923\n", "s = \"TR\"\n", "l = [\"T\",\"Ü\",\"R\",\"K\",\"İ\",\"Y\",\"E\",1923]\n", "print (i==1923 and s==\"TR\")\n", "print (i==19 and s==\"TR\")\n", "print (i==19 or s==\"TR\")\n", "print (not i==19 or not s==\"TR\")\n", "print (not i==1923 and not s==\"TR\")\n", "print (not i==1923 or not s==\"TR\")\n", "print (s in l and i in l)\n", "print (s in l or i in l)" ] }, { "cell_type": "markdown", "id": "53c70839", "metadata": {}, "source": [ "
Etkinlik: Türk alfabesi ve İngiliz alfabesi olarak iki ayrı liste oluşturunuz. Sonra kullancıdan harf verisi alınız. Kullanıcının yazdığı harfin iki alfabede de arayıp sonucu ekrana yazan algoritmayı yazınız.
" ] }, { "cell_type": "markdown", "id": "4cd6ea18", "metadata": {}, "source": [ "## Bit Operatörler Sadece integer tip için kullanılabilir!" ] }, { "cell_type": "markdown", "id": "7d7779ec-a0c4-4ca1-a159-d98f12c5d458", "metadata": {}, "source": [ "Bilgisayarlar, her türlü bilgiyi bit adı verilen ikili rakamlar akışı olarak depolar. Bu bitler arasında karşılaştırmalar bitsel operatörler ile yapılır. Devre kartları gibi fiziksel cihazları kontrol etmede, sıkıştırma, şifreleme ve hata algılama gibi algoritmaları uygulamak için bitsel operatörleri kullanılır. Mantıksal operatörler gibidir." ] }, { "cell_type": "markdown", "id": "88bdfa1a", "metadata": {}, "source": [ "| **OPERATÖR** | **İŞLEVİ** | **AÇIKLAMA** | **ÖRNEK** | **ÇIKTI** |\n", "|:-:|:-:|:-|:-:|:-:|\n", "| & | and | Karşılıklı bitleri kontrol ederek ikisi de 1 olanları açar, diğerlerini kapatır. | 10 & 10
10 & 5| 10
0 |\n", "| I | or | Karşılıklı bitleri kontrol ederek herhangi biri 1 olanları açar, diğerlerini kapatır. | 10 l 10
10 I 5| 10
15 |\n", "| ^ | xor | Karşılıklı bitleri kontrol ederek karışılıklı 0-0, 1-0 veya 0-1 olanları açar, diğerlerini kapatır. | 10 ^ 10
10 ^ 5| 0
15 |\n", "| ~ | not | Karşılıklı bitleri kontrol ederek tersine çevirir. | ~10
~5| -11
-6 |" ] }, { "cell_type": "code", "execution_count": null, "id": "b17f145d", "metadata": {}, "outputs": [], "source": [ "a = 10\n", "b = 5\n", "c=10\n", "print(a&b)\n", "print(a&c)\n", "print(a|b)\n", "print(a|c)\n", "print(a^b)\n", "print(a^c)\n", "print(~b)" ] }, { "cell_type": "markdown", "id": "916b0274", "metadata": {}, "source": [ "Bitsel operatörlerin çalışma mantığı (Zaczyński, 2020):
\n", "\n", "\n", "\n", "" ] }, { "cell_type": "markdown", "id": "56a1052e", "metadata": {}, "source": [ "# Python Kütüphaneleri (Modüller)" ] }, { "cell_type": "markdown", "id": "0a2fea82", "metadata": {}, "source": [ "Python'da standart olan (gömülü olan) modüller ile print(), input(), len() gibi fonksiyonları kullanmaktayız.
\n", "Bunların haricinde python ile birlikte gelen ama gömülü olmayan yani kodlama esnasında içeri aktarmamız (import) gereken kütüphaneler de var. Bunlar 'math', 'random', 'time', 'os' 'turtle', 'tkinter' vb. kütüphanelerdir. Tam listesi için buraya bakınız. Bunlar haricinde kullanılabilecek kütüphaneler için https://pypi.org/ sitesinden tarama yapabilirsiniz. Buradaki komutları sisteminizdeki komut isteminden çalıştırarak kütüphaneleri indirebilirsiniz. Şu an bu kısımda 'bazı' kütüphaneleri ele alacağız. Fakat konu ilerledikçe ilgili yeni kütüphaneleri de ele alacağız.
\n", "**Kütüphaneler 3 farklı şekilde import edilebilir.**
\n", "1. `from kütüphane_adi import fonksiyon_adi` şeklinde\n", "2. `import kütüphane_adi` şeklinde\n", "**3. `import kütüphane_adi as takma_ad` şeklinde

\n", "\n", "- **Birinci şekildeki** gibi aktarırsak **ilgili kütüphanenin sadece adı belirtilen fonksiyonunu** doğrudan bir python fonksiyonu gibi başına **kütüphane önekini getirmeden kullanırız.** Örneğin `from a import b` yazarsak a kütüphanesinin b fonksiyonunu kodlarımızda `b()` olarak kullanırız. Bu kullanım ile başka bir kütüphaneden aktarılan başka bir fonksiyon ile isimlerinin çakışmayacağından emin olamayız. Bu sebeple pek tercih edilmemelidir.
\n", "- **İkinci şekildeki** gibi aktarırsak **ilgili kütüphanenin tüm fonksiyonları** gelir. Bu şekilde aktarılan kütüphane fonksiyonlarının başına kütüphane adı önek olarak getirilebilir. Örneğin `import a` yazarsak a kütüphanesinin b fonksiyonunu `a.b()` olarak kullanabiliriz. Bu durumda başka kütüphanelerle isim karışıklığının önüne geçilmiş olur.
\n", "- **Üçüncü şekildeki** gibi aktarırsak ikinci şekildeki gibi kütüphane adını önek olarak kullanırız fakat bu önek direkt kütüphane adı değil `as` deyiminden sonra bizim yazdığımız isim olur. Bu şekilde adı uzun olan kütüphanelerin adını kıslatarak kullanabiliriz. Örneğin `import statistics as st` yazarsak statistics kütüphanesinin mean fonksiyonunu `st.mean()` olarak yazabiliriz.
\n", "Aşağıda kütüphaneleri aktarılma yöntemleriyle örneklendirelim." ] }, { "cell_type": "markdown", "id": "d61a658e", "metadata": {}, "source": [ "## Time ve Datetime Kütüphanesi" ] }, { "cell_type": "markdown", "id": "ca5d9033-fc3f-455e-9ad3-b59ed53d393e", "metadata": {}, "source": [ "Süre (Saat, Saniye), Tarih (Gün, Ay, Yıl) vb. elemanlarla işlemler yapmamızı sağlayan fonksiyonları barındırır.
\n", "`import time` veya `from time import *` ile import datetime veya from datetime import * olarak aktarılabilir.
\n", "Python için zamanın başlangıç noktası (epoch: belirli, kesin tarih) 1 Ocak 1970 olarak belirlenmiştir." ] }, { "cell_type": "markdown", "id": "791b9f4d-4ac3-49dd-9e1c-23c4c2609ced", "metadata": {}, "source": [ "### Time Kütüphanesi ile Gelen Bazı Fonskiyonlar" ] }, { "cell_type": "markdown", "id": "fedd7baa-0053-4553-9983-ea085857e1e4", "metadata": {}, "source": [ "- 1 Ocak 1970 tarihinden itibaren geçen süre float tipinde saniye olarak `time.time()` fonskiyonu ile alınır.\n", "- `time.gmtime()` fonksiyonu ile float tipinde saniye olarak verilen süreyi 1 Ocak 1970 tarihine ekler ve yıl, ay, gün, saat, dakika, saniye, haftanın günü, yılın günü ve dts olarak 9 farklı değerde çıktı verir. Boş bırakılırsa kodun çalıştığı andaki zamana göre hesap eder. Saat dilimi (GMT) 0 olarak hesaplanır.\n", "- `time.localtime()` fonksiyonu ile sistemdeki saat-tarih bilgileri yıl, ay, gün, saat, saniye vb. olarak çıktı alınır.\n", "- `time.asctime()` fonksiyonu ile \"Haftanın Günü, Ay, Gün Sayısı, Saat:Dakika:Saniye, Yıl\" olarak çıktı alınır. Parametre olarak sadece `gm.time()` fonksiyonunun çıktısına uygun bir girdi alır. Boş bırakılırsa çalıştığı andaki zaman-tarih alınır.\n", "- `time.ctime()` fonksiyonu ile \"Haftanın Günü, Ay, Gün Sayısı, Saat:Dakika:Saniye, Yıl\" olarak çıktı alınır. Parametre olarak **saniye cinsinden float/integer değer girilir.** Boş bırakılırsa çalıştığı andaki zaman-tarih alınır.\n", "- `time.sleep()` fonksiyonu ile \"bekle\" blokları gibi kodların çalışmasını istediğimiz sürede durdururuz. Örnek: time.sleep(2) 'devamındaki kodu çalıştırmadan önce 2 saniye bekler.\n", "- `time.strftime()` fonksiyonu ile asctime() fonksiyonuna ait bilgileri parçalayarak elde edebiliriz. Örneğin: print(time.strftime(%A)) ile haftanın tam gün adını (Sunday, Monday vb.) alırız. Bu fonksiyonun parametreleri:\n", " - `time.strftime(%a)` Hafta Günü Kısaltılmış\n", " - `time.strftime(%A)` Hafta Gün Tam Adı\n", " - `time.strftime(%b)` Ayın Kısaltılmış Adı\n", " - `time.strftime(%B)` Ayın Tam Adı\n", " - `time.strftime(%c)` Tam Tarih, Saat Ve Zaman Bilgisi\n", " - `time.strftime(%d)` Sayısal Olarak Gün\n", " - `time.strftime(%j)` Yılın Kaçıncı Günü Olduğu\n", " - `time.strftime(%m)` Sayısal Olarak Ay\n", " - `time.strftime(%U)` Kaçıncı Hafta Olduğu\n", " - `time.strftime(%y)` Yılın Son İki Rakamı\n", " - `time.strftime(%Y)` Yılın Dört Haneli Tam Hali\n", " - `time.strftime(%x)` Tam Tarih Bilgisi\n", " - `time.strftime(%X)` Tam Saat Bilgisi" ] }, { "cell_type": "markdown", "id": "30f7b9bf-6db2-4a6f-a052-1a9ac61f2f27", "metadata": {}, "source": [ "### Datetime Kütüphanesi ile Gelen Bazı Fonskiyonlar" ] }, { "cell_type": "markdown", "id": "bb7984a3-77e2-4b76-8506-395d9d5f252b", "metadata": {}, "source": [ "- `datetime.date(yyyy,aa,gg)` fonskiyonu ile girilen değerler ISO formatında tarihi elde edilir. Sistemdeki günü almak için `datetime.date.today()` metodu da vardır.\n", "- `datetime.time(saat,dakika,saniye,milisaniye)` fonksiyonu ile girilen değerler parametrede görülen formatta zaman elde edilir. Bu parametreler tamamen girilmek zorunda değildir. Sadece dakika belirlemek datetime.time(minute=5) gibi 5 dakika tanımlayabilirsiniz:\n", "- **Saat: hour, dakika: minute, saniye: second, milisaniye: microsecond olarak kodlanır.**\n", "- `datetime.datetime(yyyy,aa,gg)` fonskiyonu ile tarih (date) ve saat (time) birlikte olarak elde edilir. Ayrıca sonunda milisaniye (microsaniye) değeri de bulunur.\n", "- `datetime.timedelta()` fonksiyonu ile tarih işlemleri (ekleme vb.) yapılır. Örneğin bir tarih tipinde değişkene 2 gün eklemek için: ekleme=tarih+datetime.timedelta(days=2) yazılır.\n", "- **Gün: days, Saat: hours, Dakika: minutes, Saniye: seconds olarak kodlanır.**\n", "- `datetime.date.weekday()` fonksiyonu ile parametre olarak girilen değerin haftanın günü cinsinden çıktısı verilir. Örneğin: datetime.date.weekday(now)\n", "- Not: `strftime()` fonksiyonu datetime kütüphanesinin time ve date fonksiyonları için de kullanılır." ] }, { "cell_type": "markdown", "id": "e4700a78-aadd-4f7b-82c9-a14ec97e97e3", "metadata": {}, "source": [ "
Etkinlik: Doğum tarihinizi bir tarih tipi değişken olarak girdikten sonra doğum tarihinizden bugüne kaç saniye geçmiş hesaplayınız.
" ] }, { "cell_type": "markdown", "id": "ac0ac9ed-a6fe-467f-b0b8-8484ef805085", "metadata": {}, "source": [ "
Etkinlik: Doğum tarihinizi bir tarih tipi değişken olarak girdikten sonra o gün haftanın hangi günü imiş, bulunuz.
" ] }, { "cell_type": "markdown", "id": "e50c36ae", "metadata": {}, "source": [ "
Burada yazılanların haricinde python ile otomatik olarak gelen birçok kütüphane vardır. Bunların listesi için buraya tıklayınız.
\n", "Otomatik gelen kütüphaneler haricinde python topluluğu tarafından hazırlanmış ve yüklendikten sonra kullanılabilir kütüphaneler de vardır. Yapay zeka, makine öğrenmesi, 2D oyun, web sitesi frameworkleri gibi birçok alanda kütüphane vardır. Bu kütüphanelerin listesi için buraya tıklayınız.
" ] }, { "cell_type": "markdown", "id": "dad35cf6", "metadata": {}, "source": [ "# Karar Yapısı" ] }, { "cell_type": "markdown", "id": "866dd605", "metadata": {}, "source": [ "Tüm programlama dillerinde karar yapısı ile belirli bir koşulun gerçekleşmesi veya gerçekleşmemesi durumunda yapılacak işlemler sıralanır. Tüm dillerde temel karar yapısı `if` bloğudur. " ] }, { "cell_type": "markdown", "id": "b2061806-f511-4c88-b228-85f5e7c4a887", "metadata": {}, "source": [ "## IF Yapısı" ] }, { "cell_type": "markdown", "id": "c6c00886-79a7-432f-b5a0-53f2b5a138c2", "metadata": {}, "source": [ "**\"if\" kelime olarak \"eğer\" anlamına gelmektedir. \"Eğer şart gerçekleşirse (doğruysa-True) veya gerçekleşmezse (yanlışsa-False)\" şeklinde çalışır.** Koşul yapıları boolean veri tipi ile çalışır. Şart gerçekleşmişse True, gerçekleşmemişse False değeri kabul eder ve koşula göre işlem bloğuna gider. **\"if\" kullanılan ifadenin sonuna \":\" işareti getirilmezse blok çalışmaz, program hata verir.**" ] }, { "cell_type": "code", "execution_count": null, "id": "9170a552", "metadata": {}, "outputs": [], "source": [ "ates = 39\n", "if ates>37.5: print(\"Ateş Yüksek\") #ateş 39 olduğu için bu print çalışır.\n", "if ates<=37.5: print(\"Ateş Normal\") #ateş 39 olduğu için bu print çalışmaz." ] }, { "cell_type": "markdown", "id": "43a56465", "metadata": {}, "source": [ "Eğer `if` ifadesinden sonra bir satırdan daha fazla kod yazılacaksa yazılan `if`'in alt satırından ve bir tane **girinti (indent)** ile başlayarak yazılır. Bu girinti mantığı python'ın tamamında vardır ve sonu `:` ile biten deyimlerden sonra alt satıra geçince bir girinti (indent) yapmak gerekmektedir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "b5096651", "metadata": {}, "outputs": [], "source": [ "ates = 39\n", "durum = \"Düşük\"\n", "if ates>37.5:\n", " durum=\"Yüksek\"\n", " print(\"Ateşiniz: \",durum)\n", "if ates<=37.5:\n", " durum=\"Düşük\"\n", " print(\"Ateşiniz: \",durum)" ] }, { "cell_type": "markdown", "id": "ee6d422e-043f-4712-a008-1e516e395165", "metadata": {}, "source": [ "## ELSE Yapısı" ] }, { "cell_type": "markdown", "id": "e1ab1071", "metadata": {}, "source": [ "Koşul yapısı olan `if` kullanılırken eğer ortada 2 ihtimal var ise tekrar if bloğu ile şart yazmaya gerek yoktur. Bunun için `else` bloğu kullanılır. **Else 'Değilse' anlamına gelir.** Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "cea4c6e7-c2d3-44b7-989d-941d6581d2ca", "metadata": {}, "outputs": [], "source": [ "ates = 39\n", "if ates>37.5: print(\"Ateş Yüksek\") \n", "else: print(\"Ateş Normal\") #else bloğu\n", "\n", "durum = \"Düşük\"\n", "if ates>37.5:\n", " durum=\"Yüksek\"\n", " print(\"Ateşiniz: \",durum)\n", "else: #else bloğu\n", " durum=\"Düşük\"\n", " print(\"Ateşiniz: \",durum)" ] }, { "cell_type": "markdown", "id": "164a595a-e917-4c98-9018-7352cc40b315", "metadata": {}, "source": [ "## ELIF Yapısı" ] }, { "cell_type": "markdown", "id": "a0c98684", "metadata": {}, "source": [ "Eğer if kullanırken ortada 2 ihtimalden daha fazla ihtimal varsa `elif` (eğer değilse) kullanımı ile şartlar birbirine bağlanır. `elif` ile **bir şartın gerçekleşmediği durumda diğer şarta bakar, gerçekleştiği durumda bakmaz.** Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "5ea3bca5", "metadata": {}, "outputs": [], "source": [ "ates = 39\n", "durum = \"Düşük\"\n", "if ates>37.5:\n", " durum=\"Yüksek\"\n", " print(\"Ateşiniz: \",durum)\n", "elif ates<=35: #elif bloğu, öncesindeki şartın gerçkleşmediği durumda çalışır.\n", " durum=\"Düşük\"\n", " print(\"Ateşiniz: \",durum)\n", "else:\n", " durum=\"Orta\"\n", " print(\"Ateşiniz: \",durum)" ] }, { "cell_type": "code", "execution_count": null, "id": "b4e80e45", "metadata": {}, "outputs": [], "source": [ "#Yukarıdaki örneği elif ile yapmazsak mantıksal karşılaştırma ile yapabiliriz.\n", "ates = 39\n", "durum = \"Düşük\"\n", "if ates>37.5:\n", " durum=\"Yüksek\"\n", " print(\"Ateşiniz: \",durum)\n", "if ates<=35:\n", " durum=\"Düşük\"\n", " print(\"Ateşiniz: \",durum)\n", "if ates>35 and ates<=37.5: #and işleci\n", " durum=\"Orta\"\n", " print(\"Ateşiniz: \",durum)" ] }, { "cell_type": "code", "execution_count": null, "id": "f483f880", "metadata": {}, "outputs": [], "source": [ "#Art arda birçok elif kullanılabilir.\n", "puan = 73\n", "if puan>=0 and puan<45: print(\"Zayıf\")\n", "elif puan>=0 and puan<55: print(\"Geçer\")\n", "elif puan>=0 and puan<70: print(\"Orta\")\n", "elif puan>=0 and puan<85: print(\"İyi\")\n", "elif puan>=0 and puan<=100: print(\"Pekiyi\") #son blokta else kullanmadık çünkü 100'den büyük not girilince \"pekiyi\" yazmaması gerekir.\n", "else: print(\"Lütfen 0-100 arasında not giriniz!\")" ] }, { "cell_type": "markdown", "id": "c5279870", "metadata": {}, "source": [ "Yukarıdaki örneği elif değil `if` ile yaparsanız `elif`'in önemini anlamış olursunuz." ] }, { "cell_type": "markdown", "id": "dc0061e9", "metadata": {}, "source": [ "
Etkinlik: Gelir düzeyine göre 'düşük', 'orta' ve 'yüksek' olarak sınıflama yapan bir algoritma kodlayınız. (Gelir 9000'den az ise düşük, 9000 ile 17000 arasında ise orta, 17000'dan fazla ise yüksek olarak baz alınmalıdır.)
" ] }, { "cell_type": "markdown", "id": "53af7d8e", "metadata": {}, "source": [ "İç İçe If kullanılabilir. Koşul içine koşul eklenebilir. Unutulmaması gereken bir üst düzeydeki koşulu gerçekleşmesine bağlı olarak gerçekleşir." ] }, { "cell_type": "code", "execution_count": null, "id": "011de255", "metadata": {}, "outputs": [], "source": [ "if puan>=0 and puan<=100:\n", " if puan<45: print(\"Zayıf\")\n", " elif puan<55: print(\"Geçer\")\n", " elif puan<70: print(\"Orta\")\n", " elif puan<85: print(\"İyi\")\n", " else puan<=100: print(\"Pekiyi\")\n", "else: print(\"Lütfen 0-100 arasında not giriniz!\")" ] }, { "cell_type": "markdown", "id": "6ecc28eb", "metadata": {}, "source": [ "
Etkinlik: Kullanıcıya belirti soruları sorarak Covid-Nezle-Grip-Aleri Tablosuna göre teşhis edip sonucu ekrana yazdırınız.
" ] }, { "cell_type": "markdown", "id": "cc889cea", "metadata": {}, "source": [ "`if` yapısı string, integer, float, boolean, list gibi veri tiplerinde de kullanılabilir. Örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "71d2d825", "metadata": {}, "outputs": [], "source": [ "sifre = input(\"Şifre Giriniz: \")\n", "sifreTekrar = input(\"Şifrenizi Tekrar Giriniz: \")\n", "if sifre == sifreTekrar: print(\"Şifre onaylandı.\")\n", "if sifre != sifreTekrar: print(\"Şifreleri aynı giriniz.\")" ] }, { "cell_type": "code", "execution_count": null, "id": "a58befcf", "metadata": {}, "outputs": [], "source": [ "yas = int(input(\"Lütfen yaşınızı giriniz: \"))\n", "if not yas>=11: print(\"Bu oyunu oynayamazsınız.\") #eğerdeğilse kalıbını kullandık.\n", "else: print(\"Bu oyun için uygun yaştasınız, yönlendiriliyorsunuz...\")" ] }, { "cell_type": "code", "execution_count": null, "id": "f779ff7f", "metadata": {}, "outputs": [], "source": [ "yas = int(input(\"Lütfen yaşınızı giriniz: \"))\n", "sonuc = yas>=11 #burada sonuc true veya false boolean tipi bir değer alır.\n", "print(sonuc)\n", "if sonuc: print(\"Bu oyun için uygun yaştasınız, yönlendiriliyorsunuz...\")\n", "else: print(\"Bu oyunu oynayamazsınız.\")" ] }, { "cell_type": "code", "execution_count": null, "id": "7249101f", "metadata": {}, "outputs": [], "source": [ "i = int(input(\"0'dan 9'a kadar bir rakam yazınız.\"))\n", "liste = [0,1,2,3,4,5,6,7,8,9]\n", "if i in liste: print(i,\" sayısını girdiniz.\")\n", "else: print(\"0-9 arasında bir sayı girmediniz.\")" ] }, { "cell_type": "code", "execution_count": null, "id": "e5b550d3", "metadata": {}, "outputs": [], "source": [ "ePosta = input(\"e-Posta Adresinizi Giriniz: \")\n", "if not \"@\" in list(ePosta):\n", " print(\"E-posta adresinde @ işareti olmak zorundadır.\")" ] }, { "cell_type": "markdown", "id": "41850e14-560c-4fe7-a9e5-eaf6856c0df7", "metadata": {}, "source": [ "## İç İçe IF Yapısı (Nested Yapılar)\n", "Genellikle dallanma veya ön şartlar gerektiren durumlarda kullanılır. Örneğin öğrencinin notu girilirken 0 ile 100 arasında ise geçerli bir puanı vardır ve bu puanlar arasında \"Pekiyi - Zayıf\" olarak değerlendirmeler alır. Fakat notu 0 ile 100 arasında değilse bu not geçerli değildir. Burada unutulmaması gereken ilk if bloğunun şartı gerçekleşmezse içerideki if bloklarının çalışmayacak olmasıdır." ] }, { "cell_type": "code", "execution_count": null, "id": "fad2c9ad-dc3c-4ce0-84c3-dfd220553ee0", "metadata": {}, "outputs": [], "source": [ "#nested if yapısı\n", "yas=int(input(\"Yaşınızı Giriniz: \"))\n", "if yas>=1 and yas<=17:\n", " if yas>=6:\n", " if yas<=11: print(\"Tahminen ilkokul öğrencisidir.\")\n", " if yas<=14 and yas>11: print(\"Tahminen Ortaokul öğrencisidir.\")\n", " if yas>14: print(\"Tahminen Lise öğrencisidir.\")\n", " else:\n", " if yas>=4: print(\"Tahminen Anaokulu öğrencisidir.\")\n", " else: print(\"Okula veya anaokuluna başlama çağı gelmemiştir.\")\n", "else: print(\"Okul çağı bitmiş bir öğrencidir. Üniversiteye gidiyor olabilir.\")" ] }, { "cell_type": "markdown", "id": "41cb5889", "metadata": {}, "source": [ "
Etkinlik: Kullanıcıya belirti soruları sorarak Covid-Nezle-Grip-Aleri Tablosuna göre teşhis edip sonucu ekrana yazdırınız. Nested yapı kullanınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "36e1b149", "metadata": {}, "outputs": [], "source": [ "#Örnek problemin çözümü\n", "kuladi = \"abcd@gmail.com\"\n", "sifre = \"12345\"\n", "girilen_kuladi = input(\"Kullanıcı Adınızı Giriniz: \")\n", "girilen_sifre = input(\"Şifrenizi Giriniz: \")\n", "\n", "if kuladi == girilen_kuladi and sifre == girilen_sifre:\n", " print (\"Giriş Başarılı\")\n", "else:\n", " print (\"Yanlış Kullanıcı Adı veya Şifre\")\n", "\n", "#Örnek problemin farklı (nested) çözümü\n", "kuladi = \"abcd@gmail.com\"\n", "sifre = \"12345\"\n", "girilen_kuladi = input(\"Kullanıcı Adınızı Giriniz: \")\n", "\n", "if kuladi != girilen_kuladi:\n", " print (\"Böyle bir kullanıcımız bulunmamaktadır.\")\n", "else:\n", " girilen_sifre = input(\"Şifrenizi Giriniz: \")\n", " if sifre != girilen_sifre:\n", " print (\"Yanlış Şifre Girdiniz. Tekrar baştan deneyiniz.\")\n", " else:\n", " print (\"Giriş Başarılı.\")" ] }, { "cell_type": "markdown", "id": "7ca2efde", "metadata": {}, "source": [ "# Döngüler" ] }, { "cell_type": "markdown", "id": "93935610", "metadata": {}, "source": [ "**Döngü:** Bir program içerisinde bir işlem tekrarlayan şekilde yapılması gerektiğinde kodları tek tek yazmak yerine kullanılan yapılardır. İki tür döngü vardır. **Sayaçlı döngüler (`for`)**, yani kaç kere döneceği belli olan döngüler ve **koşullu döngüler (`while`)**, yani koşul gerçekleşene kadar (kaç kere döneceği belli değil belki 1 belki 99) tekrarlayan döngüler." ] }, { "cell_type": "markdown", "id": "1132b961", "metadata": {}, "source": [ "## For Döngüsü (Sayaçlı Döngü)" ] }, { "cell_type": "markdown", "id": "f9ffa870-4f25-4970-a417-63ac26ba525f", "metadata": {}, "source": [ "Kodun belirli bir sayıda tekrar etmesi gereken durumlarda kullanılan döngü türüdür. Örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "ad076685", "metadata": {}, "outputs": [], "source": [ "for i in range(6): print(i) #0'den 5'e kadar ekrana sayıları yazar. i varsayılan olarak 0'dır." ] }, { "cell_type": "code", "execution_count": null, "id": "3a02ca75", "metadata": {}, "outputs": [], "source": [ "for i in range(1,10): print(i) #1'den 9'a kadar ekrana sayıları yazar." ] }, { "cell_type": "code", "execution_count": null, "id": "71bca18d", "metadata": {}, "outputs": [], "source": [ "for i in range(-10,11): print(i) # -10'dan 10'a kadar ekrana sayıları yazar." ] }, { "cell_type": "code", "execution_count": null, "id": "29b27c50", "metadata": {}, "outputs": [], "source": [ "for i in range(1,21,2): print(i) # 1'den 20'ya kadar olan sayıları 2'şer atlayarak yazar (1-3-5-7...)" ] }, { "cell_type": "code", "execution_count": null, "id": "1d1496d2", "metadata": {}, "outputs": [], "source": [ "for i in range(0,21,2): print(i) # 0'dan 20'ya kadar olan sayıları 2'şer atlayarak yazar (0-2-4-6...)" ] }, { "cell_type": "code", "execution_count": null, "id": "730b12f5", "metadata": {}, "outputs": [], "source": [ "for i in range(0,21,3): print(i) # 0'dan 20'ya kadar olan sayıları 3'er atlayarak yazar (0-2-4-6...)" ] }, { "cell_type": "markdown", "id": "c0619fce", "metadata": {}, "source": [ "`For` döngüsü listedeki elemanlar içinde de döndürülebilir. Bu şekilde kullanılınca listenin eleman sayısı kadar döner ve her döngüde listenin bir elemanını ele alır." ] }, { "cell_type": "code", "execution_count": null, "id": "ede3a83a", "metadata": {}, "outputs": [], "source": [ "gunler = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "for i in gunler: #for döngüsünde aksi belirtilmedikçe ilk olarak 0'dan başlar.Yani i=0 olur.\n", " print (i)" ] }, { "cell_type": "code", "execution_count": null, "id": "e0c3026b", "metadata": {}, "outputs": [], "source": [ "gunler = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "for i in gunler:\n", " if i.startswith(\"P\"): print (i)" ] }, { "cell_type": "code", "execution_count": null, "id": "0850941c", "metadata": {}, "outputs": [], "source": [ "ozelKarakterler = [\"!\",\"'\",\"+\",\"-\",\"*\",\"/\",\"%\",\"&\",\"(\",\")\",\"=\",\"?\",\".\",\";\",\":\"]\n", "guvenliParola = input(\"Güvenli Bir Parola Giriniz: \")\n", "for karakter in guvenliParola:\n", " if not karakter in ozelKarakterler:\n", " print(\"Güvenli Şifre için özel karakterler kullanılmalıdır. Örnek:\")\n", " print(ozelKarakterler)\n", " else: print(\"Tebrikler Güvenli Şire Oluşturuldu\")" ] }, { "cell_type": "code", "execution_count": null, "id": "7977140a", "metadata": {}, "outputs": [], "source": [ "ciftSayilar =[]\n", "son = int(input(\"Kaça kadar olan çift sayılar lazım?: \"))\n", "for i in range(0,son,2):\n", " ciftSayilar.append(i)\n", "print(ciftSayilar)" ] }, { "cell_type": "code", "execution_count": null, "id": "652740ab", "metadata": {}, "outputs": [], "source": [ "#üstteki algoritmanın farklı bir çözümü\n", "ciftSayilar =[]\n", "son = int(input(\"Kaça kadar olan çift sayılar lazım?: \"))\n", "for i in range(son):\n", " if i%2==0: ciftSayilar.append(i)\n", "print(ciftSayilar)" ] }, { "cell_type": "markdown", "id": "77e70425", "metadata": {}, "source": [ "
Etkinlik: Taş kağıt makas oyunu yapınız.
" ] }, { "cell_type": "markdown", "id": "3f4648ee-0d21-4daf-9a25-bcefc10dbdcc", "metadata": {}, "source": [ "### Break, Continue ve Pass Deyimleri (Komutları)" ] }, { "cell_type": "markdown", "id": "1dedb722", "metadata": {}, "source": [ "**Döngüyü belirli bir adımda durdurmak ve çıkmak isterseniz** `break` deyimi (komutu) ile **durdurmak ve bir sonraki döngü adımına geçmek isterseniz** `continue` deyimi (komutu) ile yapabilirsiniz. Bilgisayarın **sonraki satıra geçmesini istediğiniz yerlerde** `pass` deyimi (komutunu) kullanabilirsiniz. `continue` deyimi döngüyü başa sararken `pass` deyimi sadece bulunduğu satırı atlatır.
\n", "Bu deyimlerden `pass` ve `break` her yerde kullanılabilir fakat `continue` deyimi sadece koşul (`if-elif-else`) ve döngü yapılarında kullanılabilir." ] }, { "cell_type": "code", "execution_count": null, "id": "b1f3c1dd", "metadata": {}, "outputs": [], "source": [ "#girilen sayının asal sayı olup olmadığını test edelim\n", "sayi = int(input(\"Asal testine sokulacak sayıyı giriniz: \"))\n", "for i in range(2,sayi):\n", " if sayi%i==0:\n", " print(\"Asal Değildir\")\n", " break\n", " print(\"Break çalıştı ise buradan sonrası artık çalışmaz ve döngüden tamamen çıkar dolayısıyla bu satır ekrana gelmez.\")\n", " if i==sayi-1: print(\"Asaldır\")" ] }, { "cell_type": "code", "execution_count": null, "id": "26010fb5", "metadata": {}, "outputs": [], "source": [ "#girilen sayının asal sayı olup olmadığını test edelim\n", "sayi = int(input(\"Asal testine sokulacak sayıyı giriniz: \"))\n", "for i in range(2,sayi):\n", " if sayi%i!=0:\n", " if i==sayi-1: print(\"Asaldır\")\n", " continue\n", " print(\"Contiune çalışınca buradan sonrası artık çalışmaz, bir sonraki döngüye geçer.Dolayısıyla bu satır ekrana gelmez.\")\n", " else:\n", " print(\"Asal Değildir.\")\n", " break" ] }, { "cell_type": "markdown", "id": "c500b150", "metadata": {}, "source": [ "
Etkinlik: 0'dan 200'e kadar olan asal sayıları bulan algoritmayı kodlayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "e4a9d5c7", "metadata": {}, "outputs": [], "source": [ "#Asal sayı probleminin çözümü\n", "asal = \"Evet\"\n", "for i in range(2,201): #Range fonksiyonu ile başlangıç ve bitiş aralığını belirlenir.Son sayıyının bir eksiğine kadar tekrarlar.\n", " for k in range(2,i):\n", " if i%k == 0:\n", " asal = \"Hayır\"\n", " break\n", " else: asal = \"Evet\"\n", " if asal ==\"Evet\": print (i)\n", " \n", "#Örnek problemin farklı çözümü\n", "asal = \"Evet\"\n", "asallar = []\n", "for i in range(2,201):\n", " for k in range(2,i):\n", " if i%k == 0:\n", " asal = \"Hayır\"\n", " break\n", " else: asal = \"Evet\"\n", " if asal ==\"Evet\": asallar.append (i)\n", "print (asallar)" ] }, { "cell_type": "markdown", "id": "3ec5a5ca", "metadata": {}, "source": [ "
Etkinlik: Ekrana for döngüsü ile '*' sembolünden 20x20 boyutunda kare çiziniz.
" ] }, { "cell_type": "markdown", "id": "852ca41b", "metadata": {}, "source": [ "
Etkinlik: Yıldız karakteri ve boşluk (\"* \") 1 birim kabul edilmektedir. Buna göre bu birimle 20 (en) x 10 (boy) biriminde ekrana dikdörtgen çizen algoritmayı kodlayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "9fdfd180", "metadata": {}, "outputs": [], "source": [ "#Etkinlik çözümü\n", "for i in range(1,11):\n", " if i==1 or i==10:\n", " print (\"* \"*20)\n", " else:\n", " print (\"*\",\" \"*35,\"*\")" ] }, { "cell_type": "markdown", "id": "796d83ca", "metadata": {}, "source": [ "
Etkinlik: Yıldız karakteri ve boşluk (\"* \") 1 birim kabul edilmektedir. Buna göre bu birimle kullanıcının girdiği en x boy biriminde ekrana dikdörtgen çizen algoritmayı kodlayınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "ac7af3ab", "metadata": {}, "outputs": [], "source": [ "#Etkinlik çözümü\n", "en = int(input(\"En'i Giriniz: \"))\n", "boy = int(input(\"Boy'u Giriniz: \"))\n", "\n", "for i in range(1,boy+1):\n", " if i==1 or i==boy:\n", " print (\"* \"*en)\n", " else:\n", " print (\"*\",\" \"*(en*2-(boy//2)),\"*\")" ] }, { "cell_type": "markdown", "id": "1587cb4e", "metadata": {}, "source": [ "## While Döngüsü (Koşullu Döngü)" ] }, { "cell_type": "markdown", "id": "a68e0279-51f7-4bc6-8264-95b4e9212b5d", "metadata": {}, "source": [ "Koşul **sağlandığı-olduğu** sürece tekrar eden döngü türüdür. Koşulun sağlandığı her kontrolden sonra döngü içindeki işlemler bir kez yapılır. Koşulun **sağlanmadığı** durumda döngüye girilmez. Koşuldan önce 'not' getirilerek \"koşul sağlanmadığı sürece tekrar eden döngü\" mantığı ile de döngü yapılabilir.
\n", "Sağlanması imkansız bir durum yaratarak **sürekli döngü** haline getirebilirsiniz. Örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "65dd809b-2e88-49f3-8a97-06fe3e9089da", "metadata": {}, "outputs": [], "source": [ "# çalıştıktan sonra 3'ten geriye sayan sonrasında \"BAŞLA\" yazdıran algoritmayı kodlayınız.\n", "import time\n", "gecenSure = 0\n", "while gecenSure<3:\n", " time.sleep(1) #1 saniye beklettik.\n", " gecenSure+=1 #saniyeyi 1 saniye bekledikten sonra hemen artırdık.\n", " if gecenSure==3: # 3.saniye oldu ise ekrana yazdırsın ve bir sonraki döngüye giremeyeceği için \"BAŞA\" yazsın.\n", " print(\"Geçen Süre:\",gecenSure,\"Saniye...\",\"BAŞLA\")\n", " else:\n", " print(\"Geçen Süre:\",gecenSure,\"Saniye...\")" ] }, { "cell_type": "code", "execution_count": null, "id": "69747c92", "metadata": {}, "outputs": [], "source": [ "#toplamı 1923 olan iki sayı yazılana kadar tekrar eden döngü\n", "i = 1923\n", "toplam = 0\n", "while toplam!=i:\n", " toplam = 0\n", " sayi1=int(input(\"1.Sayıyı giriniz: \"))\n", " sayi2=int(input(\"2.Sayıyı giriniz: \"))\n", " toplam = sayi1+sayi2\n", " if toplam!=i: print (\"Girdiğiniz sayıların toplamı: \",toplam,\"\\n1923'ü bulana kadar tekrar ediniz.\")\n", " else: print(\"Tebrikler!\")" ] }, { "cell_type": "code", "execution_count": null, "id": "4a8b194b", "metadata": {}, "outputs": [], "source": [ "#toplamı 1923 olan iki sayı yazılana kadar tekrar eden döngü (FARKLI ÇÖZÜM)\n", "i = 1923\n", "toplam = 0\n", "while toplam!=i:\n", " toplam = 0\n", " for j in range(1,3):\n", " toplam+=int(input(\"{}.Sayıyı giriniz: \".format(j)))\n", " if toplam!=i: print (\"Girdiğiniz sayıların toplamı: \",toplam,\"\\n1923'ü bulana kadar tekrar ediniz.\")\n", " else: print(\"Tebrikler!\")" ] }, { "cell_type": "code", "execution_count": null, "id": "5e20a436", "metadata": {}, "outputs": [], "source": [ "# while döngüsünde not, break ve contiune kullanılabilir.\n", "eposta = \"abcd@hotmail.com\"\n", "sifre = \"abcd1234\"\n", "giris =\"Başarısız\"\n", "denemeSayisi = 0\n", "while not giris==\"Başarılı\":\n", " if denemeSayisi ==3:\n", " print (\"3 kere başarısız deneme yaptığınız için bağlantınız banlanmıştır.\")\n", " break\n", " s1 = input(\"Kullanıcı E-Posta Giriniz: \")\n", " s2 = input(\"Şifre Giriniz: \")\n", " denemeSayisi +=1\n", " if s1!=eposta or s2!=sifre: continue\n", " if s1==eposta and s2==sifre:\n", " print(\"Yönlendiriliyorsunuz.\")\n", " giris=\"Başarılı\"" ] }, { "cell_type": "markdown", "id": "fdb08228", "metadata": {}, "source": [ "
Etkinlik: Kişinin 1 ile 100 arasında aklından tuttuğu sayıyı en hızlı bulan tahmin etme oyununu yapınız. Oyunda kullanıcıya tuttuğun sayı küçük mü, büyük mü diye sorularak sonuca gidilir.
" ] }, { "cell_type": "code", "execution_count": null, "id": "47abb37e-75aa-472e-9206-dffd86b43eb9", "metadata": {}, "outputs": [], "source": [ "#Sayı bulma oyunu çözümü\n", "alt,ust,durum,sayac = 1,100,\"Bulunmadı\",1\n", "print(f'{alt} ile {ust} arasında bir sayı rasgele seçiniz.')\n", "while durum==\"Bulunmadı\":\n", " if (ust-alt)%2==0: orta=(ust-alt)//2 #fark çift sayı ise bölümü atynen alıyoruz.\n", " else: orta=(ust-alt)//2+1 #fark tek sayı ise bölümü yukarı yuvarlıyoruz.\n", " cevap=input(f'{sayac}.Soru: Tuttuğunuz sayı {alt+orta-1} sayısından büyük mü? (E/H): ').upper()\n", " if cevap==\"E\": alt+=orta\n", " else: ust-=orta\n", " if alt==ust: durum=\"Bulundu\"\n", " sayac+=1\n", "print(f'Tuttuğunuz sayı: {alt} sayısıdır.')" ] }, { "cell_type": "code", "execution_count": null, "id": "48101fe7", "metadata": {}, "outputs": [], "source": [ "#Sayı bulma oyunu çözümü (for ile)\n", "import math #sayıyı yukarı yuvarlamak için math kütüphanesinden ceil fonksiyonunu kullanacağız\n", "print (\"1 ile 100 arasında bir sayı aklınızdan tutunuz.\")\n", "cevap,sayi=\"E\",50\n", "cevap=input(f'1.Soru: Tuttuğun sayı {sayi} sayısından büyük mü? (E/H)').upper()\n", "for i in range(2,8):\n", " if cevap==\"E\":\n", " sayi+=int(math.ceil(50/2**(i-1)))\n", " cevap=input(f'{i}.Soru: Tuttuğun sayı {sayi} sayısından büyük mü? (E/H)').upper()\n", " else:\n", " sayi-=int(math.ceil(50/2**(i-1)))\n", " cevap=input(f'{i}.Soru: Tuttuğun sayı {sayi} sayısından büyük mü? (E/H)').upper()\n", " if sayi==1 or sayi==99: break\n", "if cevap==\"E\": print(\"Tuttuğunuz sayi: \",sayi+1)\n", "else: print(\"Tuttuğunuz sayi: \",sayi)" ] }, { "cell_type": "markdown", "id": "f4561938", "metadata": {}, "source": [ "Döngülerde ve karar yapılarında (if, for ve while) bir de **'pass' deyimi**(komutu) vardır. Bu deyim genelde taslak kodlar yazarken kullanılır. Continue deyimi(komutu) gibidir fakat contiune deyimi(komutu) döngüyü başa döndürürken pass deyimi ile satır es geçilir sonraki satırdan devam eder." ] }, { "cell_type": "code", "execution_count": null, "id": "4fcd6137", "metadata": {}, "outputs": [], "source": [ "i=1\n", "while i<15\n", " if i%2==0:\n", " pass\n", " else:\n", " print(i,\" sayısı tek sayıdır.\")\n", " i+=1 #i'yi kendimiz manuel olarak artırdık. While döngüsünde sayaç olmadığı için." ] }, { "cell_type": "markdown", "id": "733c961a", "metadata": {}, "source": [ "
Etkinlik: While ve for döngülerini kullanarak yıldız (' * ') sembolü ile ekrana 11 satırlık 'Kelebek Motifi' modeli çiziniz. Örnek çıktı aşağıdaki gibidir.
" ] }, { "cell_type": "raw", "id": "00b319be", "metadata": {}, "source": [ "* *\n", "** **\n", "*** ***\n", "**** ****\n", "***** *****\n", "****** ******\n", "***** *****\n", "**** ****\n", "*** ***\n", "** **\n", "* *" ] }, { "cell_type": "code", "execution_count": null, "id": "e9dfb73c-6282-444a-905f-397d7d3bc3a6", "metadata": {}, "outputs": [], "source": [ "#kelebek motifi while döngüsü\n", "satir=1\n", "sonsatir=12\n", "while satir<=sonsatir:\n", " if satir<=int(sonsatir/2): print(\"*\"*satir,\" \"*(sonsatir-2*satir),\"*\"*satir)\n", " else: print(\"*\"*(sonsatir-satir),\" \"*(satir-(int(sonsatir/2)))*2,\"*\"*(sonsatir-satir))\n", " satir+=1" ] }, { "cell_type": "code", "execution_count": null, "id": "4aa21679-8d53-4506-a19b-fa99efbb3570", "metadata": {}, "outputs": [], "source": [ "#kelebek motifi for döngüsü\n", "sonsatir=12\n", "for i in range(1,sonsatir+1):\n", " if i<=int(sonsatir/2): print(\"*\"*i,\" \"*(sonsatir-2*i),\"*\"*i)\n", " else: print(\"*\"*(sonsatir-i),\" \"*(i-int((sonsatir/2)))*2,\"*\"*(sonsatir-i))" ] }, { "cell_type": "markdown", "id": "e7af0519", "metadata": {}, "source": [ "
Etkinlik: Döngüleri kullanarak standart bir hesap makinesi yapınız.
" ] }, { "cell_type": "markdown", "id": "1c9d06e2", "metadata": {}, "source": [ "
Etkinlik: e-Ticaret sitesine ürün ve fiyat verisi giren bir satıcıya sistemden sorulan 'Kaç adet ürün gireceksiniz?' sorusunun ardından sırayla ürün ve fiyatı soruları gelmeye başlıyor ve satıcı bu bilgileri giriyor. Sonunda kendisine girdiği-ürün fiyat bilgileri gösterilip onaylatılıyor. Bu akışı gerçekleştiren kodları yazınız. (İpucu: Dictionary - sözlük liste tipini kullanmanız gerekir.)
" ] }, { "cell_type": "markdown", "id": "29eb530e-8f11-48f5-b075-3f06f0fc0dff", "metadata": {}, "source": [ "## Listelere Ait Bazı Kompakt Söz Dizimleri (Comprehensions)" ] }, { "cell_type": "code", "execution_count": null, "id": "06086d40", "metadata": {}, "outputs": [], "source": [ "#hızlı integer listeler oluşturmak için\n", "liste = [i for i in range(1,11)] #bu örnek bir kompakt sözdizimidir.\n", "print(liste)" ] }, { "cell_type": "code", "execution_count": null, "id": "4f062ebe", "metadata": {}, "outputs": [], "source": [ "#listelerden istenilen elemanları seçmek için\n", "liste = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "print([eleman for eleman in liste if \"a\" in eleman]) #bu örnek bir kompakt sözdizimidir." ] }, { "cell_type": "code", "execution_count": null, "id": "52b23d0e", "metadata": {}, "outputs": [], "source": [ "#listelerden istenilen elemanları seçmek için\n", "liste = [\"Pazartesi\",\"Salı\",\"Çarşamba\",\"Perşembe\",\"Cuma\",\"Cumartesi\",\"Pazar\"]\n", "print([eleman for eleman in liste if eleman.endswith(\"a\")]) #bu örnek bir kompakt sözdizimidir." ] }, { "cell_type": "code", "execution_count": null, "id": "75d26ebf", "metadata": {}, "outputs": [], "source": [ "#birden çok değişkeni aynı anda atama\n", "i,s,f,l = 1923,\"TÜRKİYE\",23.04,[\"A\",\"N\",\"A\",\"V\",\"A\",\"T\",\"A\",\"N\"]\n", "print(i,s,f,l,sep=\"\\n\")" ] }, { "cell_type": "code", "execution_count": null, "id": "43e932d1", "metadata": {}, "outputs": [], "source": [ "#liste tipi değişkenler (list,tuple,set,dictionary) için kompakt söz dizimleri\n", "sayilar = [i for i in range(1,11)] #1'den 10'a kadar olan sayılardan bir liste oluşturduk.\n", "karesi = [j**2 for j in sayilar] #'sayilar' listesindeki sayıların karesinden yeni bir liste oluşturduk.\n", "print(karesi)" ] }, { "cell_type": "code", "execution_count": null, "id": "175b9b4a", "metadata": {}, "outputs": [], "source": [ "#enumerate() fonksiyonu ile for döngüsünü kullanarak liste tipi elemanlara sıralı sayılar atanabilir.\n", "plakalar = [\"İstanbul\",\"İzmir\",\"Kastamonu\"]\n", "for i,j in enumerate(plakalar,34):\n", " print(i,j)" ] }, { "cell_type": "code", "execution_count": null, "id": "c2f9b0d4", "metadata": {}, "outputs": [], "source": [ "#zip fonksiyonu ile liste tipi değişkenler (list,tuple,set,dictionary) birleştirilir.\n", "meyveler = [\"muz\",\"elma\",\"karpuz\"]\n", "adetler = [5,8,2]\n", "kilolar = [1.5, 2.1, 3.8]\n", "\n", "for meyve, adet, kilo in zip(meyveler,adetler,kilolar): #birleştirme yapılırken listelerdeki en az eleman sayısı kadar eleman birleştirilir.\n", " print(f\"Meyve adı: {meyve}, Adet: {adet}, Kilo: {kilo}\")" ] }, { "cell_type": "markdown", "id": "4505d606", "metadata": {}, "source": [ "# Fonksiyonlar" ] }, { "cell_type": "markdown", "id": "470bce99", "metadata": {}, "source": [ "Programlama dilinde fonksiyonlar **belirli görevleri yaparak sonucunu döndüren** bir ifade bloğudur. Şimdiye kadar gördüğümüz `print()`, `input()`, `len()` vb. öğeler fonksiyondur. Fonksiyonlar **tekrar tekrar yapılan işleri yeniden yazmamak, ortak görevleri bir araya getirmek veya çok özel durumları gerçekleştirmek için** kullanılır. Böylece temiz, basit, anlaşılır ve profesyonel bir kod yazabiliriz.
\n", "Fonksiyonlar `def` deyimi ile başlanarak yazılır. Fonksiyonlar girdi olarak parametreler kullanır, çıktı olarak ise bir ifade bloğu ortaya çıkarır. Fonksiyonlardan çıkış deyimi `return`'dür. Bu deyim aynı zamanda fonksiyon dışına aktardığımız değeri de döndürür.
\n", "**Parametre,** fonksiyonun değer üretmesi için gerekli **değer veya değişken girdileridir.**
\n", "Fonksiyon Yapısı:" ] }, { "cell_type": "markdown", "id": "cf937cab", "metadata": {}, "source": [ " " ] }, { "cell_type": "markdown", "id": "8ce803f8", "metadata": {}, "source": [ "`global` değişkenler kodun tamamında geçerli olan değişkenlerdir. Fonksiyonlar sayesinde her fonksiyon içinde (yerel (`local`)) yeni değişkenler oluşturabiliriz. Fonksiyon içinde oluşturduğumuz `local` değişken isimleri global değildir ve programın başka bir yerinde (ana programda veya başka fonksiyonda) yeniden aynı değişken isimleri kullanılabilir.
\n", "Örneğin, bir programda yüzlerce for döngüsü kullanılır. Fonksiyonları kullanmazsak her for döngüsü için farklı bir global sayaç değeri tanımlamak gerekir. for i in ..., for x in ...., for y in ....., gibi. Fakat bu kodları fonksiyon halinde yazarsak her bir fonksiyonda for i in..., for i in..., şeklinde kullanabiliriz çünkü i değerleri birbirinden etkilenmez.
\n", "Örnek Fonksiyonlar:" ] }, { "cell_type": "code", "execution_count": null, "id": "2e127eb7-e49f-4e2c-ba7b-d56168d47493", "metadata": {}, "outputs": [], "source": [ "#Parametresiz fonksiyon örneği\n", "def merhaba():\n", " print (\"Merhaba Fonksiyonlar\")\n", " return\n", " \n", "merhaba()" ] }, { "cell_type": "markdown", "id": "510366b9-32b4-4196-ab08-724b3ee9a6d9", "metadata": {}, "source": [ "
Etkinlik: Çağrıldığında İstiklal Marşının ilk dörtlüğünü ekrana yazdıran fonksiyonu yazınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "4c4ce6dd", "metadata": {}, "outputs": [], "source": [ "#Parametreli fonksiyon örneği\n", "def islem(i1, i2):\n", " sonuc = (i1*i2) + (i1//i2)\n", " return (sonuc)\n", "islem(10,2)" ] }, { "cell_type": "markdown", "id": "b20f2e89-bc86-42e7-9d75-f13e23c2de88", "metadata": {}, "source": [ "
Etkinlik: Kullanıcıdan parametre olarak aldığı kelimeyi tersten yazdıran fonksiyonu yazınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "25735b24", "metadata": {}, "outputs": [], "source": [ "#Fonksiyonlardaki değişkenler fonksiyon dışında tanınan bir değişken değildir. (Global değildir)\n", "def islem(i1, i2):\n", " sonuc = (i1*i2) + (i1//i2)\n", " return (sonuc)\n", "islem(10,2)\n", "print(sonuc) #sonuc değişkeni fonksiyon içinde tanımlamdığı için dışarıda tanınmaz. bu satır hata verir. kapatmak için başına # koyunuz" ] }, { "cell_type": "code", "execution_count": null, "id": "8c600040", "metadata": {}, "outputs": [], "source": [ "#Parametreli fonksiyonlarda girdi değişken tipini belirleme\n", "def asal(sayi: int): #parametre olarak değişken tipi belirleyerek girdi parametresini integer\n", " durum = \"Asal\"\n", " for i in range(2,sayi):\n", " if sayi%i==0:\n", " durum = \"Asal Değil\"\n", " break\n", " return (print(durum))\n", "asal(int(input(\"Bir Tam Sayı Giriniz: \")))" ] }, { "cell_type": "markdown", "id": "997efac9-81d6-4205-a916-228e60ddecf2", "metadata": {}, "source": [ "
Etkinlik: Float olarak verilen parametrelerle toplama işlemi yapan fonksiyonu yazınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "1ded0f67", "metadata": {}, "outputs": [], "source": [ "#Parametreli fonksiyonlarda uygun olmayan girdi değişken tipi ile hata verir.\n", "def asal(sayi: int): #parametre olarak değişken tipi belirleyerek girdi parametresini integer olarak\n", " durum = \"Asal\"\n", " for i in range(2,sayi):\n", " if sayi%i==0:\n", " durum = \"Asal Değil\"\n", " break\n", " return (durum)\n", "asal(float(input(\"Bir Tam Sayı Giriniz: \"))) #parametre olarak uygun değişken tipi vermezsek program hata verir. (Bkz. float)" ] }, { "cell_type": "code", "execution_count": null, "id": "1b73033a", "metadata": {}, "outputs": [], "source": [ "#Fonksiyonlarda parametreleri argümanlarla (değeri belirli olan değişken) çalıştırmak.\n", "def islem(sayi: int, yil=2022):#parametre olarak değişken tipi belirleyerek girdi parametresini integer olarak\n", " dYili = yil-sayi\n", " return (print(f'Doğum yılınız: {dYili}'))\n", "islem(int(input(\"Yaşınızı Giriniz: \"))) #parametre 1 tane verdik ama fonksiyon tanımında 2 tane girdi var; biri parametre (sayi) diğeri argüman (yil)" ] }, { "cell_type": "markdown", "id": "3ea1f926-cc57-4b8d-b7c2-84b4e6d2f703", "metadata": {}, "source": [ "
Etkinlik: Parametre olarak fiyat, argüman olarak indirim oranı alan bir fonksiyonun, ürün fiyatından indirim oranı tutarında tutarı düştükten sonra ekrana yazdıran fonksiyonu yazınız.
" ] }, { "cell_type": "markdown", "id": "e7303f08-2287-474d-b956-c71823d3f6fe", "metadata": { "tags": [] }, "source": [ "## Fibonacci Serisi\n", "Fibonacci dizisi, her sayının kendinden önceki ile toplanması sonucu oluşan bir sayı dizisidir. Fibonacci dizisi herhangi iki sayıdan başlayabilir. Fibonacci sayı dizisindeki sayıların birbirleriyle oranı olan ve altın oran denilen 1,618 sayısı ise doğada, sanatta ve hayatın her alanında görülen ve estetik ile bağdaştırılan bir sayıdır. Ayrıca Pascal Üçgeninde de fibonacci sayı dizisi bulunmaktadır. \n", "Aşağıdaki görselde daha iyi anlaşılır:
\n", "" ] }, { "cell_type": "markdown", "id": "9153a4d8-edc6-4b77-b3fa-dd7add47cad8", "metadata": {}, "source": [ "
Etkinlik: Büyük bir çiftliğe bir dişi, bir erkek olmak üzere yeni doğmuş bir tavşan çift konur. Her tavşan çifti doğduktan bir ay sonra yetişkin hâle gelmekte ve her ay bir dişi, bir erkek olmak üzere yeni bir tavşan çifti doğurmaktadır. Tavşanların hiç ölmediği varsayıldığında çiftlikte bir yıl sonra kaç çift tavşanımız olur?
\n", " Bu soru 1202 yılında yazılan 'Liber Abaci (Hesap Kitabı)' isimli kitapta yazar 'Leonardo Fibonacci' tarafından sorulmuştur. Sorunun çözümü ünlü Fibonacci Dizisidir.
" ] }, { "cell_type": "code", "execution_count": null, "id": "18747206", "metadata": {}, "outputs": [], "source": [ "#Tavşan Sorusu - Fibonacci Serisi Çözümü\n", "def fibonacci(n: int):\n", " terim1,terim2=0,1\n", " if n!=1:\n", " for i in range(2,n+1):\n", " fibDegeri=terim1+terim2\n", " terim1,terim2 = terim2,fibDegeri\n", " else: fibDegeri=terim1+terim2\n", " return(fibDegeri)\n", "print(fibonacci(12)) #12.Ay'ı istediği için 12'yi girdik" ] }, { "cell_type": "code", "execution_count": null, "id": "da9623f5", "metadata": {}, "outputs": [], "source": [ "#Fibonacci serisi\n", "def fibonacci(n: int):\n", " terim1,terim2=0,1\n", " if n!=1:\n", " for i in range(2,n+1):\n", " fiboDegeri=terim1+terim2\n", " print(f'{i}.terim: {fiboDegeri}')\n", " terim1,terim2 = terim2,fiboDegeri\n", " else:\n", " fiboDegeri=\"1. Terim: \",terim1+terim2,\"\"\n", " return(fiboDegeri)\n", "fibonacci(int(input(\"Fibonacci'nin kaç terimini yazdıralım?(Giriniz): \")))" ] }, { "cell_type": "markdown", "id": "13bfd97a-dac6-4829-b56f-b189af332620", "metadata": {}, "source": [ "
Etkinlik: Pascal üçgenini 1.satırdan 11.satıra kadar fonksiyonla yazdırınız.
" ] }, { "cell_type": "code", "execution_count": null, "id": "ecf9de48-6b31-4b9f-bd04-f892911c478f", "metadata": {}, "outputs": [], "source": [ "#Etkinlik Çözümü\n", "def pascal(n: int):\n", " for i in range(1,n + 1): \n", " m = 1; \n", " for j in range(1,i + 1):\n", " print(m, end =\" \")\n", " m = int(m * (i - j) / j) \n", " print(\"\")\n", " return\n", "pascal(int(input(\"Kaçıncı satıra kadar yazılacak, giriniz: \")))" ] }, { "cell_type": "markdown", "id": "f5170f65-58a1-41e1-ae41-2431b3872232", "metadata": { "tags": [] }, "source": [ "## İç İçe Fonksiyonlar (Nested Fonksiyonlar)\n", "Fonksiyon içinde fonksiyon kullanarak oluşturulan yapılardır. En dıştaki fonksiyonda kullanılan değişkenler daha içerde olan fonksiyonlar tarafından kullanılabilir. Sadece iç fonksiyonda kullanılan değişken 'yerel olmayan (`nonlocal`)' olarak adlandırılır. Fonksiyon içinde tanımlanan fonksiyonlar varsayılan olarak dış dünyaya kapalıdır ve sadece tanımlandıkları fonksiyon içinde geçerlidirler. Örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "db0eb1db-27dd-45c4-80c7-c01de64d300f", "metadata": {}, "outputs": [], "source": [ "def yetkiliMi(kullanici:str, sayfa:str):\n", " def yetkiler(kullanici):\n", " kullanicilar = {\n", " \"root\":[\"AYARLAR\",\"ANASAYFA\",\"KULLANICILAR\",\"TALEP\",\"İŞLEM\",\"MESAJ\",\"İLETİŞİM\"],\n", " \"admin\":[\"ANASAYFA\",\"KULLANICILAR\",\"TALEP\",\"İŞLEM\",\"MESAJ\",\"İLETİŞİM\"],\n", " \"ogretmen\":[\"TALEP\",\"İŞLEM\",\"MESAJ\",\"İLETİŞİM\"],\n", " \"ogrenci\":[\"TALEP\",\"İLETİŞİM\"]\n", " }\n", " return kullanicilar.get(kullanici)\n", " if sayfa in yetkiler(kullanici): return \"Evet\"\n", " else: return \"Hayır\"\n", "print(\"Yetkili Mi? \",yetkiliMi(input(\"Kullanıcı Adınızı Giriniz: \").lower(),input(\"Erişmek İstediğiniz Sayfa Adını Giriniz: \").upper()))" ] }, { "cell_type": "markdown", "id": "b5c50ad1-ad8b-4d92-b3ef-28a9fd7a8b57", "metadata": {}, "source": [ "
Etkinlik: Girilen matematiksel ifadeyi işlem önceliğine göre yaparak sonucu yazdıran programı yazınız. (Parantez ve üssü işlemleri olmadan)
" ] }, { "cell_type": "code", "execution_count": null, "id": "6ac1624f-df0c-429c-b085-9312b53fe9c8", "metadata": {}, "outputs": [], "source": [ "#Etkinlik Çözümü\n", "def parcalama (soru):\n", " start = 0\n", " parcala = []\n", " dortIslem=[\"+\",\"-\",\"*\",\"/\"]\n", " for sayac in range(0,len(soru)):\n", " if soru[sayac] in dortIslem:\n", " parcala.append(int(soru[start:sayac]))\n", " parcala.append(soru[sayac])\n", " start = sayac + 1\n", " if sayac == len(soru)-1: parcala.append(int(soru[start:sayac+1]))\n", " \n", " def islem(parcalanmis):\n", " sayac = 0\n", " while sayac < len(parcalanmis):\n", " if parcalanmis[sayac] == \"*\" or parcalanmis[sayac] == \"/\":\n", " if parcalanmis[sayac] == \"*\": sonuc = parcalanmis[sayac-1]*parcalanmis[sayac+1]\n", " if parcalanmis[sayac] == \"/\": sonuc = parcalanmis[sayac-1]/parcalanmis[sayac+1]\n", " for i in range (1,4): parcalanmis.pop(sayac-1)\n", " parcalanmis.insert(sayac-1,sonuc)\n", " sayac-=1\n", " sayac += 1\n", " sonuc = parcalanmis[0]\n", " for i in range (0,len(parcalanmis)-1):\n", " if parcalanmis[i] == \"+\": sonuc+=parcalanmis[i+1]\n", " if parcalanmis[i] == \"-\": sonuc-=parcalanmis[i+1]\n", " return sonuc\n", " \n", " return islem(parcala)\n", "\n", "print(parcalama(input(\"İşlemi giriniz: \")))" ] }, { "cell_type": "markdown", "id": "c72ce294-2e4f-4459-a95c-d60b8f8f90b2", "metadata": {}, "source": [ "Ek Bilgi:
\n", "Fonksiyonlar çağrılabilir şekilde (`fonksiyon()`) kullanıldığında ilgili fonksiyonun `return` ifadesindeki değeri döndürürler. Fakat fonksiyonları çağırmadan (yani `fonksiyon` olarak) 'işlevini' bir değişken gibi kullanabiliriz. Bu yöntem bir fonksiyona başka bir fonksiyonu parametre olarak verirken kullanılır. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "8741384c-6465-4c5b-a50e-da24c8521e18", "metadata": {}, "outputs": [], "source": [ "# standart 'çağrılan' fonksiyon biçimi\n", "def topla(a,b):\n", " sonuc = a+b\n", " return print(sonuc)\n", "topla(3,5)" ] }, { "cell_type": "code", "execution_count": null, "id": "9a3d6898-a1a8-4aca-8c75-e4e246bc9e91", "metadata": {}, "outputs": [], "source": [ "# çağrılmadan kullanılan fonksiyon biçimi\n", "def topla(a,b):\n", " sonuc = a+b\n", " return sonuc\n", "\n", "def carp(f,g): # f ve g adında 2 parametre aldık.\n", " sonuc = f(g,5)*g # f parametresini fonksiyon olarak yolladığımızı bildiğimiz için\n", " # onu kendi atandığı fonksiyonunu yerine getirmesi için parametreli olarak çağırdık.\n", " return sonuc\n", "\n", "fonk = topla # topla fonksiyonunu 'fonk' değişkenine atadık.\n", "# 'fonk' değişkeni artık kendisine verilen parametreleri işlevini aldığı fonksiyon ile işleyebilecek bir durumda.\n", "\n", "print(carp(fonk,10))" ] }, { "cell_type": "markdown", "id": "77e94d75-785a-4d7a-8706-a1b2bc405915", "metadata": {}, "source": [ "Esasında bu yaptığımız işlemin sonuç olarak şundan farkı yok." ] }, { "cell_type": "code", "execution_count": null, "id": "87a1be2e-bded-47c1-adca-b2c3a569ee1c", "metadata": {}, "outputs": [], "source": [ "# çağrılarak kullanılan fonksiyon biçimi\n", "def topla(a,b):\n", " sonuc = a+b\n", " return sonuc\n", "\n", "def carp(a,g): # f ve g adında 2 parametre aldık.\n", " sonuc = topla(a,5)*g #fonksiyonu çağırarak kullandık.\n", " return sonuc\n", "\n", "print(carp(10,10))" ] }, { "cell_type": "code", "execution_count": null, "id": "495c8481-2f6b-4a8b-932a-9f4d5a01505a", "metadata": {}, "outputs": [], "source": [ "# bunu şu şekilde yapmak daha sabit ifadelerle mümkün fakat dinamikliğe ihtiyacınız olduğu zamanlarda işlevsel değil.\n", "def topla(a,b):\n", " sonuc = a+b\n", " return sonuc\n", "\n", "def carp(a,g): # f ve g adında 2 parametre aldık.\n", " sonuc = a*g #fonksiyonu çağırarak kullandık.\n", " return sonuc\n", "\n", "print(carp(topla(10,5),10))" ] }, { "cell_type": "markdown", "id": "a4f8311a-4b10-49bc-a6c7-db673b26e317", "metadata": {}, "source": [ "Bir fonksiyona başka bir fonksiyonun işlevini dinamik bir şekilde aktrabilmek için fonksiyonu bir değişkene atayarak o değişkeni fonksiyon yerine dinamik olarak kullanmak iyi bir yöntem." ] }, { "cell_type": "markdown", "id": "d402bf7a-efa4-41c2-a3dc-59c60c2238dd", "metadata": {}, "source": [ "## Global, Yerel ve Yerel Olmayan Değişkenler (Global, Local ve Nonlocal)\n", "Ana programdaki (`global`deki) değişkenler kodun tamamında geçerli, fonksiyon içindeki değişkenler (`local`dekiler) ise sadece ilgili fonksiyonunda geçerli, kodun bütününde (`global`de) geçerli değildir. Fakat bir fonksiyon içinde globaldeki değişken ismi ile aynı isimde bir `local`değişken varsa fonksiyon o değişkeni `local` olarak ele alır ve `local` değeri üzerinden işlem yapar. Bu durumda `global` olan değişkene erişilemez gibi hissedebilirsiniz. Fakat üst hiyeraşideki değişkeni fonksiyon içinden tanımlamak, erişmek, kullanmak ve değiştirmek gerekebilir. Bu durumda `global` ve `nonlocal` deyimlerini kullanabiliriz. Örnekler:" ] }, { "cell_type": "code", "execution_count": null, "id": "06d5f5f8-abf9-4e85-96c7-1f30a45a5f00", "metadata": {}, "outputs": [], "source": [ "#global, local ve nonlocal değişkenlerin yerlerini öğrenelim.\n", "g = \"Ana Programdaki Değişken (Global)\"\n", "def yerel():\n", " l = \"Yerel Değişken (Local)\"\n", " def yerelOlmayan():\n", " nl = \"Yerel Olmayan Değişken (Non Local)\"\n", " return\n", " return\n", "print(g) #hata vermez, ekrana basılır.\n", "print(l) #hata verir.\n", "print(nl) #hata verir." ] }, { "cell_type": "code", "execution_count": null, "id": "a3da1f9f-e79e-4dbc-82ad-087ebf2caad3", "metadata": {}, "outputs": [], "source": [ "#global ve local'de aynı isimde değişken varsa fonksiyon local olanı ele alır.\n", "g = \"Ana Programdaki Değişken (Global)\"\n", "def yerel():\n", " g = \"Yerel Değişken (Local)\"\n", " return print(\"yerel() ile basılan g değeri: \",g)\n", "print(\"print(g) ile basılan g değeri: \",g) #ana programdaki g (globalde olan)\n", "yerel() #fonksiyondaki g (localde olan)" ] }, { "cell_type": "code", "execution_count": null, "id": "01987f69-673b-4fce-8bc8-162a73b01ff9", "metadata": {}, "outputs": [], "source": [ "#global ve local'de aynı isimde değişken yoksa fonksiyon global olanı ele alır.\n", "g = \"Ana Programdaki Değişken (Global)\"\n", "def yerel():\n", " l = \"Yerel Değişken (Local)\"\n", " return print(\"yerel() ile basılan g değeri: \",g)\n", "print(\"print(g) ile basılan g değeri: \",g) #ana programdaki g (globalde olan)\n", "yerel() #fonksiyondaki g (globalde olduğu için fonksiyonda da geçerli olan)" ] }, { "cell_type": "markdown", "id": "7394e43f-4168-4739-82ba-94b95ceee470", "metadata": {}, "source": [ "Örneklemek gerekirse:" ] }, { "cell_type": "code", "execution_count": null, "id": "56598d77-68a5-4157-919f-1b5f13314981", "metadata": {}, "outputs": [], "source": [ "#global, local ve nonlocal değişkenlere erişelim\n", "g = \"Ana Programdaki Değişken (Global)\"\n", "def yerel():\n", " global l #globalde geçerli olacak 'l' değişkenini fonksiyon içinde tanımladık\n", " l = \"Yerel'den tanımlanan bir global değişken\" # 'l' artık global bir değişken\n", " global g #globaldeki g değişkenine eriştik\n", " g = \"İçeriden Global değişkene eriştik ve değişkeni değiştirdik\" #globaldeki g değişkenini değiştirdik\n", " x = \"Şu an yerel olan, fakat yerel olmayan iç fonksiyondan erişip değişeceğimiz değişken\" #bunu iç fonksiyonda manipüle edeceğiz.\n", " \n", " def yerelOlmayan():\n", " nonlocal x\n", " nl = \"Yerel Olmayan Değişken (Non Local)\"\n", " x = nl + \" Local'in Yerine Geçti ! Tadaaa\"\n", " return print(\"'nl'yi yazdırdık: \",nl)\n", " \n", " yerelOlmayan() #iç fonksiyonu da çalıştıralım ve x değişsin.\n", " return print(\"'x'i yazdırdık: \",x)\n", "\n", "yerel() #Fonksiyonu çalıştırmazsak fonksiyon içinde yaptığımız işlemler gerçekleşmez. x ve nl değişkenleri bu satırla print olur. (return ettiğimiz için)\n", "print(\"'g'yi yazdırdık: \",g) #hata vermez. \"Ana Programdaki Değişken (Global)\" çıktısını beklemeyin.\n", "print(\"'l'yi yazdırdık: \",l) #hata vermez. Yerelden ana programda geçerli bir değişken oluşturduk." ] }, { "cell_type": "markdown", "id": "fa278bf5-d392-4878-b847-ea266d0dcc5f", "metadata": {}, "source": [ "## Özyinelemeli (Özyineli) Fonksiyonlar (Recursive Functions)\n", "Kendi kendini çağıran fonksiyonlara özyinelemeli (recursive) veya özyineli fonksiyonlar denilir. Özyinelemeli fonksiyonlar, ileri bilgisayar uygulamalarında çok kullanılır. Çoğunlukla, döngülerle çözülebilen problemler, özyinelemeli fonksiyonlarla çok daha kolay olarak çözülebilir (Karaçay, 2015)
\n", "**Özyinelemeli Fonksiyon Çalışma Mantığı**:


\n", "
\n", "Yukarıdaki Örnek-1'de görüleceği üzere özyinelemeli fonksiyonda artık fonksiyonun yinelenmemesi gereken duruma özgü bir koşul (base case) ifadesi ile kendini yineletmeyen 'return' değeri verilerek fonksiyondan çıkılır ve sonuç gönderilir.
\n", "Örnek-2'de ise fonksiyon yinelenmesi gereken duruma özgü koşul (recursive case) ifadesi ile yineletilir, koşula uymadığı durumda kendini yineletmeyen 'return' değeri ile fonksiyondan çıkılır ve sonuç gönderilir.
\n", "Özyinelemeli fonkiyonların belirli bir şekli yoktur, farklı şekillerde de yapılabilir fakat konsept hepsinde aynıdır." ] }, { "cell_type": "code", "execution_count": null, "id": "5af55e06-28ce-422c-9963-087d7bf811c9", "metadata": {}, "outputs": [], "source": [ "#tavşan sorusunun (fibonacci serisi) özyinelemeli çözümü\n", "def fibonacci(n):\n", " if n<3: return 1 # Base Case(Temel Durum) 3'ten küçük olunca yinelenmeyen return yazıyoruz.\n", " #Neden 'n<3'; çünkü n=(2,1) olunca n-1=(1,0) n-2=(0,-1) dolayısıyla geriye doğru giderek ilk terime gelmiş olduk. Yinelemenin bitmesi gerek.\n", " #Neden 'return 1'; çünkü ilk terime geldik ve ilk terim her halükarda 1.\n", " return fibonacci(n-1)+fibonacci(n-2)\n", "print(fibonacci(12)) #12. Ayda olacak tavşan sayısı, 12.Terim" ] }, { "cell_type": "code", "execution_count": null, "id": "bc5468ad-7b59-4d6a-9b1f-73575943fbbe", "metadata": {}, "outputs": [], "source": [ "#sıfırdan girilen pozitif sayıya kadar olan sayıların toplamını hesaplayan bir özyinelemeli fonksiyon yazalım\n", "def toplam(sayi):\n", " if sayi == 1: return 1 # Base Case(Temel Durum) 1'e gelince yinelenmeyen return yazıyoruz\n", " return sayi + toplam(sayi - 1) # Recursive Case (Yineleten Durum) sayımızı her yinelemede birer azaltarak ve toplayarak yineliyoruz\n", "print(toplam(int(input(\"Pozitif Bir Sayı Giriniz: \"))))" ] }, { "cell_type": "code", "execution_count": null, "id": "8cf8f576-bdab-43a7-be3f-658bd4b45849", "metadata": {}, "outputs": [], "source": [ "#sıfır'dan girilen negatif sayıya kadar olan sayıların toplamını hesaplayan bir özyinelemeli fonksiyon yazalım\n", "def toplam(sayi):\n", " if sayi == -1: return -1 # Base Case(Temel Durum) -1'e gelince yinelenmeyen return yazıyoruz\n", " return sayi + toplam(sayi + 1) # Recursive Case (Yineleten Durum) sayımızı her yinelemede birer artırarak ve toplayarak yineliyoruz\n", "print(toplam(int(input(\"Negatif Bir Sayı Giriniz: \"))))" ] }, { "cell_type": "code", "execution_count": null, "id": "58dc31dc-a3c1-4c46-bfa9-770926d26e96", "metadata": {}, "outputs": [], "source": [ "#Girilen pozitif sayıya kadar olan sayıları çarpan bir özyinelemeli fonksiyon yazalım (faktöriyel bulma)\n", "def carpim(sayi):\n", " if sayi == 1: return 1 # Base Case(Temel Durum) 1'e gelince yinelenmeyen return yazıyoruz. Neden 0 değil de 1, 0 çarpmada yutan eleman.\n", " return sayi * carpim(sayi - 1) # Recursive Case (Yineleten Durum) sayımızın bir eksiğini her yinelemede önceki sonuçla çarparak yineliyoruz.\n", "print(carpim(int(input(\"Pozitif Bir Sayı Giriniz: \"))))" ] }, { "cell_type": "code", "execution_count": null, "id": "2072362e-ed24-45a9-bf58-d98f60b7436f", "metadata": {}, "outputs": [], "source": [ "#sayılar için len() foknsiyonu kullanılmıyor malum. Basamak hesaplamak için bir özyinelemeli fonksiyon yazalım\n", "def basamak(sayi):\n", " if sayi%10 < 1: return 0 # Base Case(Temel Durum) sayının 10'a bölümünden kalan ondalıklı olunca yinelenmeyen return yazıyoruz\n", " return basamak(sayi/10) + 1 # Recursive Case (Yineleten Durum) sayının tam kısmını bölme işlemiyle bir azaltarak (ondalıklayarak) ve +1 ile yineliyoruz\n", "print(basamak(int(input(\"Bir Sayı Giriniz: \"))))" ] }, { "cell_type": "code", "execution_count": null, "id": "1a7d2d8f-7085-4551-b755-e6c921d9ae37", "metadata": {}, "outputs": [], "source": [ "#Pascal üçgeni için bir özyinelemeli fonksiyon yazalım\n", "def pascal(n):\n", " satir = [1]\n", " if n == 1:\n", " print(len(satir),\".Satır: \",satir)\n", " return satir\n", " islenenSatir = pascal(n-1)\n", " for i in range(len(islenenSatir)-1):\n", " satir.append(islenenSatir[i] + islenenSatir[i+1])\n", " satir += [satir[0]]\n", " print(len(satir),\".Satır: \",satir)\n", " return satir\n", "pascal(int(input(\"Kaçıncı Satır'a Kadar Üçgen Oluşacak: \")))" ] }, { "cell_type": "markdown", "id": "43341ba4-054b-4f41-bff1-f1a3913e0d95", "metadata": {}, "source": [ "# Nesne Yönelimli Programlama - Object Oriented Programming\n", "Nesne yönelimli programlama şöyle açıklanabilir; martı, güvercin, baykuş, ağaçkakan, yarasa gibi kuşlar vardır, buradaki 'kuş' kavramı herhangi bir kuşu belirtmez, soyut bir kavram olarak zihinlerimizde yer edinmektedir. Bu örnekten yola çıkarak; 'baykuş', 'ağaçkakan', 'yarasa' nesneleri, 'kuş' sınıfı ifade eder. Nesne olarak her bir kuş'un (martı, baykuş, ağaçkakan, yarasa) da nitelikleri (ağırlığı, beslenme türü, yaşam alanı) ve metotları (saldırma, beslenme, uçma) vardır.
\n", "Bazı programlama dilleri (python'da buna dahil) bu yapıyı kullanmaktadır. Sınıf yapısı ile;\n", "- Daha rahat okunabilir kodlama,\n", "- Modüler iş parçacıkları,\n", "- Kod bakımı yapmada kolaylık,\n", "- Projeyi rahat geliştirme veya başka işlerde kullanma kolaylığı sağlar.
\n", "Bu mantığa Nesne Yönelimli Programlama (Object Oriented Programming) denmektedir. Aşağıdaki görsele göz atalım." ] }, { "cell_type": "markdown", "id": "3a7457f2-e63f-44ce-91ca-210d825608ce", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "id": "8a5a8112-21e9-4a7d-b2b8-31361ba16838", "metadata": {}, "source": [ "## Sınıf (Class)\n", "Kendisine ait veri türlerini belirleyeceğimiz ve bu veri türleriyle yeni nesneler üretmemizi sağlayan yapılara sınıf denir. Sınıfları oluşturmak için `class` deyimi kullanılır. Sınıf dışına çıkmak için sadece girintiden (intend) çıkmanız yeterlidir. Aşağıda **ilkel şekilde bir sınıf oluşturup ve niteliklerini belirleyelim.**" ] }, { "cell_type": "code", "execution_count": null, "id": "694d7c2d-2088-4e1e-a0bd-c4eafcb9d9b0", "metadata": {}, "outputs": [], "source": [ "#bir class oluşturalım\n", "class birey(): #class'ı oluşturduk\n", " isim = \"\" #nitelikleri (attributes) girdik\n", " tcNo = 0 #nitelikleri girdik\n", " yas = 0 #nit\"elikleri girdik\n", " cins = \"\" #nitelikleri girdik\n", " #metotlar" ] }, { "cell_type": "code", "execution_count": null, "id": "08341a58-688c-420c-bece-21a364c1ed19", "metadata": {}, "outputs": [], "source": [ "#bir class'tan yeni bir class üretelim ve devraldığı niteliklere ek yeni nitelikler ekleyelim.\n", "class birey(): # temel class'ı oluşturduk (üst sınıf-base class veya parent class)\n", " isim = \"\"\n", " tcNo = 0\n", " yas = 0\n", " cins = \"\"\n", " #metotlar\n", "class ogrenci(birey): # birey class'ından yeni bir 'ogrenci' class'ını türettik (alt sınıf-sub class veya child class)\n", " isim = \"\"\n", " tcNo = 0\n", " yas = 0\n", " cins = \"\"\n", " okul = \"\" #yeni nitelikler\n", " ogrNo = 0 #yeni nitelikler\n", " seviye = 0 #yeni nitelikler\n", " sube = \"\" #yeni nitelikler\n", "class ogretmen(birey): # birey class'ından yeni bir 'ogretmen' class'ını türettik (alt sınıf-sub class veya child class)\n", " isim = \"\"\n", " tcNo = 0\n", " yas = 0\n", " cins = \"\"\n", " okul = \"\" #yeni nitelikler\n", " brans = \"\" #yeni nitelikler\n", " kidem = 0 #yeni nitelikler" ] }, { "cell_type": "markdown", "id": "9576d3fb-e4d6-4bdb-bb33-19d52645d8f2", "metadata": {}, "source": [ "Yukarıdaki örnekte 'birey' sınıfının nitelikleri ve metotları 'ogrenci' sınıfı ve 'ogretmen' sınıfı tarafından `class ogrenci(birey):` ve `class ogretmen(birey):` ifadeleri ile devralınmıştır. Bu durumda **'birey' sınıfı 'üst sınıf (parent class)', 'ogrenci' ve 'ogretmen' sınıfı 'alt sınıf (child class)'** olmaktadır." ] }, { "cell_type": "markdown", "id": "8b64be9b-5978-4393-b67f-62111cb97692", "metadata": {}, "source": [ "## Nesne (Object)\n", "Belirli bir sınıftan türetilen, kendisine has veri türleri ve değerleri olan, bu değerler doğrultusunda istenen davranışları sergileyen varlıklardır. Bir nesne üretmek için değişken tanımlar gibi `nesne = sinif_adi()` ifadesini yazmanız yeterlidir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "bcd9d7aa-5625-40ea-bd6d-495f742ea58e", "metadata": {}, "outputs": [], "source": [ "class birey(): #class'ı oluşturduk\n", " isim = \"\"\n", " tcNo = 0\n", " yas = 0\n", " cins = \"\"\n", " #metotlar\n", " #metotlar\n", "\n", "#bir nesne (object) oluşturalım\n", "nesne = birey() #bir nesne oluşturduk. Bu nesne 'birey' sınıfının niteliklerine sahip oldu (devraldı) ve metotlarını gerçekleştirebilir.\n", "print(nesne) #print ile nesnemizin 'ram belleğimizdeki' adresi görüntülenir. eğer nesnemize ait nitelikleri görmek istiyorsak:\n", "print(nesne.isim) #veya\n", "print(nesne.tcNo) #şeklinde yazmak gerekir" ] }, { "cell_type": "code", "execution_count": null, "id": "2b71b522-17ad-496e-9c1b-46e1856edc04", "metadata": {}, "outputs": [], "source": [ "class birey(): #class'ı oluşturduk\n", " isim = \"\"\n", " tcNo = 0\n", " yas = 0\n", " cins = \"\"\n", " #metotlar\n", "\n", "#bir nesne (object) oluşturalım\n", "nesne1 = birey() #bir nesne oluşturduk.Bu nesne 'birey' sınıfının niteliklerine sahip oldu (devraldı) ve metotlarını gerçekleştirebilir.\n", "nesne1.isim = \"Mehmet Akif ERSOY\"\n", "nesne1.tcNo = 12345679800\n", "nesne1.yas = 14\n", "nesne1.cins = \"E\"" ] }, { "cell_type": "markdown", "id": "6dfce8f1-fafb-428a-a19a-47f68e46de43", "metadata": {}, "source": [ "## Metot (Method)\n", "Bir sınıfa ait nesnenin bazı işlevlere sahip olması gerekir ki bunlara metot denir. Yani bir nesnenin gerçekleştirebileceği sınıfına ait fonksiyonlar metottur. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "cb5bc7da-9a2e-4db0-a461-33d5b37a60aa", "metadata": {}, "outputs": [], "source": [ "#bir class ve class'a ait nitelikler (attributes) ve metotlar (methods) oluşturalım\n", "class birey(): #class'ı oluşturduk\n", " #nitelikleri oluşturuyoruz\n", " isim = \"\"\n", " tcNo = 0\n", " yas = 0\n", " cins = \"\"\n", " #metot oluşturalım\n", " def bireyKonus(self): #Buradaki 'self' 'kendisi' demektir. Hangi nesne çağrıldıysa onun 'kendini' göstermesini istiyoruz.\n", " print(f'Ben {self.isim}. TC Numaram {self.tcNo}. Yaşım {self.yas}. Cinsiyetim {self.cins}.')\n", " \n", "#ilk nesnemizi oluşturalım\n", "birey1 = birey()\n", "\n", "#ilk nesnemizin niteliklerini belirleyelim\n", "birey1.isim = \"Mehmet Akif ERSOY\"\n", "birey1.tcNo = 12345678900\n", "birey1.yas = 14\n", "birey1.cins = \"E\"\n", "\n", "#ilk nesnemizde metotları kullanalım\n", "birey1.bireyKonus()" ] }, { "cell_type": "markdown", "id": "27e4108e-5e14-4558-98f4-172486bed4a4", "metadata": {}, "source": [ "Yukarıdaki yöntem **ilkel ve 'class' felsefesine aykırı bir kullanım** ama 'class' yapısını anlamak için anlaşılabilir bir örnek.
\n", "Bu **ilkel ve işleri zorlaştıran mantıkla 'class' yapıları kullanılmaz**. Nesnenin oluştuğu sınıfa ait olan nitelikleri otomatik çalışan (çağrılmadan kendi kendine çalışan) metotlarla işlenebilir. Bunun için genel olarak iki tür metot kullanılır; YAPICI ve YIKICI metotlar.\n", "- **Yapıcı Metot (`__init__`):** Bir nesne **oluşturulduğu anda** (`ogrenci1=ogrenci()`) otomatik çalışan metottur. Genellikle sınıfa ait oluşturulan nesnelerin niteliklerine değer atadığımız işlevdir. Python için bu işlev **'`__init__()`'** metodudur.\n", "

Önceki örnekte yazılan ilkel class yapısını yapıcı metot yöntemiyle aşağıdaki gibi felsefesine uygun ifadelendirelim." ] }, { "cell_type": "code", "execution_count": null, "id": "133c616a-bc00-4878-aad8-b8fa160589cc", "metadata": {}, "outputs": [], "source": [ "# yapıcı metotla nesne oluşturma\n", "class birey(): #class'ı oluşturduk\n", " def __init__(self,isim,tcNo,yas,cins): # yapıcı metot oluşturalım\n", " # zarif ifade ile\n", " self.isim, self.tcNo, self.yas, self.cins = isim, tcNo, yas, cins\n", " print(\"Nesne Oluşturma Başarılı! Nesnenin RAM Bellek'teki Adresi: \",self)\n", " def bireyKonus(self): #Buradaki 'self' 'kendisi' demektir. Hangi nesne çağrıldıysa onun 'kendini' göstermesini istiyoruz.\n", " print(f'Ben {self.isim}. TC Numaram {self.tcNo}. Yaşım {self.yas}. Cinsiyetim {self.cins}.')\n", "\n", "#nesnemizi oluşturalım ve yapıcı metot sayesinde niteliklerini atayalım\n", "birey1 = birey(\"Mehmet Akif ERSOY\",12345678900,14,\"Erkek\")\n", "#nesnemizde metotları kullanalım\n", "birey1.bireyKonus()" ] }, { "cell_type": "markdown", "id": "c9ff5f35-f194-49bd-b0d3-57139d29ceb5", "metadata": {}, "source": [ "- **Yıkıcı Metot (`__del__`):** Bir nesne **silindiği anda** (`del ogrenci1`) otomatik çalışan metottur. Genellikle sınıfa ait nesnenin tüm nitelik vb. değerlerinin silinmesi için kullanılan işlevdir. Ama şunu ifade etmek gerekir ki Python'da '**Garbage Collector**' vardır. Yani çöp temizleyicisi demektir ve bir değişken/nesne silinince veya aynı isimde yeni bir değişken/nesne oluşturulduğunda otomatik olarak eskisini RAM'den temizler ve belleğimizde boşuna yer kaplamaz. Bu özellik her programlama dilinde yoktur. Bu sebeple nesne veya veriyi `del` ile sildikten sonra onun bellekte kapladığı alanı da boşaltmanız gerekir. Bu metot esasında bu işlem için kullanılır ve **Python'da 'Garbage Collector' özelliği olduğu için yıkıcı metot nadiren kullanılır.** Fakat örneklendirelim." ] }, { "cell_type": "code", "execution_count": null, "id": "83f2842d-8ecd-4b87-be31-0a66f7b3392e", "metadata": {}, "outputs": [], "source": [ "# yıkıcı metotla nesne yok etme\n", "class birey():\n", " def __init__(self,isim,tcNo,yas,cins):\n", " self.isim, self.tcNo, self.yas, self.cins = isim, tcNo, yas, cins\n", " print(\"Nesne Oluşturma Başarılı! RAM Bellekteki Adresi: \",self,sep=\"\\n\")\n", " def __del__(self): #yıkıcı metot 'del' komutu ile otomatik çalışır.\n", " print(\"Nesne Silme Başarılı! Boşaltılan RAM Bellek Adresi: \",self,sep=\"\\n\")\n", "\n", "birey1 = birey(\"Mehmet Akif ERSOY\",12345678900,14,\"Erkek\")\n", "#nesnemizi yıkıcı metot ile silelim\n", "del birey1" ] }, { "cell_type": "markdown", "id": "fd4f25b6-be0d-4777-9700-5542ad297cb0", "metadata": {}, "source": [ "Yukarıdaki örnekten Python'un Garbage Collector'unu anlamak için şunu yapabilirsiniz. Koddan en son satırdaki `del birey1` deyimini kaldırınız. Ardından aynı kodu birkaç kez çalıştırınız. İlk çalıştırma haricindeki tüm çalıştırmalarda `__del__` metodunun çalıştığını göreceksiniz. `del birey1` yazmadığınız halde neden metot çalıştı diye merak ediyor olabilirsiniz. Açıklaması şöyle **birey1** nesnesi siz kodu ilk çalıştırdığınızda RAM Bellekte adresini aldı. Aynı kodu tekrar çalıştırdığınızda RAM Bellek'te zaten ***birey1*** için yer ayrılmış olduğu için Python 'Garbage Collector' özelliği ile aynı isimdeki değişken için önceden ayrılan bu belleği boşaltmak için kendisi otomatik olarak yıkıcı metodu kullanıyor. Çünkü önceki çalıştırmada değişkene ayrılan bellek adresi aynı değişkene yeniden değer atanması (çalıştırılması) sebebiyle kullanılmayacak ve boşuna RAM Bellekte yer kaplayacak. Eğer her çalıştırmada farklı bir nesne adı girerseniz (örneğin ***birey2*** veya ***birey3*** olarak) 'Garbage Collector' yıkıcı metodu çağırmaz ve sadece nesne oluştu mesajı alırsınız." ] }, { "cell_type": "markdown", "id": "4a9698df-4920-4952-87d3-4b0af3ff6751", "metadata": {}, "source": [ "## Kalıtım - Miras (Inheritance)\n", "Sınıf yapısını ilk anlattığımız örnekte sınıflardan alt sınıflar türetmiştik. Örnek olarak birey-öğrenci-öğretmen sınıfları oluşturmuştuk ve öğrenci ile öğretmen sınıfını 'birey' sınıfından `class ogrenci(birey):` ve `class ogretmen(birey):` ifadeleri ile türetmiştik. Bu örnekte birey üst sınıf ondan türetilenler onun alt sınıfı olmuştu.
\n", "Python'da bir sınıftan (üst sınıf) kalıtım ile başka bir sınıf (alt sınıf) türettiğiniz zaman, **alt sınıftan oluşturulan nesne üst sınıfa ait nitelikleri ve metodları miras alır, yani alt sınıftan bir nesnede üst sınıfa ait nitelik ve metotları kullanabiliriz.**" ] }, { "cell_type": "code", "execution_count": null, "id": "f100481e-8f58-41a1-9223-b52dd6d1116e", "metadata": {}, "outputs": [], "source": [ "# KALITIM - MİRAS Örneği\n", "class birey(): #bir sınıf oluşturduk\n", " def __init__(self,isim,tcNo,yas,cins):\n", " self.isim, self.tcNo, self.yas, self.cins = isim, tcNo, yas, cins\n", " def bireyKonus(self): #Buradaki 'self' 'kendisi' demektir. Hangi nesne çağrıldıysa onun 'kendini' göstermesini istiyoruz.\n", " print(f'Ben {self.isim}. TC Numaram {self.tcNo}. Yaşım {self.yas}. Cinsiyetim {self.cins}.')\n", "class ogrenci(birey): # birey sınıfından yeni alt sınıf türettik\n", " def __init__(self,isim,tcNo,yas,cins,okul,ogrNo,seviye,sube):\n", " # ilk 4 değişken birey sınıfından KALITIM - MİRAS alındığı için kodu tekrar etmeyip birey'in init'ine gönderiyoruz\n", " birey.__init__(self,isim,tcNo,yas,cins)\n", " #yukarıda yazdığımız birey.__init__(self,isim,tcNo,yas,cins) ifadesi sabit olarak 'birey' sınıfına gönderme yapmaktadır.\n", " #fakat programcı dinamik bir şekilde hangi üst sınıf ise adını yazmadan göndermesi daha zariftir.\n", " #bunun için super() fonksiyonu kullanılır. Örnek:\n", " # super().__init__(isim,tcNo,yas,cins) yazılabilir.\n", " \n", " self.okul, self.ogrNo, self.seviye, self.sube = okul, ogrNo, seviye, sube #ogrenci sınıfına ait nitelikleri burada girdik.\n", " def ogrenciKonus(self):\n", " print(f'Sınıfım {self.seviye}-{self.sube}.')\n", "\n", "#nesnemizi oluşturalım\n", "ogrenci1 = ogrenci(\"Mehmet Akif ERSOY\",12345678900,14,\"Erkek\",\"BİLSEM\",355,7,\"A\")\n", "\n", "#nesnemizin kendi sınıfından ve üst sınıfından kalıtım ile aldığı NİTELİKLERE erişelim.\n", "print(ogrenci1.tcNo) #üst sınıfından nitelik\n", "print(ogrenci1.ogrNo) #kendi sınıfından nitelik\n", "\n", "#nesnemizin kendi sınıfından ve üst sınıfından kalıtım ile aldığı METOTLARA erişelim.\n", "ogrenci1.bireyKonus() #üst sınıfından metot\n", "ogrenci1.ogrenciKonus() #kendi sınıfından metot" ] }, { "cell_type": "markdown", "id": "eae94cc4-8f4d-4847-b483-af922a5d1370", "metadata": {}, "source": [ "Kalıtım (Miras) özelliği yapısı sayesinde bir sınıfa yeni özellik eklemek istediğimizde sıfırdan bir sınıf oluşturmamıza gerek kalmaz. Böylece üst sınıfın metotlarını veya niteliklerini türettiğimiz sınıfta (alt sınıf) yeninden yazmayız, üst sınıftan kalıtım ile erişerek kullanırız." ] }, { "cell_type": "markdown", "id": "c3f47326-ae55-45f8-ac54-0084efdeb363", "metadata": {}, "source": [ "## Kapsülleme (Encapsulation)\n", "Kapsülleme bir sınıfa ait niteliklerin veya metotların **erişimine kısıtlama getirmedir**. Bazı nitelik veya metotlara erişimi kısıtlamak güvenlik açısından gerekli olabilir. Bir programlama dilinde niteliği veya metodu 'Erişim Belirleyiciler (Acces Modifiers)' ile kapsülleriz. Erişim belirleyiciler:
\n", "- **Açık (Public):** 'Açık' ilan edilen bir sınıfın öğelerine teorik olarak **programın herhangi bir bölümünden kolayca erişilebilir**. Şimdiye kadar kullandığımız erişim tipi hep 'Açık' idi. Bir niteliğe veya metoda herhangi bir ön ek getirilmezse (Örnek: `self.isim`) 'açık' ilan edilmiş olur. Sınıfın öğeleri varsayılan olarak herkese açıktır." ] }, { "cell_type": "code", "execution_count": null, "id": "13cd8c4e-68ee-494a-9079-3ddd73b95b8d", "metadata": {}, "outputs": [], "source": [ "# Açık (Public): Öğeler (nitelik, metot) için erişim belirleyicisi (alt çizgi) yok.\n", "class calisan():\n", " def __init__(self,sicilNo,isim,maas):\n", " self.sicilNo, self.isim, self.maas = sicilNo, isim, maas\n", " def goruntule(self):\n", " print(f'Sicil No: {self.sicilNo}. İsim: {self.isim}. Maaş: {self.maas}.')\n", "\n", "#nesnemizi oluşturalım ve niteliklerini atayalım\n", "calisan1 = calisan(102,\"Ahmet ALINTERİ\",9500)\n", "\n", "# sınıfa ait metotlara ve niteliklere DIŞARIDAN erişebiliyoruz.\n", "calisan1.goruntule()\n", "\n", "# sınıfa ait nitelikleri DIŞARIDAN değiştirebiliyoruz.\n", "calisan1.maas = 13500\n", "print(\"DIŞARDAN DEĞİŞİM SONRASI: \")\n", "calisan1.goruntule()" ] }, { "cell_type": "markdown", "id": "a356410e-fe50-4595-ad0b-6f784e0e1635", "metadata": {}, "source": [ "- **Korumalı (Protected):** 'Korumalı' olarak bildirilen bir sınıfın öğelerine teorik olarak **yalnızca sınıfın içinden veya ondan türetilmiş sınıfların içinden (alt sınıflardan) erişebilir**. Python'da sınıfın öğelerine ön ek olarak tek bir alt çizgi `_` (Örnek: `self._isim`) erişim belirleyicisi eklenerek öğe 'korumalı' olarak bildirilir.

\n", "'Korumalı' yapısının mantığı yukarıda ifade ettiğimiz şekildedir ve buna önem veren dillerde bu mantıkla kullanılır. Fakat Python dilini yazan Guido van ROSSUM ***\"Eğer programcının ihtiyacı varsa programdaki tüm öğelere erişebilmelidir.\"*** fikrini savunduğu için **bu erişim belirleyicisi Python'da işlevini yerine getirmez.** Fakat deyimi mevcuttur. Kullanıma açık olmasının sebebi, programcı bir öğeyi korumalı ilan ederek (önek olarak tek çizgi getirerek) kodun sonradan düzenlenmesi veya bakımlarında o öğeye dışardan erişmememiz gerektiğini bize ilan etmiş olur." ] }, { "cell_type": "code", "execution_count": null, "id": "9d2346eb-3b9d-4409-9af7-411838894dae", "metadata": {}, "outputs": [], "source": [ "# Korumalı (Protected): Öğeler (nitelik, metot) için erişim belirleyicisi tek alt çizgi var.\n", "class havaAraci():\n", " def __init__(self,uretici,model,seriNo):\n", " self.uretici, self.model, self._seriNo = uretici, model, seriNo # seriNo niteliğini korumalı ilan ettik.\n", " def _goruntule(self): # goruntule metodunu korumalı ilan ettik.\n", " print(f'Üretici: {self.uretici}. Model: {self.model}. Seri No: {self._seriNo}.')\n", "class siha(havaAraci):\n", " def __init__(self,uretici,model,seriNo,muhimmat):\n", " super().__init__(uretici,model,seriNo)\n", " self._muhimmat = muhimmat # muhimmat niteliğini korumalı ilan ettik.\n", " def tamOzellik(self):\n", " self._goruntule()\n", " print(f'Muhimmat: {self._muhimmat}.')\n", "\n", "#nesnemizi oluşturalım ve niteliklerini atayalım\n", "h1 = siha(\"TUSAŞ\",\"Aksungur\",\"TR1923-1\",6)\n", "\n", "# Normalde aşağıdaki kodlarla dışarıdan bu bilgilere erişememem gerekirken önüne tek alt çizgi konulunca erişilebiliyor.\n", "# Yani python'da 'korumalı' sınıfının öğelerine dışarıdan da erişilebiliyor ve değiştirilebiliyor. Teorik olanın uygulaması yok.\n", "print(h1._seriNo)\n", "print(h1._muhimmat)\n", "h1._goruntule()\n", "\n", "# korumalı ilan edilenler dışarıdan değiştiriledebilir.\n", "h1._seriNo = \"TR2023-100\"\n", "h1._muhimmat = 18\n", "print(h1._seriNo)\n", "print(h1._muhimmat)\n", "h1._goruntule()" ] }, { "cell_type": "markdown", "id": "8cfdaba1-baff-4484-87cd-9c0777af3d9b", "metadata": {}, "source": [ "- **Özel (Private):** 'Özel' olarak bildirilen bir sınıfın öğelerine **yalnızca kendi sınıfının içinden erişilebilir**. Fakat Python'da bu işlev tam olarak **çalışmaz**. Özel ilan ettiğiniz öğe 'nitelik' ise sınıfın içinden veya dışından erişebilir ve onu değiştirebilirsiniz. Fakat özel ilan ettiğiniz öğe 'metot' ise sadece sınıf içinden erişebilirsiniz. Bu sebeple ben Python'daki bu erişim belirleyicisinin adını **Kısmen Özel** olarak ilan ediyorum :).
\n", "Pyhton'da sınıfın öğelerinin önüne **çift alt çizgi** `__` (Örnek: `self.__isim`) erişim belirleyicisi eklenerek öğe 'özel' olarak bildirilir. Teorik olarak en güvenli erişim belirleyicisidir." ] }, { "cell_type": "code", "execution_count": null, "id": "750b7559-8511-432b-8b69-847d908b7434", "metadata": {}, "outputs": [], "source": [ "# Özel (Private): Öğeler (nitelik, metot) için erişim belirleyicisi çift alt çizgi var.\n", "class musteri():\n", " def __init__(self,tcNo,isim,sube,para):\n", " self.tcNo, self.isim, self.sube, self.__para = tcNo, isim, sube, para # para niteliğini özel ilan ettik. Dışarıdan erişilemez.\n", " print(\"Müşteri Oluşturma Başarılı! Müşteri Tipi:\",type(self).__name__)\n", " def __goruntule(self): # goruntule metodunu özel ilan ettik. Dışarıdan erişilemez.\n", " print(f'TC No: {self.tcNo}. İsim: {self.isim}. Şube: {self.sube}. Para: {self.__para}.')\n", " def paraEkle(self,miktar):\n", " self.__para += miktar # özel ilan edilen 'para' niteliğine içeriden erişilebilir.\n", " print(\"Para Ekleme Başarılı!\")\n", " self.__goruntule() # özel ilan edilen 'goruntule' metoduna içeriden erişilebilir.\n", "\n", "#nesnemizi oluşturalım ve niteliklerini atayalım\n", "m1 = musteri(123,\"Asya TOPRAK\",\"Üsküdar\",1260)\n", "\n", "#nesnemizin gizli ilan edilen öğelerine dışardan erişmeye çalışalım.\n", "print(m1.__para) # bu satırdan hata alacaksınız. Çalıştırıp görün ve bu satırı silin.\n", "m1.__goruntule() # bu satırdan da hata alacaksınız. Çalıştırıp görün ve bu satırı da silin.\n", "\n", "#müşterimize açık ilan edilen paraEkle() metodu ile para ekleyelim ve sonucu görelim.\n", "# m1.paraEkle(4000) # satırın başındaki hashtagi silerek çalıştırın. Dışardan erişemediğimiz öğelere içeriden erişebilir olduğunu görün." ] }, { "cell_type": "markdown", "id": "3e422b7e-5e63-45c1-80ce-130a5793c01f", "metadata": {}, "source": [ "'Korumalı' sınıfını anlatırken ifade ettiğimiz ___\"Guido van ROSSUM ***\" Eğer programcının ihtiyacı varsa programdaki tüm öğelere erişebilmelidir.\"*** fikrini savunduğu için **bu erişim belirleyicisi Python'da işlevini yerine getirmez.**\"___ fikri üzere 'Özel' olarak ilan ettiğimiz öğelere de bir şekilde erişmek mümkünüdür. Python dil yapısında herşey bir nesnedir çünkü. Bu durumda her nesnenin ardından bir sınıf eki vardır. Yani `nesne._sınıfAdı__özelÖğe` ile gizli öğelere de erişebilir ve değişebiliriz. Örnek :" ] }, { "cell_type": "code", "execution_count": null, "id": "bbb9e43e-063f-44c7-8529-c028a273d402", "metadata": {}, "outputs": [], "source": [ "# Özel (Private): Öğeler (nitelik, metot) için erişim belirleyicisi çift alt çizgi var.\n", "class musteri():\n", " def __init__(self,tcNo,isim,sube,para):\n", " self.tcNo, self.isim, self.sube, self.__para = tcNo, isim, sube, para # para niteliğini özel ilan ettik. Dışarıdan erişilemez.\n", " print(\"Müşteri Oluşturma Başarılı! Müşteri Tipi:\",type(self).__name__)\n", " def __goruntule(self): # goruntule metodunu özel ilan ettik. Dışarıdan erişilemez.\n", " print(f'TC No: {self.tcNo}. İsim: {self.isim}. Şube: {self.sube}. Para: {self.__para}.')\n", " def paraEkle(self,miktar):\n", " self.__para += miktar # özel ilan edilen 'para' niteliğine içeriden erişilebilir.\n", " print(\"Para Ekleme Başarılı!\")\n", " self.__goruntule() # özel ilan edilen 'goruntule' metoduna içeriden erişilebilir.\n", "\n", "#nesnemizi oluşturalım ve niteliklerini atayalım\n", "m1 = musteri(123,\"Asya TOPRAK\",\"Üsküdar\",1260)\n", "\n", "#nesnemizin gizli ilan edilen öğelerine dışardan isim bulanıklaştırmayıerişmeye çalışalım.\n", "m1._musteri__goruntule()" ] }, { "cell_type": "markdown", "id": "a33b7b65-0778-4ed3-80fb-1c63b103fca5", "metadata": {}, "source": [ "Bunu ifade etmemin sebebi eğer gerçekten gizli olmasını istediğiniz öğeler varsa Python bunu karşılamamaktadır. Guido van ROSSUM bunu şöyle açıklamıştır: (Slashdot.org, 2013)
\n", "- Python bir 'Skunkworks' projesidir.
___\"Skunkwork Proje: Radikal inovasyon adına, nispeten küçük ve gevşek yapılı bir grup araştırmacı veya geliştirici tarafından geliştirilen, genellikle çok büyük bir özerkliğe sahip bir proje.\"___\n", "- \"Kodun derlenme esnasında tip kontrolü yapmak kısıtlayıcı ve yavaşlatıcıdır. Bunu yapmamak ise özgürlük ve hız sağlar.\"\n", "- \"Python'u geliştirdiğim dönemlerde benim ihtiyaç duymayacağım ve acil olmayan özelliklere odaklanmadım. Hızlı sonuç almak istedim.\"\n", "- \"Bu kısıtlamalar çok fazla işlem yürütmesine sebep olurlar, ben sadece kolay bir dil istedim.\"\n", "- \"Esasen bir Nesne Yönelimli Programlama hayranı değilim, zaman içinde işler o yönde gittiği için modern Python'da kazara var oldular.\"\n", "\n", "Özel öğlere erişimle ilgili daha detaylı bilgi için 'Python İsim Bulandırma (Pyhton Name Mangling)' özelliğini araştırabilirsiniz.." ] }, { "cell_type": "markdown", "id": "61cf643e-06c8-43e3-9844-beefc1a53d08", "metadata": {}, "source": [ "## Çok Biçimlilik (Polymorphism)\n", "Çok biçimlilik ***aynı isimdeki*** bir işlevin (metot veya fonksiyon) uygulandığı öğeye göre farklı işlem yapmasına denir. Temel olarak 'Farklı İşlem' dediğimiz şey işlevde kullanılan parametrelerin veri türleri ve argüman sayısıdır.
\n", "Örnekleyecek olursak şimdiye kadar birçok kez kullanmış olduğumuz `len()` fonksiyonunu ele alalım. `len()` fonksiyonuna karakter dizisi (`str`) gönderilirse onun karakter sayısını, liste (`list`) gönderilirse onun eleman sayısını, sözlük (`dict`) gönderilirse onun anahtar değeri sayısını bize verir. Yani ***aynı isimdeki*** fonksiyon, parametrenin veri tipine göre çok biçimli şekilde işlem yapar. Peki bu nasıl yapılıyor? Şu şekilde:
" ] }, { "cell_type": "code", "execution_count": null, "id": "58b71789-bab2-47a7-9912-43f4202601c2", "metadata": {}, "outputs": [], "source": [ "class kopek():\n", " def __init__(self,tur):\n", " self.tur = tur\n", " def bilgi(self):\n", " print(\"Ben\",type(self).__name__,\"sınıfında,\",self.tur,\"türündeyim.\")\n", " def sesVer(self):\n", " print(\"Hav hav!\")\n", "\n", "class kedi():\n", " def __init__(self,tur):\n", " self.tur = tur\n", " def bilgi(self):\n", " print(\"Ben\",type(self).__name__,\"sınıfında,\",self.tur,\"türündeyim.\")\n", " def sesVer(self):\n", " print(\"Miyav!\")\n", " \n", "# Yukarıdaki sınıflarda aynı isimde farklı işleve sahip metodlarımız mevcut.\n", "# Şimdi birkaç tane hayvan oluşturalım.\n", "hayvanlar = [kopek(\"Kurt Köpeği\"),kopek(\"Kangal\"),kedi(\"Ankara Kedisi\"),kedi(\"Van Kedisi\")]\n", "\n", "#Şimdi farklı sınıf olmasına rağmen her sınıfta aynı isimde metot olduğu için nesneyle bağlantılı olarak kullanır.\n", "for hayvan in hayvanlar:\n", " hayvan.bilgi()\n", " hayvan.sesVer()" ] }, { "cell_type": "markdown", "id": "834d0202-60db-488a-9345-5cac50ced2de", "metadata": {}, "source": [ "'Üst Sınıf' - 'Alt Sınıf' ilişkisinin olduğu yani 'Kalıtım-Miras' yoluyla oluşturulan sınıflarda çok biçimlilik nasıl olur?
\n", "Kalıtım-Miras konusunu anlatırken ___\"... alt sınıflar üst sınıfların niteliklerini ve metotlarını miras alır, yani alt sınıftan bir nesnede üst sınıfa ait metotları kullanabiliriz.\"___ diye ifade etmiştik. Peki her iki sınıfta da aynı metot var ise Python hangisini işletir? Tabiki de ait olduğu birincil sınıfın metodunu kullanır. Üst sınıfında bulunan aynı isimdeki metodu 'Geçersiz Kılar (Method Overriding)'." ] }, { "cell_type": "code", "execution_count": null, "id": "7e64cce4-f720-4e54-876d-c690f2a5c232", "metadata": {}, "outputs": [], "source": [ "class hayvan():\n", " def __init__(self,tur):\n", " self.tur = tur\n", " print(\"Nesne Oluşturma Başarılı!: \",self.tur)\n", " def bilgi(self): # Bu metot alt sınıfta olmadığı için alt sınıftaki nesne tarafından kalıtım-miras alınır.\n", " print(\"Ben\",type(self).__name__,\"sınıfında,\",self.tur,\"türündeyim.\") # Bu metodun geçersiz alt sınıfta geçersiz kılınmamıştır.\n", " def sesVer(self): # Bu metot alt sınıfta da olduğu için, eğer nesne birincil olarak alt sınıfa aitse 'GEÇERSİZ KILINIR'\n", " print(\"Hayvanların çeşitli sesleri olur.\") # Bu metot geçersiz kılınacağı için ekrana hiç basılmayacak.\n", "\n", "class kopek(hayvan):\n", " def __init__(self,tur):\n", " super().__init__(tur)\n", " def sesVer(self): # Üst sınıftaki metodu geçersiz kılan metot.\n", " print(\"Hav hav!\")\n", "\n", "class kedi(hayvan):\n", " def __init__(self,tur):\n", " super().__init__(tur)\n", " def sesVer(self): # Üst sınıftaki metodu geçersiz kılan metot.\n", " print(\"Miyav!\")\n", " \n", "# Yukarıdaki sınıflarda aynı isimde farklı işleve sahip metodlarımız mevcut.\n", "# Şimdi birkaç tane hayvan oluşturalım.\n", "hayvanlar = [kopek(\"Kurt Köpeği\"),kopek(\"Kangal\"),kedi(\"Ankara Kedisi\"),kedi(\"Van Kedisi\")]\n", "\n", "#Şimdi farklı sınıf olmasına rağmen her sınıfta aynı isimde metot olduğu için nesneyle bağlantılı olarak kullanır.\n", "for eleman in hayvanlar:\n", " eleman.bilgi()\n", " eleman.sesVer()" ] }, { "cell_type": "markdown", "id": "5b330b5a-fcb0-4b81-bdea-da568eed76a1", "metadata": {}, "source": [ "## Soyutlama (Abstraction)\n", "Soyutlama, fonksiyonların veya metotların nasıl çalıştığını öğrenmek yerine yalnızca girdi ve çıktılarına odaklanarak kodun daha sade ve anlaşılır olmasını sağlamaktır. Örneğin televizyon kumandasındaki düğmeleri kullanırsınız ama arkasındaki işlemlerin nasıl gerçekleştiğini görmezsiniz. Daha farklı bir örnekle, araç kullanmanız için size 'hız göstergesi', direskiyon', 'vites kolu', 'gaz pedalı', 'fren', 'debriyaj' gibi girdi-çıktı birimleri verilmiştir. Size düşen bu birimleri kullanarak araç sürmektir. Soyutlama tüm sınıfların veya metodların akılda tutulamayacağı büyük projelerde, eklenti yüklenebilen uygulamalarda, API oluşturmada vb. kullanılır. **Soyut sınıf; somut işlevi olmayan bir sınıftır ve ondan oluşacak sınıfların 'planı'dır. Soyut sınıflar, soyut metodlar içerebilir.**

\n", "**Soyutlama Python'da gömülü olarak mevcut değildir, kullanmak için 'abc' kütüphanesinden `ABC` ve `abstractmethod` yapılarının içeri aktarılması gerekir.** Bunun için `from abc import ABC, abstractmethod` veya `import abc` ile içeri aktarılır. İçeri aktarılan `ABC` soyutlama yapılmak istenen sınıfların üst sınıfı olarak kullanılır. `abstractmethod` ise metodlar için ***dekoratör*** olarak kullanılır. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "40ea6709-d324-4222-8fb3-a91d7ecd97d2", "metadata": {}, "outputs": [], "source": [ "from abc import ABC, abstractmethod\n", "class ogrenci(ABC): #soyut temelli 'ogrenci' sınıfı\n", " def __init__(self,isim,ogrNo):\n", " self.isim, self.ogrNo = isim, ogrNo\n", " \n", " @abstractmethod #dekoratör ile metodu soyutlaştırdık. 'Soyut Metot'\n", " def konus(self):\n", " print(f\"Ben: {self.isim}, Okul Numaram: {self.ogrNo}\")\n", " \n", "ogr = ogrenci(\"Nazım\",123) # Soyut sınıftan bir nesne somutlaştıramazsınız. Hata alırsınız.\n", "ogr.soyle() # Soyut sınıfın soyut metodunu, alt sınıflarından eğer aynı isimde bir metot yoksa somutlaştıramazsınız. Hata alırsınız." ] }, { "cell_type": "code", "execution_count": null, "id": "a0dbe250-a55b-4931-8c61-7de38496ae71", "metadata": {}, "outputs": [], "source": [ "from abc import ABC, abstractmethod\n", "from random import randint\n", "\n", "class oyuncu(ABC): #soyut temelli bir sınıf\n", " def __init__(self,isim,takim,can): # Soyut sınıfta Normal metot.\n", " self.isim, self.takim, self.can = isim, takim, can\n", " print(\"Nesne Oluşturuldu: \",self.isim)\n", " \n", " @abstractmethod #dekoratör ile metodu soyutlaştırdık.\n", " def darbe(self,can): # Soyut metot. Kalıtım-miras alınsa bile alt sınıfta bu metot yoksa da üst sınıftakine ERİŞEMEZ.\n", " self.can -= randint(1,70)\n", " print(\"Darbe aldı! Kalan Can:\",self.can)\n", " \n", " def canEkle(self): # Soyut sınıfta Normal metot. Kalıtım-miras alınınca alt sınıfta bu metot olmasa da üst sınıftakine erişir.\n", " self.can += randint(1,20)\n", " print(\"Can Eklendi! Mevcut Can:\",self.can)\n", " \n", "class antiteror(oyuncu):\n", " def __init__(self,isim,takim=\"AT\",can=100): #can ve takim'i argüman yaparak sabit atadık.\n", " super().__init__(isim,takim,can)\n", " def darbe(self):\n", " super().darbe(self)\n", "\n", "p1 = antiteror(\"Mete Han\")\n", "p1.darbe() # 'darbe()' soyut sınıfta 'SOYUT' bir metot olduğu için alt sınıfta aynı metot olmazsa üst sınıftaki metot miras alınmaz ve çalışmaz.\n", "p1.canEkle() # 'canEkle()' soyut sınıfta 'NORMAL' bir metot olduğu için alt sınıfta olmasa da üst sınıftan miras alır ve çalışır." ] }, { "cell_type": "markdown", "id": "6ca807d5-e14c-4778-a1b0-d5456ec3391b", "metadata": {}, "source": [ "Yukarıdaki örnekten de göreceğiniz gibi, soyut sınıf oluşturmanın en temel farkı alt sınıfın üst sınıftaki 'soyut' metodu miras ile kalıtım alarak gerçekleştirememesi, **yani somutlaştıramamasıdır.** Fakat aynı isimdeki metot alt sınıfta mevcut ise soyut sınıftaki soyut metot çağrılabilir.
\n", "Ayrıca soyut sınıftaki işlemler alt sınıftaki işlemlerin bir şablonudur. Bu sebeple yeni oyuncu türleri türetsek de aynı işlemler için tekrar kod yazmaya gerek yok. Herhangi bir değişiklik olduğunda ilgili tüm sınıflarda bu kodları değişmek yerine soyut sınıfta değişmek yeterli gelir." ] }, { "cell_type": "markdown", "id": "c1e8d64c-42ab-4bb7-b4fd-902d30659cdd", "metadata": {}, "source": [ "# Burası düzenlenecek !! İleri İşlemler (Lambda, Dekoratörler, Map(), Filter())" ] }, { "cell_type": "markdown", "id": "0a7b101f-f219-4c07-a71d-da4bf2778242", "metadata": {}, "source": [ "## Lambda Deyimi\n", "Python'da fonksiyonların bir adı olur ve onunla çağrılır. Fakat tek işleme sahip bir fonskiyona ihtiyacınız varsa `def` ve `return` ile iki satıra çıkmak yerine kompakt bir şekilde bunu halletmek daha zariftir. Ayrıca iç içe fonksiyolar yerine daha karışık olmayacak bir şekilde fonksiyon içinde fonksiyon gerekince `lambda` deyimini kullanmak da yine zarif ve kullanışlıdır. **`Lambda` deyiminde anahtar kelime 'Tek İşlemli Fonksiyon' olmasıdır.** Örneklemek gerekirse:" ] }, { "cell_type": "code", "execution_count": null, "id": "61ee205f-ac96-4b65-bff3-1162b90da564", "metadata": {}, "outputs": [], "source": [ "#bir sayının karesini lambda ile alalım\n", "karesi = lambda sayi: sayi**2\n", "print(karesi(5))" ] }, { "cell_type": "code", "execution_count": null, "id": "ce698f41-5e6f-4f86-8518-4306cd50dea8", "metadata": {}, "outputs": [], "source": [ "#bir metni tersten lambda ile tersten yazdıralım\n", "ters = lambda kelime: kelime[::-1]\n", "print(ters(\"1923\"))\n", "print(ters(\"EYİKRÜT\"))\n", "print(ters(\"TALAT\"))" ] }, { "cell_type": "code", "execution_count": null, "id": "eb9c235d-72ec-4506-900d-9ddd19f30f3f", "metadata": {}, "outputs": [], "source": [ "#bir sayıyı float yapma\n", "flt = lambda sayi: float(sayi) if str(sayi).isnumeric() else print(\"Sayıya çevrilemez!\")\n", "print(flt(6))\n", "print(flt(\"ABC\"))\n", "print(flt(\"578\"))\n", "print(flt(85.75))" ] }, { "cell_type": "markdown", "id": "f8edec61-62d5-430e-9f3e-d5acdad0385c", "metadata": {}, "source": [ "**`Lambda` fonksiyonuna anonim fonksiyon denir.**
\n", "`Lambda` deyimi eğer fonksiyon içinde kullanılırsa fonksiyonun gerektirdiği parametre gibi lambda için de ayrıca parametre girilmesi gerekir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "143a1cdb-40bb-4093-84cb-a9152b491c7a", "metadata": {}, "outputs": [], "source": [ "#fonksiyon içinde lambda\n", "def ussu(n):\n", " return lambda x : x**n\n", "print(ussu(2)(5))" ] }, { "cell_type": "markdown", "id": "a411c022-4953-448b-a892-075b67186215", "metadata": {}, "source": [ "## Dekoratörler (Bezeyici-Süsleyici) (Decorator)\n", "Dekoratörler, bir fonksiyonu başka bir fonksiyon ile giydirmek (bezemek, süslemek) veya birbirini bağlamak için kullanılır.
\n", "Yani `def topla():` isminde bir fonksiyon ile verilen sayıları toplayacağınız bir işleviniz olduğunu düşünelim. Bu toplama işleminden önce verilen değerlerin sayı olup olmadığını kontrol etmek istiyorsunuz. Bunun için de `def sayiKontrol():` isimli bir fonksiyonunuz var. `sayiKontrol()` fonksiyonu her `topla()` fonksiyonu ***'çalışmadan önce'*** çalışması gerekiyor. Dolayısıyla bunu her seferinde yazmak yerine ***işlem zamanını*** ayarlamak için dekoratör kullanabiliriz. Buna ***bir fonksiyona başka fonksiyonların işlevlerini eklemek (bezemek-süslemek-dekore etmek)*** denir. Örnek:\n" ] }, { "cell_type": "markdown", "id": "d9970ca6-bdeb-4c95-816d-8af5b77a8732", "metadata": {}, "source": [ "## Map() Fonksiyonu\n", "`map(fonksiyon,dongulenecek_veri)` olarak kullanılır ve parametre olarak aldığı fonksiyona, parametre olarak aldığı döngü oluşturulabilecek bir verinin her elemanını fonksiyona göndererek sonucu verir. Sonuç doğal olarak genellikle bir nesnedir. `list()` fonksiyonu ile listeye dönüştürülerek `print()` edilebilir. Örnek olarak:" ] }, { "cell_type": "code", "execution_count": null, "id": "450c6978-d712-47fb-ad0d-72ef33c11e9f", "metadata": {}, "outputs": [], "source": [ "# gönderilen her elemanı stringe çeviren fonksiyon\n", "elemanlar = [1,2,3,4,5,6,7,8,9,0]\n", "print(list(map(str,elemanlar)))" ] }, { "cell_type": "code", "execution_count": null, "id": "90cb2bcb-c326-4145-ab3f-fd2b1422ce7e", "metadata": {}, "outputs": [], "source": [ "# gönderilen her elemanı 2'lik sayı sisteminde yazan fonksiyon\n", "def ikili(n):\n", " return str(bin(n))[2:]\n", "print(list(map(ikili,range(1,10))))\n", "# veya\n", "print(list(map(lambda n: str(bin(n))[2:],range(1,10))))" ] }, { "cell_type": "code", "execution_count": null, "id": "912cd4be-8735-40e2-a95e-04fdb9105ad6", "metadata": {}, "outputs": [], "source": [ "# gönderilen her elemanın karesini alarak listeye dönüştüren fonksiyon\n", "print(list(map(lambda x: x**2,range(1,10))))" ] }, { "cell_type": "code", "execution_count": null, "id": "ea2f0c06-b54c-4832-ae92-98d2385e0997", "metadata": {}, "outputs": [], "source": [ "# gönderilen her elemanın büyük harf yaparak listeye dönüştüren fonksiyon\n", "s = \"tbmm\"\n", "print(list(map(lambda x: x.upper(),s)))" ] }, { "cell_type": "markdown", "id": "152caee4-1293-4244-ba61-bc631a15f48c", "metadata": {}, "source": [ "## Filter() Fonksiyonu\n", "`filter(fonksiyon,dongulenecek_veri)` olarak kullanılır ve parametre olarak aldığı döngü oluşturulabilecek bir verinin her elemanını parametre olarak aldığı fonksiyona göndererek uyanların sonucunu verir. Sonuç doğal olarak genellikle bir nesnedir. `list()` fonksiyonu ile listeye dönüştürülerek `print()` edilebilir. Örnek olarak:" ] }, { "cell_type": "code", "execution_count": null, "id": "9ebfb1a5-b881-4ffd-a15a-f962343b6904", "metadata": {}, "outputs": [], "source": [ "# gönderilen her elemanın 4'ün katı ise filtreleyen ve listeye dönüştüren fonksiyon\n", "print(list(filter(lambda x: x%4==0,range(1,41))))" ] }, { "cell_type": "code", "execution_count": null, "id": "6b96c4b4-d5dc-4334-aaaa-9678d8f7baff", "metadata": {}, "outputs": [], "source": [ "# gönderilen her elemanın eğer nümerik ise filtreleyen ve listeye dönüştüren fonksiyon\n", "liste = [1923,\"2023\",\"TÜRKİYE\",\"TFX-600\",44]\n", "print(list(filter(lambda x: str(x).isnumeric(),liste)))" ] }, { "cell_type": "code", "execution_count": null, "id": "c0551060-ca56-40eb-aca1-44d363efdb17", "metadata": {}, "outputs": [], "source": [ "# gönderilen her elemanın eğer yaşı 17'den büyük ise filtreleyen ve listeye dönüştüren fonksiyon\n", "ogrenciler = {\n", " \"Mete\":18,\n", " \"Asya\":15,\n", " \"Oğuz\":25,\n", " \"Aysu\":17\n", "}\n", "print(list(filter(lambda x: str(x) if (ogrenciler[x]>17) else None,ogrenciler)))" ] }, { "cell_type": "markdown", "id": "84eb9df3-5225-4502-a7b2-c647d3a78456", "metadata": {}, "source": [ "# Hata Yakalama (Try, Except, Finally, Assert, Raise)\n", "Python'daki hatalar üç türden olabilir. **'Sözdizimi (syntax)'** hataları, **'İstisnalar (Exceptions)'** ve programın hataları '**Bug**'. '**Bug**' olarak ifade ettiğimiz programın hataları programda herhangi bir hata bloğuna sebep olmaz ama program doğru şekilde çalışmamış olur. **'Bug'** türünden hataları bulmak için genelde programı kullananlardan 'geri bildirim (feedback)' alınır. Örneğin girilen iki sayının bölümünü bulmak için sayıları `int()` ile tam sayıya çeviriyorsanız `float()` tipinde girilen sayılar da tam sayıya çevrileceği için yanlış sonuç alırsınız fakat program herhangi bir hata yükseltmez. Yani 7/3.5 işlemi için 2.0 bulacağınıza 2.3333333333333335 sayısını elde edersiniz.

\n", "Sözdizim hataları oluştuğunda ise program tamamen durur ve kodun değiştirilmesi gerekir. Fakat 'İstisnalar' programcı tarafından programı durdurmadan akışı değiştirecek şekilde üstesinden gelinebilir. 'İstisnalar' bir sözdizim hatası değildir, programın yürütülmesi esnasında ortaya çıkan (yükseltilen) durumlardır. Örneğin iki sayıyı birbirine bölerken, bölen sayı sıfır olursa bölünemez ve bu durumdan dolayı 'Sıfıra Bölünme İstisnası' durumu yükselir. Başka bir örnekle, bir sayı (int) ve karakter dizisi (str) toplanmaya çalışılırsa 'Değer İstisnası' durumu yükselir." ] }, { "cell_type": "markdown", "id": "0391f5db-6c9e-4c91-870b-a06cdb4166e2", "metadata": {}, "source": [ "## İstisnaları Yakalama ve Düzeltme (Try Except Finally)\n", "Bazı istisnalar `try:` ve `except:` ile kontrol edilebilir. `try:` çalışma mantığı şu şekildedir. İstisna çıkması ihtimali olan kodlar yazılmadan önce başa `try:` (dene) yazılır ardından kod blokları yazılır.Bloklar bittikten sonra `except:` deyimi yazılır ve istisna çıkması durumunda çalışması istenen kod blokları yazılır. Eğer `try:` ile yazdığınız kod bloklarında bir istisna çıkmazsa program normal olarak yürütülür. Ama istisna çıkarsa programınız durdurulmaz, bunun yerine `except:` bloğu içinde yazdığınız kodlar çalışır. Yani programdaki istisnayı kontrol ederek çalışma akışını değiştirebilirsiniz. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "44154e43-928b-4826-b4c8-eaba9bcb42a4", "metadata": {}, "outputs": [], "source": [ "def islem(a,b):\n", " try:\n", " sonuc = a/b\n", " print(sonuc)\n", " except:\n", " print(\"Bir hata çıktı.\")\n", "islem(10,0)" ] }, { "cell_type": "markdown", "id": "f9c437f1-2d37-438a-8320-f309a8e8e3f5", "metadata": {}, "source": [ "Yukarıdaki örnekte gördüğümüz gibi program sonlanmadı ve bize istisnanın çıktığı durumdaki istisna bloğu olan `except:` bloğundaki kodları çalıştırdı. Fakat bu istisnayı yakalamak ve onu düzeltmek istiyorsak esasında ortaya çıkabilecek istisnaların ne olduğunu da tahmin edebilmemiz (yordayabilmemiz) gerekir. Bu sebeple istisnaların bir isimleri vardır. Bunu şu şekilde görebiliriz:" ] }, { "cell_type": "code", "execution_count": null, "id": "bbad5142-c0df-4db7-bd0e-9396c4c81bd2", "metadata": {}, "outputs": [], "source": [ "def islem(a,b):\n", " try:\n", " sonuc = a/b\n", " print(sonuc)\n", " except Exception as hata: # istisnanın türünü 'hata' isimli değişkene atadık ve hatanın ne olduğunu artık görebiliriz.\n", " print(\"Bir hata çıktı. Hata Adı:\", hata.__class__.__name__,\", Açıklaması:\",hata)\n", "islem(10,0)" ] }, { "cell_type": "markdown", "id": "f43b11e0-9a0b-45b8-92bf-d46a4c6a32ba", "metadata": {}, "source": [ "Yukarıdaki örnekte:\n", "- `islem(10,0)` için `ZeroDivisionError` istisnası alırsınız. Çünkü hiçbir sayı 0'a bölünmez\n", "- `islem(10,\"A\")` için `TypeError` istisnası alırsınız. Çünkü \"A\" harfi hiçbir sayıyı bölemez.\n", "- `islem(10,\"A\")` ve `sonuc = float(a)/float(b)` için `ValueError` istisnası alırsınız. Çünkü \"A\" harfi flolat'a çevrilemez.\n", "- `islem(10,5)` ve `sonuc = a/c` için `NameError` istisnası alırsınız. Çünkü 'c' isminde bir değişken tanımlı değil." ] }, { "cell_type": "markdown", "id": "d0d64aaa-7520-401e-9725-5fe8f5b8299c", "metadata": {}, "source": [ "`try:` , `except:` ifadeleri arasında yazılanlarda 'istisna' kontrolü yapılır. Yani `try:` dışındaki bir kod bloğu için istisna kontrolü sağlamış olamazsınız. Örnek olarak yukarıdaki kod örneğinde `islem(10,5)` yerine `issslem(10,5)` yazarsanız alacağınız `NameError` istisnası `try:` - `except:` bloğu dışında olduğu için kontrol dışı kalır. Ayrıca yapısı itibariyle her istisna da `try:` - `except:` ile kontrol edilemez. Python'daki tüm hata ve istisnalar için şuraya bakabilirsiniz: https://docs.python.org/2/library/exceptions.html#exception-hierarchy
\n", "İstisnalarda`else:` ve `finally:` deyimleri kullanılabilir. İstisna yakalamayı denedik (`try:`) ama bulunamadı ise `else:` ile akışın devamı getirilebilir veya `finally` deyimi ile hata yakalansa da yakalanmasa da yapılması istenen işlemler yazılabilir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "289d8ed0-36bd-4bc5-b2ba-2d01d9aa6b46", "metadata": {}, "outputs": [], "source": [ "try:\n", " class calisan():\n", " def __init__(self,sicilNo,isim,maas):\n", " #sicilNo'yu tamsayıya çevirdik ama gelen parametre \"A\" olduğu için ValueError hatası yükselecek\n", " self.sicilNo, self.isim, self.maas = int(sicilNo), isim, maas\n", " def goruntule(self):\n", " print(f'Sicil No: {self.sicilNo}. İsim: {self.isim}. Maaş: {self.maas}.')\n", " calisan1 = calisan(\"A\",\"Ahmet ALINTERİ\",9500)\n", "except Exception as hata:\n", " s = \"Çalışan Oluşturma Başarısız!\\nHata: \"+hata.__class__.__name__+\"\\nAçıklama: \"+str(hata)\n", "else:\n", " s = \"Çalışan Oluşturma Başarılı\"\n", " calisan1.goruntule()\n", "finally:\n", " print(s)" ] }, { "cell_type": "markdown", "id": "41ce0a2d-183e-4752-84b2-65e943de14b8", "metadata": {}, "source": [ "İstisna yakalandıktan sonra `else:` ve `finally:` ile akış değiştirilebilir ama esasen programcının programı en az hata yükseltecek şekilde tasarlaması ve ona göre ifade etmesi gerekir. Programdaki olası hata veya istisnaları önlemek esaslardan biridir. Ayrıca yakalanan istisna için çözüm varsa çözümü program tasarımında uygulaması gerekir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "021180a6-288d-42cd-bb03-7dbee49973a7", "metadata": {}, "outputs": [], "source": [ "def islem(a,b):\n", " try:\n", " sonuc = float(a)/float(b)\n", " except ValueError:\n", " print(\"Virgül-Nokta Hatası Kontrol Ediliyor...\")\n", " if \",\" in (a+b):\n", " print(\"Virgül-Nokta Hatası Bulundu!\")\n", " a=a.replace(\",\",\".\")\n", " b=b.replace(\",\",\".\")\n", " print(\"Virgül-Nokta Düzeltmesi Yapıldı!\")\n", " islem(a,b)\n", " else:\n", " print(\"Girdiğiniz elemanlardan biri sayıya çevrilemiyor.Elemanlar: \",a,\",\",b)\n", " islem(input(\"Bolunecek sayıyı giriniz: \"),input(\"Bolen sayıyı giriniz: \"))\n", " except ZeroDivisionError:\n", " print(\"Bir sayı sıfıra bölünemez.\")\n", " islem(input(\"Bolunecek sayıyı giriniz: \"),input(\"Bolen sayıyı giriniz: \"))\n", " except Exception as hata:\n", " print(\"Hata Yakalandı! Çıkan Hata: \",hata.__class__.__name__,\"Açıklaması: \",hata)\n", " else:\n", " return print(sonuc)\n", "\n", "islem(input(\"Bolunecek sayıyı giriniz: \"),input(\"Bolen sayıyı giriniz: \"))" ] }, { "cell_type": "markdown", "id": "d4f829e2-8788-471c-afc1-19dca4d8bc0e", "metadata": {}, "source": [ "## İddia Etme ve Hata Yükseltme (Assert, Raise)\n", "Programlama dillerinde `assert` yani 'iddia etme' bir hata ayıklama aracıdır. Programın yanlış çalışmasını engellemek için programcının varsayımlarını iddia etmesidir. `assert` ile bir ifadenin doğruluğu `if` gibi kontrol edilir ve eğer doğru (**True**) ise kodlar çalışmaya devam eder, eğer yanlış (**False**) ise **`AssertionError`** istisnası yükseltir ve programın akışını durdurulur. Örneğin TC Numarasını doğrulayacağız:" ] }, { "cell_type": "code", "execution_count": null, "id": "4340f982-793c-46cb-9c98-2eaae359647d", "metadata": {}, "outputs": [], "source": [ "try:\n", " def tcDogrula(tc):\n", " assert tc.isnumeric(), \"TC No Sayılardan Oluşmalıdır!\"\n", " assert tc[0]!=\"0\", \"TC No'nun İlk Hanesi '0 (Sıfır)' Olamaz.!\"\n", " assert len(tc)==11, \"TC No 11 Haneli olmak zorundadır!\"\n", " tek = sum([int(tc[i]) for i in range(0,len(tc)-2,2)]) #tek basamakları topladık\n", " cift = sum([int(tc[i]) for i in range(1,len(tc)-2,2)]) #çift basamakları topladık\n", " assert int(tc[9]) == (7*tek-cift)%10, \"Girilen TC No'nun 10.Basamağı Doğrulanamadı!\" #10.basamak algoritması\n", " assert int(tc[10]) == sum([int(tc[i]) for i in range(len(tc)-1)])%10, \"Girilen TC No'nun 11.Basamağı Doğrulanamadı!\" #11.basamak algoritması\n", " print(\"TC No Geçerli\")\n", " tcDogrula(input(\"TC No giriniz: \"))\n", "except AssertionError as hata:\n", " print(hata)" ] }, { "cell_type": "markdown", "id": "21f49966-2cbb-4558-963d-5d669a760eed", "metadata": {}, "source": [ "`assert` deyimi `try`-`except` ile kullanılmak zorunda değildir. `try`-`except`ile kullanılınca 'Asseriton Error' istisnası diğer istisnalarda da olduğu gibi kırmızı ekran vermeden kontrol edilebilmektedir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "073eb863-1950-4a6f-8460-c0d4bfbd71ac", "metadata": {}, "outputs": [], "source": [ "#Örneğin sisteme kayıt olurken kullanıcı adının varolanlardan farklı olarak belirtilemesini sağlayalım\n", "def kayitOl(kulAdi):\n", " kullanilanlar = [\"admin\",\"root\",\"teknikdestek\",\"info\",\"kurumsal\"]\n", " assert kulAdi.lower() not in kullanilanlar, \"Bu kullanıcı adı zaten kullanılmaktadır. Başka birtane seçiniz.\"\n", " kayit = KulAdi\n", " print(\"Kayıt Başarılı!\")\n", "kayitOl(input(\"Kayıt olmak için kullanıcı adınızı giriniz: \"))" ] }, { "cell_type": "markdown", "id": "75cbeee7-0321-402d-a28d-5361b18e59eb", "metadata": {}, "source": [ "`assert` deyiminin kullanımı ile ilgili bilinmesi gerekenler:\n", "1. `assert` deyimi programın geliştirilme sürecindeki kaynak kodları deneme çalıştırmalarındaki hata ayıklama aracıdır (debugging). Bitmiş, derlenmiş ve sürüm haline getirilmiş programın çalışma süreçlerinde (runtime) dikkate alınmazlar. Yani kaynak kodun bir parçası gibi derlenmezler.\n", "1. `assert` deyimi ile programcının iddiası (varsayımı) doğrulanmazsa (False) programın geri kalan kodları çalıştırılmaz. Hata bloğuna gidilir. Yani geliştirme sürecinde gereksiz yere kod çalıştırmaz ve geliştirme sürecini hızlandırır, kaynakları tüketmez.\n", "1. `assert` ile yükseltilen her istisna 'Assertion Error' sınıfında olduğu için 'Assertion Error' istisnasından farklı olarak gerçekleşebilecek 'TypeError', 'ValueError' gibi istisnalar için 'kırmızı ekran' alınır." ] }, { "cell_type": "markdown", "id": "8c95f874-76d8-4b6c-99df-2b3277eff320", "metadata": {}, "source": [ "Sadece geliştirme sürecinde (debug) hata yükselttiği için `assert` deyimi yerine ***her çalışma zamanında çalışacak şekilde istisna sınıfını belirterek istisnayı biz yükseltirsek*** daha uygun hata kontrolü yapmış oluruz.
\n", "İstisna veya hata yükseltmek Python'da `raise` deyimi ile yapılır. `raise` deyimi de `try` - `except` olmadan kullanılabilibir fakat istisna (hata) kontrolü yapmak için `try` - `except` ile kullanırız. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "6c80d45d-b694-4a5a-b227-899b8ebdc7d0", "metadata": {}, "outputs": [], "source": [ "try:\n", " def tcDogrula(tc):\n", " if not tc.isnumeric(): raise TypeError(\"TC No Sadece Rakamlardan Oluşur!\")\n", " if tc[0] == \"0\": raise ValueError(\"TC No Sıfır ile Başlayamaz!\")\n", " if len(tc)!=11: raise TypeError(\"TC No 11 Hanelidir!\")\n", " tek = sum([int(tc[i]) for i in range(0,len(tc)-2,2)]) #tek basamakları topladık\n", " cift = sum([int(tc[i]) for i in range(1,len(tc)-2,2)]) #çift basamakları topladık\n", " #10.basamak algoritması\n", " if int(tc[9]) != (7*tek-cift)%10: raise Exception(\"Girilen TC No'nun 10.Basamağı Doğrulanamadı!\")\n", " #11.basamak algoritması\n", " if int(tc[10]) != sum([int(tc[i]) for i in range(len(tc)-1)])%10: raise Exception(\"Girilen TC No'nun 11.Basamağı Doğrulanamadı!\")\n", " print(\"TC No Geçerli\")\n", " tcDogrula(input(\"TC No giriniz: \"))\n", "except TypeError as hata:\n", " print(hata)\n", "except TypeError as hata:\n", " print(hata)\n", "except Exception as hata:\n", " print(hata)" ] }, { "cell_type": "markdown", "id": "751c2f85-b397-4db3-928b-cf95940f40e7", "metadata": {}, "source": [ "Yukarıda da gördüğünüz gibi `raise` deyimi ile hangi istisnanın yükseltileceğini biz belirliyoruz ve açıklamasını giriyoruz. `raise` deyimi `try` - `except` ile birlikte gerçek sürümde de (gerçek çalışma zamanında) hata kontrolü içn kullanılır. Yani `assert` kod yazım esnasında, `raise` ise yayımlanan sürümde kullanılır. Ayrıca siz **kendinize ait bir istisna sınıfını da yine `raise` ile oluşturabilirsiniz.**" ] }, { "cell_type": "code", "execution_count": null, "id": "301b2e3d-8046-4213-b747-01b5559198c4", "metadata": {}, "outputs": [], "source": [ "class Hata(Exception): #Exception sınıfından alt bir 'Hata' isminde sınıf türettik.\n", " def __init__(self,aciklama=\"Bir 'Hata' Çıktı!\"):\n", " if not aciklama == None: self.aciklama = aciklama\n", " def __str__(self):\n", " if not self.aciklama == None:\n", " return self.aciklama\n", " else:\n", " return \"Özel Hata Çıktı\"\n", "try:\n", " veri = \"A\"\n", " if not veri.isnumeric():\n", " raise Hata(\"Verimiz ancak ve ancak sayı olabilir!\")\n", "except Hata as aciklama:\n", " print(aciklama)" ] }, { "cell_type": "markdown", "id": "515e8dd0-d1e6-4355-89ea-5332cd394b5f", "metadata": {}, "source": [ "# Dosya İşlemleri\n", "**Dosya (Bilgisayar Dosyası):** Disk üzerinde saklanan ve belirli büyüklüğü (bayt) olan verilerin oluşturduğu bir veri bütünüdür (yapısıdır). Dosyaları düzenli bir şekilde içerisinde tuttuğumuz klasörler bir **dizin (path)**'dir. Örneğin Windows işletim sisteminin kurulduğu klasör `C:\\Windows\\` dizinidir. Sürücülerimizin yüklendiği klasör `C:\\Windows\\System32\\` dizinidir. Dizinler tek başına bir veriyi ifade etmediği için boyutları yoktur. İçerisinde barındırdığımız ***dosyalar*** ile büyüklüğü artar. Ayrıca klasörlerin veya dizinlerin bir uzantısı olmaz, o sadece bir yolu ifade eder.
\n", "Dosyaların ise dizinlerden farkı bir veri yapısı olmaları ve uzantısının olmasıdır. Örneğin `.txt , .csv , .jpg , .png` gibi uzantılar sadece dosyalarda yani içerisinde veri içeren yapılarda olur. Metin dosyaları, resim dosyaları, program dosyaları, ayar dosyaları vb. dosyalar uzantısına göre tanımlanır.
\n", "Dosya bütünlüğü disk üzerinde `[başlık (header) - veri - bitiş göstergesi (eof)]` ile belirlenir. Başlık kısmında başlangıç adresi, dosya başlık vb. birçok bilgi varken veri kısmında verinin binary içeriği mevcuttur. Bitiş göstergesi (end of file) ise verinin binary olarak tamamlanıp bittiğinin göstergesidir.

\n", "Örneğin bizim Python ile yazdığımız kodları çalıştırmamız için disk üzerine kaydetmemiz gerekir. Bu dosyanın uzantısı .py'dir ve uzantısından Python dosyası olduğu anlaşılabilir. Bir dosyayı çalıştırdığımızda (çift tıkladığımızda) onu disk üzerinden belleğe (RAM) çağırmış oluruz. İşletim sistemimiz de bu dosya türünü yürütebilecek bir program ile başlangıcından sonuna kadar (başlangıç adresi - bitiş göstergesi) dosyamızın verilerini yürütür. Python'da dosyalara `open()` fonksiyonu ile erişilir." ] }, { "cell_type": "markdown", "id": "94503ec8-dc75-46a8-bb0a-52b8053b52c9", "metadata": {}, "source": [ "## Open() Fonksiyonu ve Close() Metodu\n", "Python'da `open()` fonksiyonu ile bilgisayarınızda var olan bir dosyaya erişebilir, görüntüleyebilir, içeriğini değiştirebilir, yeni bir dosya oluşturabilir veya bir dosyayı silebilirsiniz. Şimdi **çalıştırdığımız Python dosyası ile aynı dizinde (klasörde) olan** bir metin dosyası oluşturalım. **Eğer çalıştığınız python dosyasının nerede kayıtlı olduğunu bilmiyorsanız 'Dosya->Farklı Kaydet' seçeneği ile erişebileceğiniz bir yere kaydediniz.**" ] }, { "cell_type": "code", "execution_count": null, "id": "c4d7acaf-a1e2-4372-87f2-0007f9a10bc3", "metadata": {}, "outputs": [], "source": [ "dosya = open(\"metin_dosyasi.txt\",\"w\",encoding=\"utf-8\") #dosyamızı oluşturduk ve açtık.\n", "dosya.close() #dosyamızı kapattık." ] }, { "cell_type": "markdown", "id": "aba618c6-0857-4c4a-9e8f-9ac795679e87", "metadata": {}, "source": [ "Yukarıda yazdığımız kod çalıştırılınca, python dosyamız ile aynı dizinde bir `metin_dosyasi.txt` dosyası oluşturur. Burada `\"w\"` parametresiyle dosyayı **yazma (write)** modunda açtığımızı belirttik. Ayrıca `encoding=\"utf-8\"` parametresiyle dosyayı Türkçe karakterleri tanıyacak şekilde encode (kodla-çöz) ettik. Bu erişim parametresi ile eğer dizinimizde böyle bir dosya mevcut ise dosyanın üzerine yazarak sıfırdan yeni bir dosya açar. Yani eski dosyadaki veriler kaybolur. Dosyalara erişirken kullanabileceğimiz parametreler ve açıklamaları aşağıdaki gibidir." ] }, { "cell_type": "markdown", "id": "4c10f3d6-80b9-45bd-b88e-e1fc0d6f73c3", "metadata": {}, "source": [ "| **ERİŞİM PARAMETRESİ** | **MOD** | **AÇIKLAMA** | **DOSYA VARSA** | **DOSYA YOKSA** | **İMLEÇ** |\n", "|:-:|:-:|:-|:-:|:-:|:-:|\n", "| **\"r\"** | **Okuma** | Dosyayı sadece okuma modunda açar. Dosyanın içeriğini değiştiremezsiniz.|İçeriğini koruyarak açar.|Hata verir.|Başta|\n", "| **\"r+\"** | **Okuma
Yazma** | Dosyayı okuma ve yazma modunda açar. Dosyayı okur veya dosyanın içeriğini değiştirebilirsiniz.|İçeriğini koruyarak açar.|Hata verir.|Başta|\n", "| **\"w\"** | **Yazma** | Dosyayı sadece yazma modunda açar. İçeriğini değiştirebilirsiniz fakat dosyada okuma işemleri yapamazsınız.
Eğer dosya mevcutsa dosyadaki verileri sıfırlar (siler) ve boş şekilde açar.|İçeriğin üzerine yazarak yenisini oluşturur. Eski içerik kaybolur.|Yenisini Oluşturur.|Başta|\n", "| **\"w+\"** | **Okuma
Yazma** | Dosyayı okuma ve yazma modunda açar.
Eğer dosya mevcutsa dosyadaki verileri sıfırlar (siler) ve boş şekilde açar.|İçeriğin üzerine yazarak yenisini oluşturur. Eski içerik kaybolur.|Yenisini Oluşturur.|Başta|\n", "| **\"a\"** | **Yazma** | Dosyayı sadece yazma modunda açar. Dosyada okuma vb. işemler yapamazsınız.
Eğer dosya mevcutsa dosyadaki verileri silmeden en sonuna ekleme yapacak şekilde getirir.|İçeriğini koruyarak açar.|Yenisini Oluşturur.|Sonda|\n", "| **\"a+\"** | **Okuma
Yazma** | Dosyayı okuma ve yazma modunda açar.
Eğer dosya mevcutsa dosyadaki verileri silmeden en sonuna ekleme yapacak şekilde getirir.|İçeriğini koruyarak açar.|Yenisini Oluşturur.|Sonda|" ] }, { "cell_type": "markdown", "id": "663f9f2e-2264-4744-84e6-6f3be68807cc", "metadata": {}, "source": [ "Dosyaları açtıktan sonra kapatmazsak farklı işlemler için dosyaya erişmesi gereken kodun geri kalanındaki ifadeler veya farklı programlar dosyaya erişemeyebilir. Bu sebeple okuma-yazma hataları yükselebilir. Bu sebeple açtığımız dosyalar ile işimiz bitince kapatmak öneme sahiptir. Python'da dosyaları yukarıdaki örnekte olduğu gibi `close()` metodu ile kapatırız. Her seferde `close()` metodunu kullanmak can sıkıcı olabileceği için `with` deyimi daha işlevseldir." ] }, { "cell_type": "markdown", "id": "ba69eb7f-7c85-4b7a-9e4a-455d3e2f17bd", "metadata": {}, "source": [ "## With Deyimi" ] }, { "cell_type": "markdown", "id": "8bdf62f8-d76d-4c15-bac1-d05e09ed3be2", "metadata": {}, "source": [ "`open()` fonksiyonunu `with` deyimi ile kullanırsak dosya işlemleri yaparken dosyayı her seferinde kapatmanıza gerek kalmaz. Çünkü deyimin kendine ait `__enter()__` ve `__exit()__` metodları vardır ve fonksiyonu kullanınınca bu işlemler otomatik gerçekleşir. Örnek kullanım:" ] }, { "cell_type": "code", "execution_count": null, "id": "cc4518cb-8a6f-4283-a47e-b8d080c0c62d", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"w\",encoding=\"utf-8\") as dosya:\n", " pass #burada dosya.metot() olarak istediğimiz işlemleri yapabiliriz.\n", "#with deyiminin girintisinden çıkınca dosya otomatik olarak kapanır. Yani dosya.close() olur." ] }, { "cell_type": "markdown", "id": "2a18e443-7905-4d82-8d5a-f92080d923a2", "metadata": {}, "source": [ "`with` deyimi esasında fonksiyonlar veya class'lar gibi `__enter()__` ve `__exit()__` metodu olan birçok yapıyla da kullanılabilir. Sadece dosya işlemlerine özgü bir yapı değildir." ] }, { "cell_type": "markdown", "id": "b5a3822b-8018-44ae-80f3-d97c403f5748", "metadata": {}, "source": [ "## Write() ve Writelines() ile Veri Yazma\n", "Açtığımız dosyaya **'string'** tipinde eklemeler yapmak için `write()` metodunu, **'string'** veya **'list'** tipinde eklemeler yapmak için `writelines()` metodunu kullanırız. Şimdi `write()` ve `writelines()` için bir örnek yapalım." ] }, { "cell_type": "code", "execution_count": null, "id": "ddbafc87-c7da-4921-b070-bf04015e4bd5", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"w\",encoding=\"utf-8\") as dosya: #Dosyamızı yazma modunda açtık, eğer dosya mevcutsa üzerine yazarak sıfırladı.\n", " bilgi = \"TÜRKİYE, 1923, Ankara\" #yazacağımız bilgileri string değişkene atadık.\n", " dosya.write(bilgi) #string değişkenimizin değerlerini dosyamıza 'yazdık'.\n", " dosya.write(\"\\n\") # bir alt satıra geçtik\n", " bilgi = [\"ANADOLU\",\"=\",\"ANAYURT\"] #list değişkenimizin değerlerini dosyamıza 'yazdık'.\n", " dosya.writelines(bilgi)" ] }, { "cell_type": "markdown", "id": "d75cec92-9010-4748-b6c9-6dfbdc0360ef", "metadata": {}, "source": [ "Şimdi Python kodlarımızı yazdığımız .py dosyamızın kayıtlı olduğu dizine gidelim ve orada oluşturduğumuz `metin_dosyasi.txt` dosyasını açarak içine yazılanları kontrol edelim. Aşağıdaki resimdeki gibi olması gerekir.
\n", "
" ] }, { "cell_type": "markdown", "id": "5a1af6f3-09c1-409d-8e84-deaad893a21c", "metadata": {}, "source": [ "## Read() ve Readlines() ile Veri Okuma\n", "İşlediğimiz dosyanın içindeki bilgileri dizine gidip açmaktansa python üzerinden de okuyabiliriz. Bunun için önce 'imleç' mantığını ifade edelim. Yukarıdaki resimde 'Türkiye'nin başında gördüğünüz **'|' işaretine imleç (cursor)** denir. Yapacağımız işlemler bu imleç hizasından yapılır. İmleç konumu bu sebeple önemlidir. Şimdi bunu örneklendirelim. Kapattığımız dosyayı okuma modunda tekrar açalım ve `read()` metodu ile okuyalım." ] }, { "cell_type": "code", "execution_count": null, "id": "0d5707b1-cce7-445b-905c-4644c4c36e8f", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " print(dosya.read()) #dosyamızdaki verileri imlecin konumundan itibaren ekrana bastıralım." ] }, { "cell_type": "markdown", "id": "2acdb780-3ac3-436e-b76f-4d7ee969ad24", "metadata": {}, "source": [ "Bu kodlar ile ekrana **yukarıdaki resimde yazanlar basılır.** Bunun sebebi 'r' erişim modu ile imlecin başta açılmasıdır. Çünkü `read()` metodu ile imleçten sonrası ekrana yazılır. İmleç başta olduğu için imleçte sonra yazılanların hepsi basılır. Şimdi imleçten sonraki tüm verileri değil de belirli sayıda karaktere olanları görelim. Bunun için `read()` metoduna parametre vermek lazım: `read(5)` gibi." ] }, { "cell_type": "code", "execution_count": null, "id": "f2d62282-bbcf-4de7-975e-2a8f6025503c", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " print(dosya.read(7)) #dosyamızdaki verileri imlecin konumundan itibaren 7.karaktere kadar ekrana bastıralım." ] }, { "cell_type": "markdown", "id": "5c5bd94b-b2ed-4b2e-a0c9-156c5ec48604", "metadata": {}, "source": [ "`read(7)` ifadesi ile ekrana sadece `TÜRKİYE` yazıldığını görürüz. İmlecin olduğu konumdan itibaren 7 karakter yazdırır.

\n", "`readlines()` metodu ile dosyamızdaki verilerin her bir satırı bir eleman olacak şekikde **'list'** (liste) tipine çevrilir. Bu metot ile satırlar görünmez, her bir satır bir liste elemanı olur. Ekrana yazdırarak görelim." ] }, { "cell_type": "code", "execution_count": null, "id": "843f52a1-4006-468b-9d25-6f97b6eb2796", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " print(dosya.readlines()) #dosyamızdaki verilerin her bir satırın liste elemanı yaparak listeyi ekrana yazdıralım." ] }, { "cell_type": "markdown", "id": "fcc4933d-e0bc-4cc1-bcb4-c4c072c80515", "metadata": {}, "source": [ "`readlines()` metoduna parametre verilerek işlem yaptırılabilir. Parametre ile şu şekilde çalışır:
\n", "İmlecin bulunduğu satırdan, parametre olarak girilen sayıda karakterin denk geldiği satır dahil olacak şekilde satırları liste elemanı yaparak listeyi oluşturur ve imleci o satırın sonuna alır. Yani yukardaki örnek için 21'e kadar yazlanlarda sadece ilk satırı eleman yapar, 21'den büyük değerler için ilk iki satırı eleman yapar." ] }, { "cell_type": "code", "execution_count": null, "id": "c78e91b5-3b82-4574-88fd-487ef5afe0a7", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " liste = dosya.readlines(21)\n", " print(liste)" ] }, { "cell_type": "code", "execution_count": null, "id": "b4215bb2-ef9b-4616-b5a4-a1ebafcd5ae9", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " liste = dosya.readlines(22)\n", " print(liste)" ] }, { "cell_type": "markdown", "id": "cab0a13f-ddea-49a8-806f-59e482e37e41", "metadata": {}, "source": [ "Buradaki çıktılarda birşeyi farketmişsinizdir. `readlines()` metodu kaçış stringlerini de önceki satıra dahil ediyor. Yani kaçış stringlerini görmezden gelmiyor. Şimdi dosyamızdaki satırları `for` döngüsü ile yazdıralım." ] }, { "cell_type": "code", "execution_count": null, "id": "47044cb9-d606-484c-a5fc-c3e48e35b2c7", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " for satir in dosya.readlines():\n", " print(satir)" ] }, { "cell_type": "markdown", "id": "33f6f319-9689-47a1-be3a-62c9e4928a1b", "metadata": {}, "source": [ "Farkettiyseniz bu kez kaçış stringi çalıştı. Çünkü her bir elemanı ele alırken **string** olarak ele aldığı için ilk satırı yazarken sonundaki kaçış stringi çalıştırdı ve alt satıra geçti. Şimdi bunu önleyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "e3098573-6bbb-4ad2-bae1-c067373d090e", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " for satir in dosya.readlines():\n", " satir = satir.replace(\"\\n\",\"\")\n", " print(satir)" ] }, { "cell_type": "markdown", "id": "59446ea9-7e56-48f1-8bd9-4e9f96dad201", "metadata": {}, "source": [ "## Seek() ve Tell() ile İmleç İşlemleri, Truncate() ile Budama" ] }, { "cell_type": "markdown", "id": "3f04af02-6736-47c8-a225-fc9e7b7a2f32", "metadata": {}, "source": [ "Python'da imleç kontrolü `seek()` metodu ile yapılır. Bütün bu işlemlerin (`write(), writelines(), read(), readlines()`) imlece göre yapıldığını unutmayalım. Şimdi imleci 25. byte konumuna yani ikinci satırın başına getirerek tekrar `read()` metodu ile okuyalım." ] }, { "cell_type": "code", "execution_count": null, "id": "99cace26-367f-4941-b2db-649c111c43d6", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"r\",encoding=\"utf-8\") as dosya: #Dosyamızı okuma modunda açtık, eğer dosya mevcut değilse hata verir.\n", " dosya.seek(25) #imleci 25. byte konumuna getirdik.\n", " print(dosya.read()) #dosyamızdaki verileri imlecin konumundan itibaren ekrana bastıralım." ] }, { "cell_type": "markdown", "id": "2fa51662-f754-4237-a2dc-a0cd650640ff", "metadata": {}, "source": [ "Sonuç olarak sadece `ANADOLU=ANAYURT` yazmış olması gerekir.
\n", "`r, r+, w, w+, a, a+` erişim modlarını düşününce imleç konumunun önemini anlamış olduk. Şimdi `readlines()` ve `writelines()` metotları ile imleç konumunu biraz daha işleyelim. `readlines()` ve `writelines()` metotları ile imlecin bulunduğu yerden, parametre olarak girilen değerin denk geldiği satır ele alınır ve imleç o satırın sonuna getirilir." ] }, { "cell_type": "code", "execution_count": null, "id": "f1f0241f-bc02-41cb-adca-cd69b579ac54", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"w+\",encoding=\"utf-8\") as dosya: #Dosyamızı yazma-okuma modunda açtık.\n", " dosya.writelines(\"1.Satır\") #imleç burada yazılanın sonuna geldi.\n", " dosya.writelines(\"\\n\") #imleç burada yazılanın sonuna geldi. (Yani bundan sonrakiler alt satıra geçecek.)\n", " dosya.writelines(\"2.Satır\") #imleç burada yazılanın sonuna geldi.\n", " dosya.writelines(\"\\n\") #imleç burada yazılanın sonuna geldi. (Yani bundan sonrakiler alt satıra geçecek.)\n", " dosya.writelines(\"3.Satır\") #imleç burada yazılanın sonuna geldi.\n", " dosya.seek(0) # imleci başa aldık.\n", " print(dosya.readlines(1)) #imleç 0'da idi. İmleçten sonra ilk byte konumuna denk geldiği satırı yazdı ve imleci bu satırın sonuna getirdi.\n", " print(dosya.readlines(1)) #imleç 1.satırın sonunda idi. İmleçten sonra ilk byte konumuna denk geldiği satırı (2.satır) yazdı ve bu satırın sonuna geldi.\n", " print(dosya.readlines(1)) #imleç 2.satırın sonunda idi. İmleçten sonra ilk byte konumuna denk geldiği satırı (3.satır) yazdı ve bu satırın sonuna geldi." ] }, { "cell_type": "markdown", "id": "b0c8bbeb-cd6c-4506-91b8-c93c92cda1cf", "metadata": {}, "source": [ "Yukarıdaki çıktından da göreceğimiz üzere **imleç her zaman en son yapılan işlemin sonunda konumlanıyor.** Bu işlemin yazma veya okuma olması farketmiyor. Bir örnek daha yapalım." ] }, { "cell_type": "code", "execution_count": null, "id": "10bb8c67-c9a1-4e75-bb60-d8d2c0d018d5", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"w+\",encoding=\"utf-8\") as dosya: #Dosyamızı yazma-okuma modunda açtık.\n", " dortluk = \"\"\"Korkma, sönmez bu şafaklarda yüzen al sancak;\n", "Sönmeden yurdumun üstünde tüten en son ocak.\n", "O benim milletimin yıldızıdır, parlayacak;\n", "O benimdir, o benim milletimindir ancak.\"\"\"\n", " dosya.write(dortluk) #imleç dörtlüğü yazdı ve sona geldi.\n", " dosya.seek(0) #imleci başa almazsak sonraki adımdaki 'readlines()' boş olur. Çünkü imleç sonda. İmleç sonrasında birşey yok.\n", " for i in range(len(dosya.readlines())):\n", " if i==0: dosya.seek(0) #for döngüsüne girerken 'readlines()' yaptığımız için imleç sona geldi, onu ilk döngüde başa alıyoruz ki okunacak birşey olsun.\n", " print(dosya.readlines(1))" ] }, { "cell_type": "markdown", "id": "8cb5df9a-4c7d-4ad9-adb3-aaa79a60203b", "metadata": {}, "source": [ "Eğer dosyada **imlecin konumunu öğrenmek** istiyorsak `tell()` metodunu kullanırız. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "88232999-3065-48ef-bf35-569ac3bcf684", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"w+\",encoding=\"utf-8\") as dosya: #Dosyamızı yazma-okuma modunda açtık.\n", " dortluk = \"\"\"Korkma, sönmez bu şafaklarda yüzen al sancak;\n", "Sönmeden yurdumun üstünde tüten en son ocak.\n", "O benim milletimin yıldızıdır, parlayacak;\n", "O benimdir, o benim milletimindir ancak.\"\"\"\n", " dosya.write(dortluk) #imleç dörtlüğü yazdı ve sona geldi.\n", " print(dosya.tell()) #imlecin konumunu gösterdik.\n", " dosya.seek(44) #imlecin konumunu değiştirdik.\n", " print(dosya.tell()) #imlecin konumunu tekrar gösterdik." ] }, { "cell_type": "markdown", "id": "4e6737ed-0434-4d90-a916-e570bed4b954", "metadata": {}, "source": [ "Bir dosyayı **sondan kırpmak** için `truncate()` metodunu kullanırız. `truncate()` metodu için imleç kontrol etmenize gerek yoktur. Dosyayı baştan itibaren yazdığınız paratmetredeki byte konumuna kadar korur, geri kalanı budar. Bu sebeple sondan kırpmak diyebiliriz. Örneğin `TÜRKİYE` stringinin olduğu bir dosyayı `truncate(5)` ile budarsak baştan başlayarak beşinci byte konumuna gelir ve gerisini budar. Sonuç `TÜRK` olur. Örnek yapalım." ] }, { "cell_type": "code", "execution_count": null, "id": "3b5bed73-7e39-4ee5-bbb8-24119926f8dd", "metadata": {}, "outputs": [], "source": [ "with open(\"metin_dosyasi.txt\",\"w+\",encoding=\"utf-8\") as dosya: #Dosyamızı yazma-okuma modunda açtık.\n", " misra = \"Her şey ben yaşarken oldu, bunu bilsin insanlar.\"\n", " dosya.write(misra) #imleç misrayı yazdı ve sona geldi.\n", " dosya.seek(0) #imleci başa aldık\n", " print(\"Dosyanın ilk hali: \",dosya.read())\n", " dosya.seek(0)\n", " sonKelimeBaslangici = str(dosya.readlines()).rfind(\" \")+1 #son kelime son boşluktan 1 sonraki karakterden başlar.\n", " dosya.seek(sonKelimeBaslangici) #imlecimizi son kelimenin olduğu başlangıca aldık\n", " sonKelime = dosya.read() # imlecin bulunduğu yerden sona kadar giderek son kelimeyi değişkene atadık.\n", " dosya.truncate(sonKelimeBaslangici-1) #son kelimeyi budadık. Truncate kullanmak için imleç kontrolüne gerek yoktur. Baştan hiza alır, geri kalanı budar.\n", " dosya.seek(0)\n", " print(\"Dosyanın son hali: \",dosya.read())\n", " print(\"Silinen veri: \",sonKelime)" ] }, { "cell_type": "markdown", "id": "e5168080-9e7e-42fb-a499-192d2577ccb3", "metadata": {}, "source": [ "`truncate()` ile ilgili bir bilgi daha verelim. `truncate()` byte konumuna göre budama yaptığı için eğer bir dosyayı `truncate(10)` ile budarsanız dosya büyüklüğü 10 Byte olur. Budadığınız bir dosyaya sağ tıklayarak özelliklerinden boyutuna bakarak bunu görebilirsiniz. Farklı dosyalar türleri için `truncate()` kullanırsanız `eof` silenebileceği için dosyanız geri dönüştürülemez şekilde bozulabilir." ] }, { "cell_type": "markdown", "id": "4e61dc5a-3b67-427d-b102-990db6a8d40a", "metadata": {}, "source": [ "## OS (İşletim Sistemi) Kütüphanesi" ] }, { "cell_type": "markdown", "id": "8f425bdc-431f-4ab1-9fd6-a0b0a55b8174", "metadata": {}, "source": [ "İşletim sistemine ait yetenekleri (dosya-klasör-silme-oluşturma vb.) kullanmamızı sağlayan fonksiyonları barındırır. `import os` veya `from os import *` olarak aktarılabilir." ] }, { "cell_type": "markdown", "id": "a95eadef-5c15-460b-9eef-7c78bfb58143", "metadata": {}, "source": [ "### OS Kütüphanesi ile Gelen Bazı Deyim ve Fonskiyonlar" ] }, { "cell_type": "markdown", "id": "0ad89326-b851-4189-8699-abcb5fb6fd39", "metadata": {}, "source": [ "- İşletim sistemi **arabirimini** öğrenmek için **`os.name()`** fonskiyonu kullanılır. (Windows (nt), Linux (posix) vb.)
İşletim sisteminin adını sürümünü öğrenmek için `import plaftform` kütüphanesi ile `platform.system()` ve sürümü için `platform.release()` kullanılabilir. İşletim sistemi derlemesi için `platform.version()` kullanılır.\n", "- İçinde çalışılan dizini simgeleyen karakter için **`os.getcwd()`** fonskiyonu kullanılır. Genelde *.* karakteridir.\n", "- İçinde çalışılan dizin ve yolun string değişken hali için **`os.curdir`** deyimi kullanılır.\n", "- Kullanılan işletim sisteminin kullandığı dizin ayracını öğrenmek için **`os.sep`** deyimi kullanılır.\n", "- İçinde çalışılan dizini değiştirmek için **`os.chdir()`** fonskiyonu kullanılır.\n", "- Bir dizin içindeki dosya ve klasörleri listelemek için **`os.listdir()`** fonskiyonu kullanılır.\n", "- Bir üst dizin yolunu simgeleyen karakter için **`os.pardir`** deyimi kullanılır. Genelde *..* karakteridir.\n", "- Bir dosyayı başlatmak veya bir dizin açmak için **`os.startfile()`** fonskiyonu kullanılır. Sadece windows işletim sisteminde çalışır.\n", "- İçinde çalışılan dizinin içinde yeni dizin oluşturmak için **`os.mkdir()`** fonskiyonu kullanılır.\n", "- İçinde çalışılan dizinin içinde yeni dizin ve alt dizinler oluşturmak için **`os.mkdirs()`** fonskiyonu kullanılır.\n", "- İçinde çalışılan dizinin içinde bulunan dizinlerin adlarını değiştirmek için **`os.rename()`** veya **`os.replace()`** fonskiyonu kullanılır. Örnek: `os.rename(dizinin_Varolan_Adi,dizinin_Yeni_Adi)`\n", "- İçinde çalışılan dizinde bulunan 'dosyaları' silmek için **`os.remove()`** fonskiyonu kullanılır.\n", "- İçinde çalışılan dizinde bulunan 'boş 1 dizini' silmek için **`os.rmdir()`** fonskiyonu kullanılır.\n", "- İçinde çalışılan dizinde bulunan 'boş dizinleri' silmek için **`os.removedirs()`** fonskiyonu kullanılır.\n", "- İçinde çalışılan dizinde bulunan 'dosyaya ait öznitelik bilgileri' için **`os.stat()`** fonskiyonu kullanılır.\n", "- Bir dosya yolunun dizin kısmını elde etmek için **`os.path.dirname()`** fonskiyonu kullanılır.\n", "- Bir dosya veya yolun varolduğunu kontrol etmek için **`os.path.exists()`** fonskiyonu kullanılır.\n", "- Kullanıcıya ait dizin adresi için **`os.path.expanduser()`** fonskiyonu kullanılır. Örnek: os.path.expanduser('~')\n", "- Bir değerin dizin olup olmadığını kontrol etmek için **`os.path.isdir()`** fonskiyonu kullanılır.\n", "- Bir değerin dosya olup olmadığını kontrol etmek için **`os.path.isfile()`** fonskiyonu kullanılır.\n", "- Verilen parametreler ile işletim sistemine ait ayracı kullanarak yol oluşturmak için **`os.path.join()`** fonskiyonu kullanılır." ] }, { "cell_type": "markdown", "id": "4147b863-9b44-4c6c-a09b-8df26870ce7a", "metadata": {}, "source": [ "Birkaç örnek yapalım. Örneğin bir python dosyası açmadık ve kabukta (shell) çalışıyoruz ve yeni bir dosya oluşturduk. Fakat dosyayı bulmamız gerekiyor. Python derleyicimizin çalıştığı konum için sırasıyla şunları yazarsak ekranda görüntüleriz." ] }, { "cell_type": "code", "execution_count": null, "id": "02d0899b-6596-4105-9ec6-c61f52e15514", "metadata": {}, "outputs": [], "source": [ "import os\n", "print(os.getcwd())" ] }, { "cell_type": "markdown", "id": "c2e579e2-7a39-4459-8b78-e593f511b8fd", "metadata": {}, "source": [ "Çalıştığımız dizini `os.chdir()` ile değiştirelim. Öyle bir dizin yoksa `os.mkdir()` ile oluşturalım. Sonrasında `os.rmdir()` ile silelim." ] }, { "cell_type": "code", "execution_count": null, "id": "c86dd801-11c4-4196-a484-87f27035098f", "metadata": {}, "outputs": [], "source": [ "import os\n", "from IPython.display import clear_output #Jupyter ile çalışıyorsanız output silmek için.\n", "\n", "# DİZİN DEĞİŞTİRME\n", "root = os.getcwd() #mevcut dizini root değişkenine atadık.\n", "print(\"Şu an çalışılan dizin: \",os.getcwd())\n", "yeni = \"D:\\\\PythonDizini\\\\\" #yeni değişkenine dizin atadık.\n", "print(\"Yeni dizine geçiliyor...\")\n", "if not os.path.isdir(yeni): # Dizin yoksa oluşturacağız.\n", " print(\"Yeni dizin mevcut değil, oluşturuluyor...\")\n", " os.mkdir(yeni) # os.mkdir() ile oluşturduk.\n", " print(\"Oluşturma Başarılı!\")\n", "os.chdir(yeni) #eski dizini yeni dizin ile değiştirdik.\n", "print(\"Dizin değiştirme başarılı!\",\"Eski dizin: {}\".format(root),\"Mevcut Dizin: {}\".format(os.getcwd()),sep=\"\\n\")\n", "\n", "# ESKİ DİZİNE DÖNME DEĞİŞTİRME\n", "#Root dizinine dönmeyi soruyoruz.\n", "islem = input(\"Root dizinine dönmek istiyor musunuz? (E:Evet, H:Hayır)\").upper()\n", "os.system(\"clear\") #önceden ekrana basılanları temizliyoruz. (Windows için 'cls' Linux için 'clear')\n", "clear_output(wait=True) #Jupyter için önceden ekrana basılanları temizliyoruz.\n", "\n", "if islem == \"EVET\" or islem == \"E\":\n", " print(\"Root dizinine dönülüyor...\")\n", " os.chdir(root)\n", "print(\"Dizin değiştirme başarılı!\",\"Eski dizin: {}\".format(yeni),\"Mevcut Dizin: {}\".format(os.getcwd()),sep=\"\\n\")\n", "\n", "# OLUŞTURULAN DİZİNİ SİLME\n", "# Oluşturduğumuz klasörü siliyoruz.\n", "islem = input(\"Oluşturduğunuz klasörü silmek istiyor musunuz? (E:Evet, H:Hayır)\").upper()\n", "os.system(\"cls\") #önceden ekrana basılanları temizliyoruz. (Windows için 'cls' Linux için 'clear')\n", "clear_output(wait=True) #Jupyter için önceden ekrana basılanları temizliyoruz.\n", "\n", "if islem == \"EVET\" or islem == \"E\":\n", " print(\"Siliniyor...\")\n", " os.rmdir(yeni)\n", "print(\"Dizin silme başarılı!\",\"Silinen Dizin: {}\".format(yeni),sep=\"\\n\")" ] }, { "cell_type": "markdown", "id": "08b78946-3168-4379-9ccc-5742e1cab7c7", "metadata": {}, "source": [ "Şimdi bilgisayarda kullanıcıya ait ne dosyalar var bakalım. Listeyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "562156e7-fe1b-48c0-908f-9def5efa4af7", "metadata": {}, "outputs": [], "source": [ "import os\n", "root = os.getcwd() #mevcut dizini root değişkenine atadık.\n", "userPath = os.path.expanduser('~') #kullanıcı dizini için '~' giriyoruz.\n", "dDisk = \"D:\\\\\"\n", "\n", "print(\"Kullanıcı dosyalarının dizini: \",userPath)\n", "print(f'{userPath} dizinindeki dosya ve klasörler: ')\n", "for eleman in os.listdir(userPath): print(eleman)\n", "\n", "print(f'\\n{dDisk} dizinindeki dosya ve klasörler: ')\n", "for eleman in os.listdir(dDisk): print(eleman)\n", "\n", "print(\"Şu an içinde çalışılan dizin: \",os.getcwd()) #dizinlerde gezip dosyaları listelesek de Python çalıştığı dizin değişmez." ] }, { "cell_type": "markdown", "id": "62ca950e-b03d-478f-be93-bd3f0fedd9ef", "metadata": {}, "source": [ "
Etkinlik: Bilgisayarınızın D: diskinde bir \"Deneme\" isimli klasör oluşturunuz. Ardından bu klasörün adını \"Python\" olarak değiştiriniz sonrasında bu klasörü siliniz.
" ] }, { "cell_type": "markdown", "id": "c2466b71-3177-4dbf-a2d6-49caad181a1d", "metadata": {}, "source": [ "
Etkinlik: Bilgisayarınızda bulunan bir dosyayı açınız.
" ] }, { "cell_type": "markdown", "id": "76493437-74c4-4849-86cc-53f9040ebf8e", "metadata": {}, "source": [ "Python ile `.txt` dosyaları standart olarak işlenebilirken `.csv` veya `.json` dosyalarını işlemek için ek kütüphanelere ihtiyaç vardır. `import csv` ile `.csv` dosyası işlemlerini, `import json` ile `.json` dosyası işlemlerini yapabilirsiniz. Bunlar haricinde görüntü dosyaları da ek kütüphaneler ile işlenebilmektedir." ] }, { "cell_type": "markdown", "id": "912fea7a-002d-45fc-a0c1-a6d662855527", "metadata": {}, "source": [ "# Veritabanı (Database) İşlemleri\n", "**Veritabanı:** Elektronik olarak depolanan, yapılandırılmış bilgi veya verilerden oluşan düzenli veri kolesiyonudur. Veritabanı genelde satır ve sütunlardan oluşan ilişkisel tablolardır.
\n", "**Veritabanı Yönetim Sistemi:** Veritabanını yönetmek (oluşturma, erişme, organize etme, güvenliğini sağlama, bilgi ekleme, alma veya güncelleme vb. işler) için kullanılan yazılımlardır.
\n", "**SQL (Structured Query Language):** Veritabanı yönetim yazılımlarının standart olarak kullandığı 'sorgu' dilidir. Veritabanında 'sorgu'lar aracılığıyla bilgiler ekleyebilir, kaldırabilir, güncelleyebilir, arayabilir veya yeni tablolar oluşturabiliriz.

\n", "Örneğin bir `.txt` dosyasına şu bilgileri yazdığımızı düşünelim:

\n", "*\"29 Ekim 1923 Tarihinde kurulan Türkiye Cumhuriyetinin başkenti kurulduğundan beri Ankara'dır. 1299 Yılında kurulan Osmanlı Devletinin son başkenti ise İstanbul olmuştur.\"*
\n", "Burada yazan bilgileri Anadolu coğrafyasında kurulmuş tüm devletler için yazdığımızı düşünelim. Bu bilgiler yapılandırılmamış bir şekildedir ve bu bilgileri projelerimizde kullanmak için yapılandırmamız gerekir. Bu bilgileri şöyle yapılandırdığımızı düşünelim:

\n", "**`DEVLET ADI,KURULUŞ YILI,BAŞKENT`**
\n", "`Türkiye Cumhuriyeti,1923,Ankara`
\n", "`Osmanlı Devleti,1299,İstanbul`

\n", "Bu şekilde daha yapılandırılmış gibi oldu. Bu bilgileri kullanışlı bir hale getirmenin bir diğer yolu da **tablo** haline getirmektir.
\n", "|**DEVLET ADI**|**KURULUŞ YILI**|**BAŞKENT**|\n", "|:-|:-:|:-|\n", "|Türkiye Cumhuriyeti|1923|Ankara|\n", "|Osmanlı Devleti|1299|İstanbul|" ] }, { "cell_type": "markdown", "id": "fe438049-1640-41cb-a52c-1eacee6975fa", "metadata": {}, "source": [ "İşte verileri daha elverişli bir şekilde kullanabilmek için onları veritabanı şeklinde yapılandırarak yönetmekten geçiyor. Python bunun için standart bir modüle sahiptir. Python'daki `sqlite3` modülü ile veritabanı yönetim işlemlerini işleyeceğiz. Python'da **`import sqlite3`** ile veritabanı yönetim sistemini doğrudan projelerimize dahil edebiliriz.
\n", "**SQLite3 ile Yönetebileceğimiz Veri Tipleri:**
\n", "- TEXT - Karakter Dizisi (String)\n", "- INTEGER - Tamsayı (Integer)\n", "- REAL - Ondalıklı Sayı (Float)\n", "- BLOB - İkili (Binary) (Bytes)\n", "- NULL - Değersiz (NonType)" ] }, { "cell_type": "markdown", "id": "b988168f-2b31-4fe5-8c78-70f8184ccfcf", "metadata": {}, "source": [ "Pyhton sqlite3 modülü ile `.sqlite3 , .sqlite , .db , .db3` uzantıya sahip veritabanı dosyalarını açabilir veya oluşturabiliriz. Burada `.db , .db3` ile daha büyük(çok) ve farklı tipteki verilerden (boolean, datetime vb.) oluşan veritabanları yönetilebilir. Fakat doğrudan çalıştığı işletim sisteminin Windows olması dezavantajdır. Fakat `.sqlite , .sqlite3` ile daha küçük çapta veritabanları ile yukarıda saydığımız veri tipleri yönetilebilir. Ayrıca çapraz platformdur. Yani sqlite her platformda (windows, linux, andorid, ios vb.) doğrudan çalışır. Bu sebeple burada yapacağımız örneklerde hangisini kullanırsak kullanalım bir fark bizim açımızdan olmaz. Eğer bir proje hazırlıyorsanız, projeye göre veritabanı dosya türünün ve yönetim sisteminin ne olması gerektiğine karar vermek için daha fazla bilgi sahibi olmanız gerekir.
\n", "Ayrıca burada yazdıklarımızın dışında da birçok veritabanı dosya türü mevcuttur. SQL ve NoSQL olarak farklı birçok seçenek projelere göre kullanılmaktadır." ] }, { "cell_type": "markdown", "id": "4e85ecdb-6168-4b02-a370-a91132443e60", "metadata": {}, "source": [ "## Connect() ile Veritabanını Oluşturma-Bağlanma, Close() ile Bağlantıyı Kapatma\n", "Bir **veritabanı oluşturmak ve ona bağlanmak için `.connect()`** metodu kullanılır. Eğer bağlanmaya çalıştığımız **veritabanı mevcut ise onu oluşturmaz sadece bağlanır.** Veritabanının oluştuğu yer varsayılan olarak python dosyasının yürütüldüğü dizindir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "c0411bc3-42d9-45ed-8279-ceb1755ea8c0", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "#Python dosyamızı çalıştırdığımız dizindeki veritabanına bağlanalım. Eğer böyle bir dosya yoksa oluşturur ve bağlanır.\n", "baglanti = sqlite3.connect('havadurumu.sqlite')\n", "\n", "#bağlantıyı kapatır\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "4a8668cd-2f68-45af-a6ed-399083d3e193", "metadata": {}, "source": [ "Şu an bir veritabanı dosyası -eğer mevcut değilse- oluşturduk ve bağlandık. Veritabanı ile **bağlantıyı kapatmak için `.close()` metodu kullanılır.** Bir dosyayı kapatmanın önemini 'Dosya İşlemleri' konusunda ifade etmiştik. Aynı önem veritabanı bağlantıları için de geçerlidir.

\n", "Bu ifadeyi `with` deyimi ile de kullanabiliriz. Veritabanlarını `with` deyimiyle kullanırsak blok bitince **dosyadaki değişiklikler otomatik olarak uygulanır.** Fakat dosya otomatik olarak kapanmaz." ] }, { "cell_type": "code", "execution_count": null, "id": "bda75118-08c0-4fec-b2b4-cc1f1e8eb80f", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " pass\n", "#bağlantıyı kapatır\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "d2e5e2a1-6e7b-472e-9f6e-8f430e988297", "metadata": {}, "source": [ "Eğer siz bir dizin yolu belirterek `.connect()` yaparsanız o dizindeki veritabanını açar veya oluşturur. **Var olmayan bir dizin için hata yükselir.** Bu sebeple varolan bir dizin yolu girmemiz önemlidir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "a492d546-6e50-46c4-b804-1f5bd63da680", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('D:\\OrnekVeriTabanlari\\havadurumu.sqlite') as baglanti:\n", " pass\n", "#bağlantıyı kapatır\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "468866e1-3b61-488c-a135-382b15877b41", "metadata": {}, "source": [ "Disk üzerinde bir dosya oluşturmak istemiyorsak Python ile RAM Bellek üzerinde, yani bağlantının çalıştığı sürece varolan, bağlantının kapatılmasıyla kaybolan bir veritabanı da oluşturabilirsiniz. Bu ilk başta faydasız gibi görünse de veritabanı üzerinde işlem yapmadan önce onun bir kopyası üzerinden işlem yapmak verilerinizi korur. Yahut bir veriyi veritabanına işlemeden önce onun üzerinde çeşitli dönüşümler yapmak ve sonrasında kaydetmek için önemlidir. Bellek içi veritabanı bağlantısı optimizasyon ve çeşitli çözümler (güvenlik vb.) sağlar.
\n", "**RAM bellek üzerinde 'geçici' bir veritabanı bağlantısı oluşturmak için** `.connect(':memory:')` **parametresi ile kullanılır.**" ] }, { "cell_type": "code", "execution_count": null, "id": "1426b147-57bd-487f-829a-75cc8ea1e767", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect(':memory:') as baglanti:\n", " pass" ] }, { "cell_type": "markdown", "id": "46514d9f-0055-4699-8d50-4370802786c1", "metadata": {}, "source": [ "Burada dikkat etmeniz gereken durum bağlantı kapatıldığı anda veritabanının kaybolmasıdır. `with` deyimi ile veritabanı bağlantısı yapınca bloktan çıktığımız anda kapatılacağı için kaybolacağını düşünmemiz gerekir. Eğer bundan kaçınmak istiyorsak `with` deyimi olmadan işlemlerimizi yapmalıyız. RAM Bellekte geçici veritabanı oluşturabildiğimiz gibi disk üzerinde de geçici şekilde oluşturabiliriz.
\n", "**Disk üzerinde 'geçici' bir veritabanı bağlantısı oluşturmak için** `.connect('')` **parametresi ile kullanılır.** Bu şekilde disk üzeride geçici bir bağlantı açılmış olur." ] }, { "cell_type": "code", "execution_count": null, "id": "5e79a10f-d2b2-45c5-8c9f-2a2f69fc3870", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('') as baglanti:\n", " pass" ] }, { "cell_type": "markdown", "id": "f775a4a4-bb5a-4f8d-b8c6-5eb2d6e22614", "metadata": {}, "source": [ "Aynı şekilde bağlantının kapandığı anda oluşan veritabanı kaybolur." ] }, { "cell_type": "markdown", "id": "a5dbd1f7-c2ab-47ca-8394-3d6bb85f2ee6", "metadata": {}, "source": [ "## Cursor() ile Veritabanında İmleç Oluşturma\n", "Veritabanında herhangi bir işlem (ekleme,çıkarma,güncelleme vb.) yapmak için **öncelikle 'imleç' oluşturmak gerekir.** Bunun için de **`.cursor()`** metodu kullanılır. Tablo oluşturma, veri ekleme vb. işlemler için 'imleç' veritabanında satır satır işlem yapma olanağını sağlar. Veritabanında yapılan sorguya dönen sonuçlardan sadece birkaçını işlemek için bütün sonuçları ele almak (ağ trafiği düşünüldüğünde) zaman alıcı ve verikaybı riski oluşturabileceği için imleç oluşturarak satır satır ele almanın daha işlevsel olduğu düşünülebilir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "7f3cda07-9417-48df-baad-815e63ccebdc", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor()\n", " pass\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "fe612c4c-0afa-444d-9cbe-ac4d9b27f790", "metadata": {}, "source": [ "Burada şu bilgiyi de vermek gerekir. Python SQLite3 modülü veritabanı işlemleri için çalıştırdığımız `.execute()` gibi *(`.executemany() , .executescript() vb.`)* bağlantı metodları için **otomatik olarak bir imleç oluşturur.** Ayrıca `.cursor()` ile imleç oluşturmanız genelde gereksiz olur. Fakat bizler Python dışındaki genel yapıya hakim olmak için örneklerimizde imleç oluşturalım." ] }, { "cell_type": "markdown", "id": "7477ac80-00da-4597-b62f-ee3d5097e41f", "metadata": {}, "source": [ "## Commit() ile Değişikliklerin Uygulanması\n", "Sqltie veritabanlarını `DB Browser for SQLite` programı ile görüntüleyebilirsiniz. Eğer kullandığınız platforma uygun bir sürüm bulamazsanız https://sqliteonline.com/ sitesinden çevrimiçi olarak kullanıp veritabanınızı görüntüleyebilirsiniz.

\n", "Python'da veritabanında yürüttüğümüz **işlemlerin veritabanına işlenmesi için `.commit()` ile uygulanması gerekir.** Eğer `.commit()` ile uygulamazsak işlemler veritabanına uygulanmaz ve biz `DB Browser for SQLite` programı ile açıp bakarsak işlemlerin gerçekleşmediğini görürüz." ] }, { "cell_type": "code", "execution_count": null, "id": "4639f927-1219-4c77-a55c-ce15c2366ffa", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "#Python dosyamızı çalıştırdığımız dizindeki veritabanına bağlanalım. Eğer böyle bir dosya yoksa oluşturur ve bağlanır.\n", "baglanti = sqlite3.connect('havadurumu.sqlite')\n", "\n", "#Burada işlemler yaptığımızı varsayalım\n", "pass\n", "\n", "#İşlemleri veritabanına uygulayalım\n", "baglanti.commit()\n", "\n", "#bağlantıyı kapatır\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "7a120136-9c30-46d0-9bff-3acca75fcc05", "metadata": {}, "source": [ "Bununla birlikte Python'da **`with` deyimi ile veritabanı bağlantısını açtığınızda blok bitince yürüttüğünüz işlemler otomatik uygulanır.** Yani `self.commit()` çalışır.
\n", "`with` deyimi ile veritabanına bağlandıysanız `.commit()` kullanmanız gereksiz olur. Eğer `with` deyimi olmadan veritabanında işlemler yaptıysanız `.commit()` metodu ile bağlantıya uygulamanız gerekir.

\n", "**`with` deyimi kullanmanın artı ve eksi yönleri vardır.** Veritabanında işlem yürütmek ve uyglamak hassas bir iştir. Yanlış bir işlem yürütmenizle bütün verileriniz kaybolabilir veya değişebilir ve bunu geriye döndüremezsiniz. Bu sebeple bazı işlemleri kontrol (`if`) bloğu ile kontrol ederek veritabanına uygulamak istiyorsanız **`with` deyimi kullanmamalısınız.** Kısacası `with` deyimi ihtiyaca yönelik kullanılmalıdır." ] }, { "cell_type": "markdown", "id": "5d7c43a2-6e58-4ffd-ab8d-8f6aba977aea", "metadata": {}, "source": [ "## Execute() ile Veritabanında İşlem Yürütme (Tablo Oluşturma, Veri Ekleme vb.)\n", "Veritabanında **herhangi bir işlem (ekleme,çıkarma,güncelleme vb.) yürütmek için `.execute()`** metodu kullanılır. **Veritanbanında işlem yürütmek için SQL ifadeleri (sorgular) yürütülür.** `.execute()` metodu ile veritabanımızda SQL sorgularını ve ona bağımlı parametreleri yürütebiliriz. `.execute()` metodunun kendine ait alt fonksiyonları (yani metodları) da vardır. Şimdi bunlara geçelim.
\n", "### Veritabanına Tablo ve Sütunlar Ekleme (CREATE TABLE ...)\n", "Veritabanında tabloları **`CREATE TABLE Tablo_Adi (Sutun_Adlari)`** SQL sorgusunu `.execute()` metoduyla yürüterek oluştururuz. Eğer veritabanımızda oluşturmak istediğimiz **tablo zaten mevcut ise hata yükselir.** Bundan kaçınmak için sorgu cümlemizi **`CREATE TABLE IF NOT EXISTS Tablo_Adi (Sutun_Adlari)`** şeklinde 'EĞER MEVCUT DEĞİLSE (IF NOT EXISTS)' olarak ifade etmemiz gerekir. Bu kısımda artık SQL sorgu cümle yapılarını da yavaş yavaş tanıyacağız. Şimdi veritabanımızda bir tablo oluşturalım." ] }, { "cell_type": "code", "execution_count": null, "id": "baf57f4c-eb80-4de5-b57e-38dba55c1957", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # SQL'de oluşturma, ekleme, silme, güncelleme vb. tüm işlemler için 'sorgu'lar yazlır.\n", " #TABLO oluşturmak için SQL 'sorgu'su yazalım. Sorgumuzu bir string'e atayalım.\n", " tablo =\"\"\" CREATE TABLE IF NOT EXISTS HavaDurumu (\n", " Tarih TEXT NOT NULL,\n", " Sehir TEXT NOT NULL,\n", " Sicaklik_Dusuk INTEGER NOT NULL,\n", " Sicaklik_Yuksek INTEGER NOT NULL,\n", " Gokyuzu TEXT\n", " )\n", " \"\"\"\n", " imlec.execute(tablo) #İmleç ile SQL Sorgumuzu veritabanımızda yürüttük ve tablo oluşturduk.\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "2e4fd037-2a8f-4460-ab3d-035193f35b31", "metadata": {}, "source": [ "Yukarıda `tablo` değişkenine atadığımız string bir **tablo oluşturmak ve sütun eklemek için yazılmış SQL sorgusudur.** Bu sorguda dikkat etmeniz gereken yerler:\n", "- SQL'a ait komutlar büyük harfle yazılır (elzem değil, sadece okunurluğu artırır).\n", "- Türkçe ve özel karakterler **kullanılmadan** tablo ve sütun isimleri oluşturulur. İlla kullanılacaksa tırnak içinde yazılmalıdır.\n", "- Veritabanındaki tabloya ait sütunlar ve satırlar `tuple` veri tipindedir.\n", "- Veritabanında oluşturacağımız tablo (bu örnekte 'HavaDurumu') mevcut ise oluşturamaz ve hata verir. Bu sebeple **hata yükselmemesi için `IF NOT EXISTS` ifadesi** kullanılır.\n", "- Sütuna ait **verilerin boş geçilemeyeceği `NOT NULL`** ile ifade edilir. Bu tabloda sadece 'Gokyuzu' sütununa veri girmenin zorunlu olmadığı ifade edilmiştir." ] }, { "cell_type": "markdown", "id": "855df892-600c-4ea4-8096-7f07ec9b550d", "metadata": {}, "source": [ "SQLite için basit tablo oluşturma ve sütun ekleme sorgusu yukarıdaki gibidir.
\n", "Bu ifadeyi dinamik bir şekilde ayrı ayrı yazarak `.execute()` ile de yürütebiliriz. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "e8fba0fc-f872-414b-84d1-99cb59b8c5e5", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # SQL'de oluşturma, ekleme, silme, güncelleme vb. tüm işlemler için 'sorgu'lar yazlır.\n", " #TABLO oluşturmak için SQL 'sorgu'su yazalım. Sorgumuzu bir string'e atayalım.\n", " \n", " tabloAdi = \"HavaDurumu\"\n", " sutunlar= [\"Tarih TEXT NOT NULL\",\n", " \"Sehir TEXT NOT NULL\",\n", " \" Sicaklik_Dusuk INTEGER NOT NULL\",\n", " \"Sicaklik_Yuksek INTEGER NOT NULL\",\n", " \"Gokyuzu TEXT\"]\n", " sorgu = f\"CREATE TABLE IF NOT EXISTS {tabloAdi} ({','.join(sutunlar)})\"\n", " \n", " #İmleç ile SQL Sorgumuzu veritabanımızda yürüttük ve tablo oluşturduk.\n", " imlec.execute(sorgu)\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "a00d8f0c-6c98-4d7e-83a4-3415a47478bb", "metadata": {}, "source": [ "Yukarıda **yazdığımız SQL sorgu sözdizimi (syntax) SQLite içindir.** MySQL, MS SQL, MariaDB, OracleDB, MongoDB, PostgreSQL gibi farklı birçok veritabanı yönetim sistemi vardır. **Tüm sistemlerinin SQL sorgu sözdizimi temel olarak birbirine çok benzese de bazı farklarla sözdizimleri (syntax) birbirinden farklıdır.**" ] }, { "cell_type": "markdown", "id": "15345752-f9dd-4f98-8d5a-f7c150978368", "metadata": {}, "source": [ "### Veritabanındaki Sütunlara Veri Ekleme (INSERT INTO ... VALUES ...)\n", "Veritabanındaki tablolara veriler **`INSERT INTO Tablo_Adi (Sutun_Adlari) VALUES (Veriler)`** ile eklenebilir. Sütun adlarını girmek zorunlu değildir. Sütun adları kısmı eklenmezse varsayılan olarak tablodaki tüm sütunları sırasıyla ele alır. Bu sebeple tablodaki sıralamayı da bilmek gerekir yoksa yanlış işlemlere sebep olabiliriz. Biz genel yapıya uygun olarak sütun adlarını vererek verileri ekleyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "3cab7208-6fb8-4b74-ae64-3b5f5f3113c3", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " #TABLO oluşturmak için SQL 'sorgu'su yazalım. Sorgumuzu bir string'e atayalım.\n", " tablo =\"\"\" CREATE TABLE IF NOT EXISTS HavaDurumu (\n", " Tarih TEXT NOT NULL,\n", " Sehir TEXT NOT NULL,\n", " Sicaklik_Dusuk INTEGER NOT NULL,\n", " Sicaklik_Yuksek INTEGER NOT NULL,\n", " Gokyuzu TEXT\n", " )\n", " \"\"\"\n", " imlec.execute(tablo) #İmleç ile SQL Sorgumuzu veritabanımızda yürüttük ve tablo oluşturduk.\n", " \n", " # Şimdi 'ekleme' işlemi için SQL Sorgumuzu yazalım ve 'execute' ile veritabanımızda imleç aracılığıyla yürütelim.\n", " imlec.execute(\"\"\"INSERT INTO HavaDurumu (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu) VALUES\n", " (\"2023.01.01\",\"İSTANBUL\",7,13,\"Parçalı Bulutlu\")\n", " \"\"\")\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "a2aa22f2-9131-483c-ade0-f6585c6258f3", "metadata": {}, "source": [ "Yukarıdaki örnekte sütun adları verilerek veri eklendi. Sütun adlarını tablodaki sırasına göre yazmamıza gerek yok. Fakat verileri işlerken sütun adında belirttiğimiz sütuna veriyi ekler. Mesela yukarıdaki örnekte biz sütun adlarında **'Tarih' ile 'Sicaklik_Yuksek' sütunlarının yerlerini değiştirirsek** alttaki 'VALUES' yazan **değerlerde de '2023.01.01' ile '13'ün de yerini değişmemiz gerekir.** Yoksa '2023.01.01'i 'Sicaklik_Yuksek', 13'ü 'Tarih' olarak kaydeder. Yani:
\n", "`imlec.execute(\"\"\"INSERT INTO HavaDurumu (Sicaklik_Yuksek,Sehir,Sicaklik_Dusuk,Tarih,Gokyuzu) VALUES`\n", "`(13,\"İSTANBUL\",7,\"2023.01.01\",\"Parçalı Bulutlu\")\n", "\"\"\")`\n", "olarak yazılırsa da olur.

\n", "Tabloya ekleyeceğimiz verileri sabit bir ifade ile değil de değişken ile dinamik bir şekilde de atayabiliriz. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "ae31c2ca-62c7-4454-ac80-b1bd5e5bdde3", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " #TABLO oluşturma\n", " tabloAdi = \"HavaDurumu\"\n", " sutunlar= [\"Tarih TEXT NOT NULL\",\n", " \"Sehir TEXT NOT NULL\",\n", " \"Sicaklik_Dusuk INTEGER NOT NULL\",\n", " \"Sicaklik_Yuksek INTEGER NOT NULL\",\n", " \"Gokyuzu TEXT\"]\n", " olustur = f\"CREATE TABLE IF NOT EXISTS {tabloAdi} ({','.join(sutunlar)})\"\n", " imlec.execute(olustur) #İmleç ile SQL Sorgumuzu veritabanımızda yürüttük ve tablo oluşturduk.\n", " \n", " #Şimdi ekleme sorgumuzu dinamik bir şekilde (VALUES'den sonra sütun sayısı kadar '?' koyarak) yazalım.\n", " ekle = f\"INSERT INTO {tabloAdi} (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu) VALUES (?,?,?,?,?)\"\n", " \n", " #Şimdi sorgumuza iliştireceğimiz verileri tuple olarak sorgumuzdaki tablo sırasına göre yazalım.\n", " veri = (\"2023.01.10\",\"ANKARA\",2,9,\"Çok Bulutlu\")\n", " \n", " # Şimdi imleç kullanarak sorgu aracılığıyla verileri ekleyelim.\n", " imlec.execute(ekle,veri)\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "7ab43eaa-b7cc-4999-b57c-5d583eb94099", "metadata": {}, "source": [ "Hem sorgumuzu hem de verilerimizi dinamik bir şekilde eklemiş olduk. Bunlardan hangisini dinamikleşmesi işinize geliyorsa o şekilde kullanabilirsiniz.
Şimdi bir veri setini (birçok veriyi) for döngüsü ile işleyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "5d146fc1-edfc-4e95-9f42-14bb485ad87e", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " #TABLO oluşturma\n", " tabloAdi = \"HavaDurumu\"\n", " sutunlar= [\"Tarih TEXT NOT NULL\",\n", " \"Sehir TEXT NOT NULL\",\n", " \"Sicaklik_Dusuk INTEGER NOT NULL\",\n", " \"Sicaklik_Yuksek INTEGER NOT NULL\",\n", " \"Gokyuzu TEXT\"]\n", " olustur = f\"CREATE TABLE IF NOT EXISTS {tabloAdi} ({','.join(sutunlar)})\"\n", " imlec.execute(olustur) #İmleç ile SQL Sorgumuzu veritabanımızda yürüttük ve tablo oluşturduk.\n", " \n", " #Şimdi ekleme sorgumuzu dinamik bir şekilde (VALUES'den sonra sütun sayısı kadar '?' koyarak) yazalım.\n", " ekle = f\"INSERT INTO {tabloAdi} (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu) VALUES (?,?,?,?,?)\"\n", " \n", " #Şimdi tablomuza ekleyeceğimiz veri setini tuple'lardan oluşan bir liste olarak sorgumuzdaki tablo sırasına göre yazalım.\n", " veriler = [(\"2023.01.04\",\"İSTANBUL\",5,9,\"Bulutlu\"),\n", " (\"2023.01.05\",\"İSTANBUL\",4,10,\"Parçalı Bulutlu\"),\n", " (\"2023.01.06\",\"İSTANBUL\",7,11,\"Az Bulutlu\"),\n", " (\"2023.01.04\",\"ANKARA\",3,7,\"Bulutlu\"),\n", " (\"2023.01.05\",\"ANKARA\",2,6,\"Çok Bulutlu\"),\n", " (\"2023.01.04\",\"İZMİR\",9,13,\"Parçalı Bulutlu\"),\n", " (\"2023.01.06\",\"BURSA\",5,11,\"Parçalı Bulutlu\"),\n", " (\"2023.01.07\",\"KONYA\",1,13,\"Açık\")]\n", " \n", " # Şimdi for döngüsü ve imleç aracılığıyla verileri ekleyelim.\n", " for veri in veriler: imlec.execute(ekle,veri)\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "e3def9c7-344b-4be8-b1ae-d1bba223401d", "metadata": {}, "source": [ "## Fetch Metodları ile Veritabanından Veri Getirme İşlemleri\n", "Veritabanındaki tablo ile verileri okumak, seçmek ve bunlar üzerinde işlemler yapmak için **yazdığımız sorgularımızın sonuçlarını gidip getiren `fetch` metodlarını** kullanırız. Bunlardan:\n", "- **`.fetchall()`** metodu, sorgumuzun bütün sonuçlarını **(bütün satırları) liste olarak** getirir.\n", "- **`.fetchone()`** metodu, sorgumuzun bütün sonuçlarından **her bir satırı sırayla** getirir. Her çalıştığında bir sonraki satırı getirir.\n", "- **`.fetchmany(n)`** metodu, sorgumuzun bütün sonuçlarından **istediğimiz kadar satırını (n) liste olarak sırayla** getirir. Her çalıştığında bir sonraki satırları (n) liste olarak getirir." ] }, { "cell_type": "code", "execution_count": null, "id": "6be5f183-407d-4e3c-97b5-8d2246e058d3", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor()\n", " imlec.execute(\"SQL Sorgusu\")\n", " \n", " # Fetch metodları sorgunun '.execute()' edilmesine bağlıdır. \n", " # Bir sorgu veritabanında yürütülmezse fetch metodları boş olarak döner.\n", " # Aynı şekilde yürttüğümüz sorgunun bir sonucu olmazsa yine boş olarak döner.\n", " gelenVeriler = imlec.fetchall()\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "197fa866-40df-4e2b-8dbd-1c9919091128", "metadata": {}, "source": [ "- Fetch metodları bir sorgunun yürütülmesi (execute) sonucunda oluşan verileri getirebilir.\n", "- Veritabanında bir sorgu yürütülmezse Fetch metodları boş değer döndürür.\n", "- Veritabanında yürüttüğümüz sorgu hiçbir veriyle eşleşmezse yine boş değer döndürür. (Örneğin elmaların içinde armut ararsanız)\n", "
\n", "Veritabanımızdan veri getirmek için veri seçecek veya süzecek SQL sorgusu yazmamız gerekir. Öncelikle bu SQL sorgularına eğilerek fetch metodlarını örneklendirelim." ] }, { "cell_type": "markdown", "id": "e36d6cc9-ee5e-4ea1-8d4c-4b45b060b5d0", "metadata": {}, "source": [ "### Veritabanındaki Sütunları Seçme (SELECT ... FROM ...)\n", "Bir veritabanından veri seçecek olan 'temel' SQL sorgusu **`SELECT Sutun_Adi FROM Tablo_Adi`** olarak yazılır. Örnek verelim.
\n", "**NOT: Eğer bir önceki adımda tablo oluşturup veri eklediyseniz 'TABLO Oluşturma ve Veri Ekleme Satırlarını' kodlarınıza yazmayınız.**" ] }, { "cell_type": "code", "execution_count": null, "id": "50602399-09d8-473e-86fa-7499de728da1", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor()\n", " #TABLO oluşturma ve Verileri Ekleme\n", " tabloAdi = \"HavaDurumu\"\n", " sutunlar= [\"Tarih TEXT NOT NULL\",\n", " \"Sehir TEXT NOT NULL\",\n", " \"Sicaklik_Dusuk INTEGER NOT NULL\",\n", " \"Sicaklik_Yuksek INTEGER NOT NULL\",\n", " \"Gokyuzu TEXT\"]\n", " olustur = f\"CREATE TABLE IF NOT EXISTS {tabloAdi} ({','.join(sutunlar)})\"\n", " imlec.execute(olustur)\n", " ekle = f\"INSERT INTO {tabloAdi} (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu) VALUES (?,?,?,?,?)\"\n", " veriler = [(\"2023.01.04\",\"İSTANBUL\",5,9,\"Bulutlu\"),\n", " (\"2023.01.05\",\"İSTANBUL\",4,10,\"Parçalı Bulutlu\"),\n", " (\"2023.01.06\",\"İSTANBUL\",7,11,\"Az Bulutlu\"),\n", " (\"2023.01.04\",\"ANKARA\",3,7,\"Bulutlu\"),\n", " (\"2023.01.05\",\"ANKARA\",2,6,\"Çok Bulutlu\"),\n", " (\"2023.01.04\",\"İZMİR\",9,13,\"Parçalı Bulutlu\"),\n", " (\"2023.01.06\",\"BURSA\",5,11,\"Parçalı Bulutlu\"),\n", " (\"2023.01.07\",\"KONYA\",1,13,\"Açık\")]\n", " for veri in veriler: imlec.execute(ekle,veri)\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalım. Şehir sütununu seçelim.\n", " imlec.execute(\"SELECT Sehir FROM HavaDurumu\")\n", " sehirler = imlec.fetchall()\n", " # Fetchall ile seçtiğimiz Sehir sütunundaki tüm satırları 'sehirler' değişkenine atadık. Şimdi sırayla ekrana yazdıralım.\n", " for sehir in sehirler: print(sehir)\n", " \n", " # Bu kod ile ekranımızda 3 tane İSTANBUL 2 tane ANKARA 1'er tane İZMİR, BURSA ve KONYA yazmış olması lazım.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "68bbc5b5-e0d9-45f6-9982-a6a2fc2af7c3", "metadata": {}, "source": [ "Burada tek bir sütun elde etttik. İstediğimiz birkaç sütunu elde etmek için sorgumuzu şu şekilde değiştirip yeniden çalıştırabiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "1ec50a01-f613-4e73-9d06-f01b9c161ed7", "metadata": {}, "outputs": [], "source": [ "imlec.execute(\"SELECT Tarih,Sehir,Gokyuzu FROM HavaDurumu\")" ] }, { "cell_type": "markdown", "id": "bda140a8-0e4e-4649-ae36-0269ef009c2e", "metadata": {}, "source": [ "Eğer tüm sütunları getirmek istiyorsak hepsini yazmak yerine **`*`** joker karakterini kullanmalıyız. En sık kullanılan joker karakterlerden **`*`** tek başına yazılırsa 'herşey' anlamına gelir. Şimdi sorgumuzu şu şekilde değiştirelim." ] }, { "cell_type": "code", "execution_count": null, "id": "eb255067-f09b-4dd4-a2ab-aca7baabc382", "metadata": {}, "outputs": [], "source": [ "imlec.execute(\"SELECT * FROM HavaDurumu\")" ] }, { "cell_type": "markdown", "id": "495aa47b-6372-46e4-a642-f975c2d71c9c", "metadata": {}, "source": [ "Bu sorguyu yürüttüğümüzde tablodaki tüm sütun ve satırların seçilmesi, `.fetchall()` ile de hepsini ekrana yazdırmış olmamız gerekir. Fakat binlerce veri içeren bir tablo ile çalıştığınızı düşündüğünüzde hepsini `fetch` metodu ile etmek mantıksızdır. Bunu `.fetchone()` metodunu kullanarak yapmak mümkün.\n", "\n", "**`.fetchone()` ile tüm sorgu sonucunu çekmeden teker teker sırayla getirebiliriz.** Mesela ilk 5 tanesini getirelim." ] }, { "cell_type": "code", "execution_count": null, "id": "10afb7dc-a740-4764-8562-fd794b5f8dc9", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalıWm. Tüm sütunları seçelim.\n", " imlec.execute(\"SELECT * FROM HavaDurumu\")\n", " # Fetchone ile her yürüttüğümüzde bir sonraki satır gelir.\n", " for satir in range(5): print(imlec.fetchone())\n", " \n", " # Bu kod ile ekranımızda tablomuzdaki ilk 5 satırı yazmış olması gerekir.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "528201be-db48-439b-bb70-ebc86204af09", "metadata": {}, "source": [ "Burada her bir sorguyu tek tek çağırarak döngü ile ekrana bastık. Eğer veritabanındaki satırlardan daha fazla sayıda döngü yaparsanız var olmayan her satır için 'None' değer döner, hata vermez. Verileri sabit artanlı bir şekilde çekeceksek **`.fetchmany()`** kullanılır.

\n", "**`.fetchmany()` ile tüm sorgu sonucundan istediğimiz sayıda sonucu sırayla getirebiliriz.** Mesela 3'erli olarak getirelim." ] }, { "cell_type": "code", "execution_count": null, "id": "02587649-8c07-4b52-beed-59dc9045395b", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalıWm. Tüm sütunları seçelim.\n", " imlec.execute(\"SELECT * FROM HavaDurumu\")\n", " # Fetchmany ile her yürüttüğümüzde bir sonraki satır dizisi gelir.\n", " print(imlec.fetchmany(3))\n", " print(imlec.fetchmany(3))\n", " \n", " # Bu kod ile ekranımızda tablomuzdaki ilk 5 satırı yazmış olması gerekir.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "b7f44893-5ef9-45aa-8558-9322a55b321b", "metadata": {}, "source": [ "Burada da veri tabanındaki satırlardan daha fazla sayıda veri çekerseniz olmayan her dizi için boş dizi ('[ ]') döner, hata vermez.

\n", "**`fetch`** metodları ile çektiğiniz veri tiplerini farketmişsinizdir. Bunları bir tablo olarak verelim.\n", "|**METOT**|**DÖNEN VERİ TİPİ**|**ÖRNEK**|**SATIR UZUNLUĞUNU GEÇİNCE**|\n", "|:-:|:-:|:-:|:-:|\n", "|`.fetchall()`|Liste (List), içindeki her eleman Demet (Tuple)| [('satır1_sutun1','satır1_sutun2'),('satır2_sutun1','satır2_sutun2')] |Boş Liste = [ ]|\n", "|`.fetchmany(n)`|Liste (List), içindeki her eleman Demet (Tuple)|[('satır1_sutun1','satır1_sutun2'),('satır2_sutun1','satır2_sutun2')]
[('satır3_sutun1','satır3_sutun2'),('satır4_sutun1','satır4_sutun2')] | Boş Liste = [ ]|\n", "|`.fetchone()`|Demet (Tuple)|('satır1_sutun1','satır1_sutun2')|None|" ] }, { "cell_type": "markdown", "id": "2e99b466-de05-48bf-92c6-cfe125ec6c77", "metadata": {}, "source": [ "### Veritabanındaki Sütunlardan Veri Süzme (SELECT ... FROM ... WHERE ...)\n", "Bir veritabanından veri seçecek olan 'temel' SQL sorgusuna 'WHERE' ekleyerek sütundaki verileri süzebiliriz.
\n", "Kullanımı **`SELECT Sutun_Adi FROM Tablo_Adi WHERE Sutun_Adi = Aranacak_Veri`** şeklindedir. Burada 'Aranacak_Veri' için karakter dizisi veya sayısal değerler gibi SQLite3'ün kabul ettiği veri tipleri girilir. Operatör olarak '=' yerine diğer sayısal operatörler (<,>,<=,>=,<>,!=) de kullanılabilirler.
**NOT: Eğer bir önceki adımda tablo oluşturmayıp veri eklemediyseniz 'TABLO Oluşturma ve Veri Ekleme Satırlarını' kodlarınıza ekleyiniz.**" ] }, { "cell_type": "code", "execution_count": null, "id": "1a17a4ae-3934-4b4e-aa98-96660d643893", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalıWm. Tüm sütunlardan Sehir sütununda İSTANBUL yazanları seçelim.\n", " imlec.execute(\"SELECT * FROM HavaDurumu WHERE Sehir='İSTANBUL'\")\n", " suzulenVeri = imlec.fetchall()\n", " for satir in suzulenVeri: print(satir)\n", " # Bu kod ile ekranımızda tablomuzdaki 'Sehir' sütununda 'İstanbul' yazan satırları süzdük.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "afd7272d-5b0b-46e9-9667-0f97b87d4a44", "metadata": {}, "source": [ "### Özel Süzme Operatörleri (AND, OR, NOT, LIKE, IN, BETWEEN)" ] }, { "cell_type": "markdown", "id": "76a0bddf-97d1-41c9-970d-a73577d1842a", "metadata": {}, "source": [ "Tablodaki verileri süzerken SQL sorgumuza **'VE (and), VEYA (or), DEĞİL (not)' gibi mantıksal operatörleri de ekleyebiliriz.** Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "90978271-5726-4e6a-87c5-d4d6bd0a3432", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalıWm.\n", " imlec.execute(\"\"\"SELECT * FROM HavaDurumu\n", " WHERE\n", " Sehir='İSTANBUL'\n", " AND\n", " Sicaklik_Dusuk > 5\"\"\")\n", " suzulenVeri = imlec.fetchall()\n", " for satir in suzulenVeri: print(satir)\n", " # Bu kod ile ekranımızda tablomuzdaki 'Sehir' sütununda 'İstanbul' yazan VE 'Sicaklik_Dusuk' degeri 5'ten büyük olan satırları süzdük.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "3778eb93-a703-466e-8658-bfd52df137f5", "metadata": {}, "source": [ "**`LIKE`** ifadesini **`WHERE`** ile birlikte kullanarak joker karakter gibi işlemler yapabiliriz. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "36cbe54b-fa89-4ee0-8ca1-cdcb0142e8e4", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalıWm.\n", " imlec.execute(\"\"\"SELECT * FROM HavaDurumu\n", " WHERE\n", " Sicaklik_Yuksek > 11\n", " OR\n", " Sehir LIKE '%K%'\"\"\")\n", " suzulenVeri = imlec.fetchall()\n", " for satir in suzulenVeri: print(satir)\n", " # Tablomuzdaki 'Sicaklik_Yuksek' sütununda degeri 11'den büyük olanlar VEYA 'Sehir' içinde 'K' harfi olanları süzdük.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "d35bb1e0-6a53-4bc4-bb9a-741f8f63ae42", "metadata": {}, "source": [ "Bu sorgulardaki yazım bir zorunluluk olmayıp okunurluğu artırmak için bu şekilde yazılmıştır.
\n", "**`IN`** ifadesini **`WHERE`** ile birlikte kullanarak, bir sütunda 'içerenleri' veya 'içermeyenleri' seçebiliriz." ] }, { "cell_type": "code", "execution_count": null, "id": "9286bdc1-4dba-4da7-9933-6fb677960683", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalıWm.\n", " imlec.execute(\"\"\"SELECT * FROM HavaDurumu\n", " WHERE\n", " Tarih LIKE '%2023%'\n", " AND NOT\n", " Sehir IN ('ANKARA','BURSA')\"\"\")\n", " suzulenVeri = imlec.fetchall()\n", " for satir in suzulenVeri: print(satir)\n", " # Tablomuzdaki 'Tarih' sütununda degeri '2023' içerenleri VE 'Sehir' içinde 'ANKARA' ve 'BURSA' OLMAYANLARI süzdük.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "a2ad7e8b-389a-4c84-863a-50ce5728118a", "metadata": {}, "source": [ "**`BETWEEN`** ifadesini **`WHERE`** ile birlikte kullanarak, bir sütunda 'arasındakileri' seçebiliriz. Mantıken sayısal değerler için kullanılır." ] }, { "cell_type": "code", "execution_count": null, "id": "7f15e338-8c65-47d2-a63f-d8c6cbd954ef", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri süzecek SELECT'li SQL sorgumuzu yazalıWm.\n", " imlec.execute(\"\"\"SELECT * FROM HavaDurumu\n", " WHERE\n", " Sicaklik_Dusuk BETWEEN 1 AND 4\n", " AND\n", " Gokyuzu != 'Açık' \n", " \"\"\")\n", " suzulenVeri = imlec.fetchall()\n", " for satir in suzulenVeri: print(satir)\n", " # Tablomuzdaki 'Sicaklik_Dusuk' degeri 1 ile 4 arasında olanları VE 'Gokyuzu' değeri 'Açık' OLMAYANLARI süzdük.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "26b36877-e7ea-4549-8ffe-64914627d80d", "metadata": {}, "source": [ "### Veritabanındaki Verileri Güncelleme (UPDATE ... SET ... WHERE)" ] }, { "cell_type": "markdown", "id": "b381ba67-b22b-43b1-9706-655a6ddb447d", "metadata": {}, "source": [ "Bir **veriyi süzdükten sonra** ona ait değerleri değiştirebiliriz. Bunun için 'temel' olarak **`UPDATE Tablo_Adi SET Sutun_Adi = Yeni_Veri WHERE Sutun_Adi = Secilen_Sutun`** kullanılır. Fakat burada dikkat edilecek nokta **süzdüğümüz veri kaç satır ise hepsine bu işlemi uygular.**
\n", "**NOT: Eğer bir önceki adımda tablo oluşturmayıp veri eklemediyseniz 'TABLO Oluşturma ve Veri Ekleme Satırlarını' kodlarınıza ekleyiniz.**" ] }, { "cell_type": "code", "execution_count": null, "id": "ce4e8145-92f2-4c15-a149-c5e2b97e954f", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri güncelleyecek UPDATE'li SQL sorgumuzu yazalıWm.\n", " imlec.execute(\"\"\"UPDATE HavaDurumu\n", " SET\n", " Sicaklik_Dusuk = 9,\n", " Sicaklik_Yuksek = 13,\n", " Gokyuzu = 'Açık'\n", " WHERE\n", " Tarih = '2023.01.04'\n", " AND\n", " Sehir = 'İSTANBUL'\n", " \"\"\")\n", " \n", " #Şimdi veri tabanını tekrar süzerek okuyalım.\n", " imlec.execute(\"\"\"SELECT * FROM HavaDurumu WHERE Tarih = '2023.01.04' AND Sehir = 'İSTANBUL'\n", " \"\"\")\n", " print(imlec.fetchall())\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "0787f2f1-8b7b-4706-b918-de11c29d6d5b", "metadata": {}, "source": [ "Yukarıda süzdüğümüz veri veritabanımızda bir tane olduğu için sadece onu değiştirdi ama **çok satırlı veri süzülseydi hepsini değiştirecekti.** Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "401a62ed-5b8f-4fe5-8d00-8bc88e3c14e0", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri güncelleyecek UPDATE'li SQL sorgumuzu yazalıWm.\n", " imlec.execute(\"\"\"UPDATE HavaDurumu\n", " SET Gokyuzu = 'Çok Bulutlu'\n", " WHERE Tarih = '2023.01.04'\n", " \"\"\")\n", " \n", " #Şimdi veri tabanını tekrar süzerek okuyalım.\n", " imlec.execute(\"\"\"SELECT * FROM HavaDurumu WHERE Tarih = '2023.01.04'\n", " \"\"\")\n", " for satir in imlec.fetchall(): print(satir)\n", " # 2023.01.04 tarihine sahip tüm satırların Gokyuzu durumu \"Çok Bulutlu\" olarak değişmiş oldu.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "bd9dd646-9425-4b62-99d0-2a80bf7b763e", "metadata": {}, "source": [ "Esasında bu değişimler tablomuzda bir **`PRIMARY KEY`** (birincil anahtar) ile yapılır. 'PRIMARY KEY' için en bilinen örnek TC Numaramızdır. TC numaramız benzersiz bir anahtar olarak sadece bize aittir. Veritabanlarında o anahtar ile bize ait verilere başvurmuş oluruz. Başka bir örnekle, e-posta hesaplarımızın isimlerinden sadece bir tane vardır, benzersizdir ve bize ait verilere başvurulmasını sağlar. Bu konuya biraz ileride değinmek zorunda kalacağız." ] }, { "cell_type": "markdown", "id": "c8f70d5e-51cc-4b2e-824b-adf0b67a6c48", "metadata": {}, "source": [ "## Description, Row_Factory ve Sqlite_Master ile Veritabanındaki Tablo ve Sütun Başlıklarını Okuma\n", "Şimdiye kadar yaptığımız örneklerde veritabanındaki tablo ve sütun adlarını şema olarak bildiğimiz için rahatça kullanabilidik. Bilmesek bile 'SQLiteDatabaseBrowser' ile açıp içindeki tablo ve verileri görebiliyorduk. Bunlara gerek kalmadan yazdığımız kodlarla da bu bilgileri elde etmenin bir yolu var.
\n", "Her sqlite veritabanı dosyasında mevcut olan **`sqlite_master`** isminde veritabanının şemasını tutan bir tablo mevcuttur. Bu tablodan veritabanındaki tablolara erişebliriz. **`SELECT name FROM sqlite_master WHERE type='table';`** ifadesiyle kullanılır. Şimdi veritabanımızdaki tablo isimlerini öğrenelim." ] }, { "cell_type": "code", "execution_count": null, "id": "7f8b28a9-589b-4589-9384-f38a561e1c0b", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " #Şimdi veri tabanındaki anakayıttan tablo bilgilerini alalım.\n", " imlec.execute(\"SELECT name FROM sqlite_master WHERE type='table';\")\n", " for satir in imlec.fetchall(): print(satir)\n", " # Bir tane tablomuz olduğu için sadece onu gösterir. Fakat birkaç tablomuz mevcut olsaydı hepsini gösterirdi.\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "996bddc9-3bcc-48d8-a0f7-099c3eb9effe", "metadata": {}, "source": [ "Tablo isimlerini öğrendiğimize göre şimdi de sütun isimlerini öğrenelim. Sütun isimlerini öğrenmek için genelde kullanılan iki yöntem vadır.

\n", "**`.description`** bir 'SELECT' içeren sorgunun özniteliğidir (Nesne yaklaşımlı programlamadan hatırlayalım). Bu öznitelik ile yapılan son sorgunun sütun adları alınır. Farketmemiz gereken önemli nokta **`.description`** için bir imleç ve 'SELECT' ile sorgu yapmanın gerekliliğidir. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "46136076-dc38-4258-9642-b44f9fcaa657", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " #Şimdi veri tabanında sorgu yapalım.\n", " imlec.execute(\"SELECT * FROM HavaDurumu\")\n", " \n", " #Bir imleçle 'SELECT' içeren bir sorgu yaptık. Artık .description özniteliğine başvurabiliriz.\n", " tablolar = imlec.description\n", " # Şimdi bu tablolar sırayla ekrana yazdıralım\n", " for tablo in tablolar: print(tablo)\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "0e7cf844-76cc-430d-a9d0-345bee85607c", "metadata": {}, "source": [ "**`.description`** özniteliği her zaman 7 elemanlı bir **`TUPLE`** demeti döndürür. Her sütun başlığı 7 elemanlı **demetin ilk elemanıdır**. Bu sebeple ekrana yazdırırken dilimleyerek yazdıralım." ] }, { "cell_type": "code", "execution_count": null, "id": "557c9598-d5fc-472a-b8e2-9df42cf0609a", "metadata": {}, "outputs": [], "source": [ "for tablo in tablolar: print(tablo[0])" ] }, { "cell_type": "markdown", "id": "3c12df99-5264-4a7c-8890-0e816b0450af", "metadata": {}, "source": [ "**`.row_factory`** ise bir sqlite bağlantısının özniteliğidir. Bu özniteliği, sqlite3'ün **`.row`** adlı özniteliği ile kullanarak tablomuzdaki her satırı **`DICTIONARY`** (sözlük) formatında bir 'nesne'ye çeviririz. Bu 'nesne'nin anahtar (.keys()) değeri sütun adları olurken, değerleri ise satırımızdaki verilerdir ve **`LIST`** tipine çevrilebilir. Tabi yine bunun için de bir tabloya bağlanıp 'SELECT' ile sorgu yapmamız gerekliliktir." ] }, { "cell_type": "code", "execution_count": null, "id": "8d72d716-669d-416f-84eb-b953831f4517", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " \n", " # Bağlantımızın row_factory özniteliğini sqlite3'ün row özniteliği üzerinden bir nesne olarak atayalım (Dict'e benzeyen bir nesne).\n", " baglanti.row_factory = sqlite3.Row\n", " \n", " # Varsayılan olarak '.row_factory' özniteliği ile sadece satırdaki değerler 'tuple' olarak gelir. Bir önceki örneği hatırlayınız.\n", " # Bunun yerine satırdaki verileri ve sütun başlıklarını sutun_adlari ve satirdaki_veriler olarak dict'e benzer bir 'nesne' olarak elde etmek için:\n", " # sqlite3'ün '.Row' özniteliğine atadık. Artık her sorgumuzu '.Row' şeklinde ele alabileceğiz.\n", " # Burada her satırı dict' benzer şekilde ele almamızı sağlayan '.Row' özniteliğidir.\n", " # Neden 'dict'e benzer diyoruz da 'dict' diyemiyoruz. Çünkü 'dict'e ait '.get()', '.items()' gibi metotları kullanamazsınız.\n", " # Çünkü dict değil, benzer bir 'nesne'.\n", " \n", " \n", " imlec = baglanti.cursor()\n", " imlec.execute(\"SELECT * FROM HavaDurumu\")\n", " \n", " # Artık fetch ile sadece bir satır okumamız yeterli, çünkü her satır dict tipinde. Anahtar değerleri ise sütun adlarımız.\n", " satir = imlec.fetchone()\n", " \n", " # Şimdi bu dict'in anahtarlarını .keys() ile ekrana yazdıralım.\n", " print(satir.keys())\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "9263f376-8504-483c-9b23-8950380bc212", "metadata": {}, "source": [ "Burada `print (satir.keys())` ile sütun adlarını getirdik. Sadece `print(satir)` yazarsak belleğimizdeki bir nesnenin adresi gelir. Fakat `print(list(satir))` yazarsak satırımızdaki değerleri (values) liste olarak görebiliriz. Şimdi alta yazarak deneyelim." ] }, { "cell_type": "code", "execution_count": null, "id": "3bbb8e43-d287-41c1-85eb-824e84641748", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "9b5f4326-bfe8-4497-ba38-5c9e7afddfd2", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "b6909f7f-11dc-4326-bec9-0f7e4237e90d", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "raw", "id": "f7982a2c-4e63-4f06-9045-b52baf78dc5f", "metadata": {}, "source": [ "CREATE TABLE IF NOT EXISTS kullanicilar (\n", " e-posta TEXT PRIMARY KEY,\n", " isim TEXT NOT NULL,\n", " sifre TEXT NOT NULL,\n", " );" ] }, { "cell_type": "markdown", "id": "28911386-efa8-4f4f-ac35-97c1ebc94af9", "metadata": {}, "source": [ "**`PRIMARY KEY`** ile sileceğimiz veriyi benzersiz değerine göre süzerek doğru işlem yapmış oluruz. Ayrıca **`PRIMARY KEY`** ile alanın boş olamayacağını **`NOT NULL`** sağlamış olduk." ] }, { "cell_type": "code", "execution_count": null, "id": "c5af9ee6-0086-4b4e-84dc-849078610c72", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "bb3cd254-3611-401d-8379-35c387c2e577", "metadata": {}, "source": [ "### Veritabanındaki Verileri Değiştirme (REPLACE INTO ... VALUES ...)\n", "Bu işlem **`INSERT`** işleminin bir varyasyonu olup verileri süzme ifadesi eklemenize gerek kalmadan **`PRIMARY KEY`** mantığıyla başvurulan satırın aynısı anahtarın satırındaki tüm verileri değiştirmenize yarar.
\n", "**`REPLACE INTO Tablo_Adi (Primary_Key_Sutun_Adi, Diger_Sutun_Adi,...) VALUES (Primary_Key,Veri1,...) `** şeklinde kullanılır. Örnek:" ] }, { "cell_type": "code", "execution_count": null, "id": "d83f7e14-72cb-46c8-a9db-bb081c05e83b", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " # Şimdi veri güncelleyecek UPDATE'li SQL sorgumuzu yazalıWm.\n", " imlec.execute(\"\"\"REPLACE INTO HavaDurumu (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu)\n", " VALUES ('2023.01.07','KONYA',5,13,'Çok Bulutlu')\n", " \"\"\")\n", " \n", " #Şimdi veri tabanını tekrar süzerek okuyalım.\n", " imlec.execute(\"\"\"SELECT * FROM HavaDurumu\"\"\")\n", " for satir in imlec.fetchall(): print(satir)\n", " \n", "baglanti.close()" ] }, { "cell_type": "code", "execution_count": null, "id": "ff6d9375-5f3c-4b91-959e-1c75508ea9dd", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "47a31e0f-04cf-4580-a328-3ac9bce4324c", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "id": "8de79f01-c052-40b8-8637-7750fde07dbf", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "01d7f03b-7227-4a21-8bd7-94086cda0e94", "metadata": {}, "source": [ "## Executemany() ve Executescript() ile Çoklu İşlem Yürütme\n", "**`.executemany(sorgu,dongulenebilir_parametre)`** ile veri listemizi for döngüsü kullanmadan sql sorgusuna iliştirerek tabloya ekleyebiliriz. Bu metot esasında `.execute(sorgu,parametre)` metodunu içerir. Fakat `.executemany(sorgu,dongulenebilir_parametre)` ile veri listemiz otomatik döngüye alınır ve listemizdeki her bir veri sql sorgusuna iliştirilerek yürütülür. Hemen örnek verelim:" ] }, { "cell_type": "code", "execution_count": null, "id": "01f7f93f-7999-4fa6-bb2f-ba9ed11753fc", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " \n", " #TABLO oluşturma\n", " tabloAdi = \"HavaDurumu\"\n", " sutunlar= [\"Tarih TEXT NOT NULL\",\"Sehir TEXT NOT NULL\",\" Sicaklik_Dusuk INTEGER NOT NULL\",\"Sicaklik_Yuksek INTEGER NOT NULL\",\"Gokyuzu TEXT\"]\n", " olustur = f\"CREATE TABLE IF NOT EXISTS {tabloAdi} ({','.join(sutunlar)})\"\n", " imlec.execute(olustur) #İmleç ile SQL Sorgumuzu veritabanımızda yürüttük ve tablo oluşturduk.\n", " \n", " #Şimdi ekleme sorgumuzu dinamik bir şekilde (VALUES'den sonra sütun sayısı kadar '?' koyarak) yazalım.\n", " ekle = f\"INSERT INTO {tabloAdi} (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu) VALUES (?,?,?,?,?)\"\n", " \n", " #Şimdi tablomuza ekleyeceğimiz veri setini tuple'lardan oluşan bir liste olarak sorgumuzdaki tablo sırasına göre yazalım.\n", " veriler = [(\"2023.01.04\",\"İZMİR\",9,13,\"Bulutlu\"),\n", " (\"2023.01.16\",\"BURSA\",5,11,\"Parçalı Bulutlu\"),\n", " (\"2023.01.12\",\"KONYA\",1,13,\"Açık\")]\n", " \n", " # Şimdi döngü kullanmadan ve imleç aracılığıyla verileri ekleyelim.\n", " imlec.executemany(ekle,veriler)\n", " \n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "d3cec5b8-9c34-48a6-84a2-3b6f9d6c1e73", "metadata": {}, "source": [ "`.execute()` veya `.executemany()` ile **sadece bir sql sorgusu** yürütebilirsiniz. Yani hem tablo oluşturma hem de veri ekleme sql sorgularınızı tek bir string'e atayıp onu **`.execute(sorgu)`** ile yürütmemezsiniz. Bu metodlar sadece bir sql sorgusu içeren parametreleri yürütürler.

\n", "**`.executescript()` metodu ile çoklu sql sorgusunu içeren bir ifadeyi tek satırda yürütebilirsiniz.**" ] }, { "cell_type": "code", "execution_count": null, "id": "02c0abb7-3e7d-4f64-8282-74a2a8e86b82", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " # Çoklu SQL sorgumuzu yazalım. Sorgumuzu bir string'e atayalım. SQL İfadeleri sonunda ';' koymayı unutmayınız!\n", " cokluSorgu =\"\"\" CREATE TABLE IF NOT EXISTS HavaDurumu (\n", " Tarih TEXT NOT NULL,\n", " Sehir TEXT NOT NULL,\n", " Sicaklik_Dusuk INTEGER NOT NULL,\n", " Sicaklik_Yuksek INTEGER NOT NULL,\n", " Gokyuzu TEXT\n", " );\n", " INSERT INTO HavaDurumu (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu) VALUES\n", " (\"2023.01.01\",\"SAMSUN\",10,13,\"Çok Bulutlu\"),\n", " (\"2023.01.02\",\"ANTALYA\",13,16,\"Açık\"),\n", " (\"2023.01.03\",\"GAZİANTEP\",6,10,\"Bulutlu\"),\n", " (\"2023.01.04\",\"ERZURUM\",-4,4,\"Çok Bulutlu\"),\n", " (\"2023.01.05\",\"DİYARBAKIR\",8,12,\"Parçalı Bulutlu\");\n", " \"\"\"\n", " \n", " # Şimdi çoklu sql sorgusu içeren ifademizi 'executescript' ile veritabanımızda imleç aracılığıyla yürütelim.\n", " imlec.executescript(cokluSorgu)\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "67270ffb-8225-4516-bc4a-ea7d006dbd35", "metadata": {}, "source": [ "**`.executescript()`** metodunu kullanırken dikkat edeceğiniz nokta, parametre olarak verdiğiniz ifadenin 'string' tipinde olmasıdır.
\n", "**`.executescript()`** metodu ile birçok sorgudan oluşan **sql dosyasını da yürütebilirsiniz.** Örnek sql dosyası içeriği." ] }, { "cell_type": "raw", "id": "e4df91f1-c6a1-4391-b97b-e1be1ed930f8", "metadata": {}, "source": [ "CREATE TABLE IF NOT EXISTS HavaDurumu (\n", " Tarih TEXT NOT NULL,\n", " Sehir TEXT NOT NULL,\n", " Sicaklik_Dusuk INTEGER NOT NULL,\n", " Sicaklik_Yuksek INTEGER NOT NULL,\n", " Gokyuzu TEXT\n", " );\n", "\n", "INSERT INTO HavaDurumu (Tarih,Sehir,Sicaklik_Dusuk,Sicaklik_Yuksek,Gokyuzu) VALUES\n", " (\"2023.01.01\",\"SAMSUN\",10,13,\"Çok Bulutlu\"),\n", " (\"2023.01.02\",\"ANTALYA\",13,16,\"Açık\"),\n", " (\"2023.01.03\",\"GAZİANTEP\",6,10,\"Bulutlu\"),\n", " (\"2023.01.04\",\"ERZURUM\",-4,4,\"Çok Bulutlu\"),\n", " (\"2023.01.05\",\"DİYARBAKIR\",8,12,\"Parçalı Bulutlu\");" ] }, { "cell_type": "markdown", "id": "96336cb4-ca90-4a28-85ef-3f91eeca8df4", "metadata": {}, "source": [ "Yukarıdaki içeriği kopyalayıp not defteri ile boş bir deftere yapıştırıp 'Farklı Kaydet'e tıklayınız. Kayıt türünü 'Tüm Dosyalar' seçtikten sonra 'sqlDosyasi.sql' adıyla çalıştırdığınız Python dosyasının bulunduğu dizine kaydediniz. Ardından şu şekilde python'da yürütünüz." ] }, { "cell_type": "code", "execution_count": null, "id": "98f6bdd6-f9b4-4f01-8573-77b38e56ca7f", "metadata": {}, "outputs": [], "source": [ "import sqlite3\n", "with sqlite3.connect('havadurumu.sqlite') as baglanti:\n", " imlec = baglanti.cursor() #İmleç oluşturduk.\n", " #SQL dosyamızı açalım ve okuyup bir değişkene atayalım.\n", " with open(\"sqlDosyasi.sql\",\"r\",encoding=\"utf-8\") as dosya:\n", " sql = dosya.read()\n", " \n", " # Şimdi çoklu sql sorgusu içeren dosyamızın içeriğini veritabanımızda imleç aracılığıyla yürütelim.\n", " imlec.executescript(sql)\n", "baglanti.close()" ] }, { "cell_type": "markdown", "id": "69b31abe-07b2-4496-8de4-91b7a14d8f27", "metadata": {}, "source": [ "Burada unutulmaması gereken veritabanlarını **`with` deyimi ile kullanırken yaptığınız işlemlerin otomatik dosyaya uygulanmasıdır.** Eğer `with` deyimi ile kullanmıyorsanız sql dosya içeriğinizin sonuna `COMMIT;` yazarsanız yaptığınız işlemler veritabanına uygulanır." ] }, { "cell_type": "markdown", "id": "3ec6456b-cbea-4f8f-b13a-a4e52fd8b5d1", "metadata": {}, "source": [ "# Projeler\n", "Eklenecek..." ] }, { "cell_type": "code", "execution_count": null, "id": "1ad7adcc-4c79-4b7e-8cce-254965d95376", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "id": "60573ec6-b35f-444a-a976-99cc2ae27564", "metadata": {}, "source": [ "# Kaynakça" ] }, { "cell_type": "markdown", "id": "be609304-f66d-439c-b453-5766641ada0a", "metadata": {}, "source": [ "Darnit, J. (2017). Exact Instructions Challenge PB&J Classroom Friendly. Erişim Adresi: https://www.youtube.com/watch?v=FN2RM-CHkuI
\n", "GeeksForGeeks, (2022). Algorithms. Erişim Adresi: https://www.geeksforgeeks.org/fundamentals-of-algorithms/
\n", "Kara, A. (2020). Algoritma ve Çeşitleri. Erişim Adresi: https://www.datasciencearth.com/algoritma-ve-cesitleri/
\n", "Karaçay, T. (2015). C Programlamanın Temelleri, Abaküs, İstanbul, Eylül 2015. isbn:978-6059129183. Erişim Adresi: http://www.baskent.edu.tr/~tkaracay/etudio/ders/prg/c/recursive.pdf
\n", "Kaya, E. E. (2021). Fibonacci Dizisinden Altın Orana. Erişim Adresi: https://bilimgenc.tubitak.gov.tr/makale/fibonacci-dizisinden-altin-orana
\n", "Slashdot.org (2013). Interviews: Guido van Rossum Answers Your Questionn. Erişim Adresi: https://developers.slashdot.org/story/13/08/25/2115204/interviews-guido-van-rossum-answers-your-questions\n", "Şeker, S. E. (2009). Arama Algoritmaları. Erişim Adresi: https://bilgisayarkavramlari.com/2009/11/23/arama-algoritmalari-search-algorithms/
\n", "Torun, C. (2021). Algoritma Nedir, Nerelerde Kullanılır? Erişim Adresi: https://bilimgenc.tubitak.gov.tr/algoritma-nedir
\n", "Zaczyński, B. (2020). Bitwise Operators in Python. Erişim Adresi: https://realpython.com/python-bitwise-operators/
" ] }, { "cell_type": "code", "execution_count": null, "id": "7014c99a-d8b7-4b69-b670-f8cfcf2ad6fc", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.5" }, "toc-autonumbering": true, "toc-showcode": false, "toc-showmarkdowntxt": false, "toc-showtags": false }, "nbformat": 4, "nbformat_minor": 5 }