{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# AST415 Astronomide Sayısal Çözümleme - I #\n", "## Ders - 03 Döngü Yapıları, Listeler, Demet Nesneleri ##" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Doç. Dr. Özgür Baştürk
\n", "Ankara Üniversitesi, Astronomi ve Uzay Bilimleri Bölümü
\n", "obasturk at ankara.edu.tr
\n", "http://ozgur.astrotux.org" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Bu derste neler öğreneceksiniz?#\n", "## Döngü Yapıları, Listeler, Demet (Tuple) Nesnesi ##\n", "\n", "* [Neden Döngülere İhtiyaç Duyarız?](#Neden-Döngülere-İhtiyaç-Duyarız?)\n", "* [While Döngüleri](#While-Döngüleri)\n", " * [Blok Kullanımı](#Blok-Kullanımı)\n", " * [Matematiksel İşlemlerin Kısa Gösterimi](#Matematiksel-İşlemlerin-Kısa-Gösterimi)\n", " * [Boolean İfadeler](#Boolean-İfadeler)\n", "* [Listeler](#Listeler)\n", " * [Listeler Üzerinde İşlemler](#Listeler-Üzerinde-İşlemler)\n", " * [Listelere Uygulanabilen Bazı Fonksiyonlar](#Listelere-Uygulanabilen-Bazı-Fonksiyonlar)\n", "* [For Döngüleri](#For-Döngüleri)\n", "* [Döngüler ve Listeler](#Döngüler-ve-Listeler)\n", " * [range Fonksiyonu](#range-Fonksiyonu)\n", " * [Reel Sayı Adım Kullanmak](#Reel-Sayı-Adım-Kullanmak)\n", " * [Döngü İçerisinde Liste Elemanı Değiştirmek](#Döngü-İçerisinde-Liste-Elemanı-Değiştirmek)\n", " * [enumerate Fonksiyonu](#enumerate-Fonksiyonu)\n", " * [Listelerle Hızlı ve Kompakt İşlemler (List Comprehensions)i](#Listelerle-Hızlı-ve-Kompakt-İşlemler:-List-Comprehensions)\n", " * [zip() Fonksiyonu](#zip-Fonksiyonu)\n", " * [İç-İçe-Listeler: Nested Lists](#İç-İçe-Listeler:-Nested-Lists)\n", "* [Demet (Tuple) Nesneleri](#Demet:-Tuple-Nesneleri)\n", "* [Alıştırmalar](#Alıştırmalar)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Neden Döngülere İhtiyaç Duyarız?#\n", "\n", "Aşağıdaki şekilde bir liste halinde verilmiş bir grup sıcaklığı santigrad dereceden ($^{\\circ}$C), fahrenheit dereceye ($^{\\circ}$F) dönüştürmek istiyor olalım.\n", "\n", "
\n", " -20.0\t-4.0
\n", " -15.0\t5.0
\n", " -10.0\t14.0
\n", " -5.0\t23.0
\n", " +0.0\t32.0
\n", " +5.0\t41.0
\n", " 10.0\t50.0
\n", " 15.0\t59.0
\n", " 20.0\t77.0
\n", " 30.0\t86.0
\n", " 35.0\t95.0
\n", " 40.0\t104.0
\n", "
\n", "\n", "Bu problemin basit bir çözümüne aşağıdaki kod satırlarıyla ulaşabiliriz." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-20 -4.0\n", "-15 5.0\n", "-10 14.0\n", "-5 23.0\n", "0 32.0\n", "5 41.0\n", "10 50.0\n", "15 59.0\n", "20 68.0\n", "25 77.0\n", "30 86.0\n", "35 95.0\n", "40 104.0\n" ] } ], "source": [ "C = -20; F = 9.0/5*C + 32; print(C, F)\n", "C = -15; F = 9.0/5*C + 32; print(C, F)\n", "C = -10; F = 9.0/5*C + 32; print(C, F)\n", "C = -5; F = 9.0/5*C + 32; print(C, F)\n", "C = 0; F = 9.0/5*C + 32; print(C, F)\n", "C = 5; F = 9.0/5*C + 32; print(C, F)\n", "C = 10; F = 9.0/5*C + 32; print(C, F)\n", "C = 15; F = 9.0/5*C + 32; print(C, F)\n", "C = 20; F = 9.0/5*C + 32; print(C, F)\n", "C = 25; F = 9.0/5*C + 32; print(C, F)\n", "C = 30; F = 9.0/5*C + 32; print(C, F)\n", "C = 35; F = 9.0/5*C + 32; print(C, F)\n", "C = 40; F = 9.0/5*C + 32; print(C, F)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bu çözümün birkaç önemli problemi var.\n", "\n", "1. Çıktısının formatı çok çirkin! Ancak bu C ve F'yi doğrudan ekrana yazdırmak yerine daha önce öğrendiğimiz formatlama seçeneklerini kullanarak aşılabilir.\n", "\n", "2. Asıl önemlisi, aynı ifadeyi defalarca yazıyor olmamız! Elimizin altında bir bilgisayar olduğuna göre bunu daha kolay yapabilmeliyiz. Tüm bilgisayar programlama dillerinde olduğu gibi Python'da da bunun çözümü döngü yapıları kullanmaktır. Python'da iki çeşit döngü yapısı bulunmaktadır: $while$ döngüleri ve $for$ döngüleri\n", "\n", "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# While Döngüleri\n", "\n", "$while$ döngüsü verilen bir şart sağlanana kadar döngü yapısı içerisinde yer alan ifadeleri tekrar tekrar çalıştırır. \n", "\n", "Örnek: Amacımız verilen liste dahilinde C = -5 $^{\\circ}$C'den başlayıp, C ≤ 40 $^{\\circ}$C olduğu sürece 5 $^{\\circ}$C'lik artışlarla sıcaklık değerini arttırıp, karşılık geldiği ($^{\\circ}$F dereceyi hesaplamak ve her ikisini ekrana yazdırmak!\n", "\n", "Algoritma:
\n", "C = -20
\n", "          C ≤ 40 OLDUĞU SÜRECE aşağıdaki adımları TEKRARLA!:
\n", "                    F = (9 / 5.) * C + 32
\n", "                    C ve F'yi ekrana yazdır
\n", "                    C'yi 5 arttır
\n", "\n", "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Blok Kullanımı\n", "\n", "Döngü içerisinde çalışması istenen tüm ifadeler içeri doğru aynı miktarda bloklanmalıdır. Bunun miktarı bir zorunluluk olmamakla birlikte, önerilen bir standart \\\"\" ya da 4 boşluk kullanmaktır.\n", "\n", "Aşağıdaki kod segmentini; kağıt kalem kullanarak, her bir değişkenin her çalışma anındaki değerini yazıp, ekrana yazılacakları tahmin etmek suretiyle elinizle (ing. trace) çalıştrınız. Daha sonra aşağıdaki kodu çalıştırıp, aradaki (varsa) farkların nedenlerini anlamaya çalışmalısınız (Elle çalıştırmak → “trace” etmek). Elle çalıştırmak, programcılık öğrenirken ve kodunuzdaki olası hataları bulmaya çalışırken çok faydalı bir egzersizdir." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", "-20 -4.0\n", "-15 5.0\n", "-10 14.0\n", "-5 23.0\n", "0 32.0\n", "5 41.0\n", "10 50.0\n", "15 59.0\n", "20 68.0\n", "25 77.0\n", "30 86.0\n", "35 95.0\n", "40 104.0\n", "------------------\n", "C'nin dongu disindaki degeri: 45\n" ] } ], "source": [ "print(\"------------------\") # tablo basligi\n", "C = -20 # C icin baslangic degeri\n", "dC = 5 # dongu icinde C'nin arttirilacagi deger\n", "while C <= 40: # dongunun calismasi icin kosul\n", " # while dongusu icindeki kod blogu\n", " F = (9.0/5)*C + 32 # Dongudeki ilk ifade\n", " print(C, F) # Dongudeki ikinci ifade\n", " C = C + dC # Dongudeki ucuncu ifade\n", " # while dongusunden cikis\n", "# while disindaki kod blogu\n", "print (\"------------------\") # Dongu sonrasi tablo sonu\n", "print(\"C'nin dongu disindaki degeri: \", C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# İşlemlerin Kısa Gösterimi\n", "\n", "Bir değişken ismi, türüne göre (int, float, str gibi) yaratılan bir nesne (object)'ye verilen bir isimdir. Değişkene yeni bir değer atadığınız vakit, yeni bir nesne yaratılır ve değişken ismi artık bu yeni nesnenin ismi olur. Bu nedenle matematiksel olarak yanlış gibi görünen aşağıdaki ifade bilgisayar bilimlerinde doğru bir atama ifadesidir.
\n", "\n", "
\n", "$$C = C + dC$$\n", "
\n", "\n", "Bu ifadeyle C değişkenin atıfta bulunduğu tamsayı ($int$) nesnesinin değeri dC tamsayı ($int$) nesnesinin değeri kadar arttırılmakta, bu iki nesnenin ikisi birden tamsayı ($int$) nesnesi olduğu için yeni yaratılan nesne de tamsayı nesnesi olup, değeri de onların toplamı olmaktadır. C'nin daha önce atıfta bulunduğu nesne ise yok edimiş, C yeni yaratılan tamsayı nesnesinin ismi olmuştur. Bu ifade kısaca aşağıdaki şekilde de yazılabilir.
\n", "\n", "
\n", "$$C += dC$$\n", "
\n", "\n", "Bu kısa gösterim diğer işlemler için de aynen kullanılabilir.\n", "\n", "
\n", "$C$     $-=$     $dC$
\n", "$C$     $*=$     $dC$
\n", "$C$     $/=$     $dC$
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Boolean İfadeler\n", "## Karşılaştırma ve Mantıksal Operatörler ##\n", "\n", "Boolean İfadeler: Sonucu DOĞRU ($TRUE$) ya da YANLIŞ ($FALSE$) olan ifadelerdir.\n", "\n", "Örnek 1:
\n", "$C == 40$\t# C “eşittir” 40
\n", "$C != 40$\t# C “eşit değildir” 40
\n", "$C >= 40$\t# C 40'tan “büyük ya da ona eşittir”
\n", "$C <= 40$\t# C 40'tan “küçük ya da ona eşittir”
\n", "$C > 40$\t# C 40'tan “büyüktür”
\n", "$C < 40$\t# C 40'tan “küçüktür”
\n", "\n", "Bu karşılaştırma operatörlerini yanı sıra mantıksal operatörler ($not$, $and$, $or$, $xor$) de Boolean ifadelerde kullanılıır." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n", "True\n", "True\n", "False\n", "True\n", "False\n" ] } ], "source": [ " x = 0; y = 1.2\n", "print(x >= 0 and y < 1)\n", "print(x >= 0 or y < 1)\n", "print(x > 0 or y > 1)\n", "print(x > 0 or not y > 1)\n", "print(-1 < x <= 0) # -1 < x and x <= 0\n", "print(not (x > 0 or y > 0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Herhangi bir programlama dilinde iki reel sayının eşitliğinin karşılaştırılması şartına dayanan döngüler yazmak iyi bir fikir değildir. İki reel sayıyı karşılaştırmanın neden iyi bir fikir olmadığını aşağıdaki örnekle anlamaya çalışalım." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "%%capture\n", "#Asagidaki kodu calistirmak istediginizde yukaridaki satiri siliniz\n", "epsilon = 1.0\n", "while 1.0 != 1.0 + epsilon:\n", " print(\"...................\", epsilon)\n", " epsilon /= 2.0\n", "print(\"epsilon'un son degeri: \", epsilon)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Şimdi bu kodun ne yaptığını anlamaya çalışalım. 1 değerinden başlatılan $epsilon$ bir $while$ döngüsü dahilinde sürekli 2'ye bölünerek küçültülüyor. Makinenizin izin verdiği en küçük değere (\"makine epsilonu\") kadar küçültüldüğünde $epsilon$ 0'a çok yakın olduğundan 0 olarak değerlendiriliyor ve $1.0 != 1.0 + epsilon$ koşulu artık sağlanmıyor (yani 1 = 1 + 0) ve döngü tamamlanıyor. Son olarak da epsilon'un en son değeri (0 kabul edilen) ekrana yazdırılıyor. Herhangi iki reel sayıyı $while$ döngüsünün şartını \"eşit değil\" (!=) üzerine değil de \"eşit\" (==) üzerine kurarak çalıştırırsanız programınızı sonsuz döngüye sokabilirsiniz. Şimdi bu probleme bir başka örnek verelim:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Yanlis sonuc!\n" ] } ], "source": [ "a = 1/947.0*947\n", "b = 1\n", "if a != b: # Henuz if ogrenmediniz!\n", " print(\"Yanlis sonuc!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bir önceki derste gördüğünüz bazı sayıların ikilik sistemde tam gösterilememesi problemi burada karşımıza tekrar çıkmaktadır. 1/947.0 işleminin sonucu ikilik sayı sisteminde tam gösterilemediği için en yakın ikilik sayıya yuvarlanmakta, bu sayı 947 ile çarpılınca 1'den (çok az miktar olmakla birlikte makine epsilonundan büyük) daha büyük bir sayı çıkmaktadır. Henüz Python'da şartlı yapıları ($if$ ile başlayan blok) öğrenmemiş olsanız da ilgili kod bloğunun ne yaptığını tahmin edebilirsiniz: Bu sayıyı 1'le karşılaştırıyor ve 1'den farklı olduğu sürece ekrana \"Yanlis sonuc!\" ifadesini yazdırıyor. Eğer bu blok bir $while$ bloğu olsaydı ($if$ yerinde $while$ yazıyor olsaydı), bu blok \"sonsuz kez\" çalışacaktı. \n", "\n", "Bu iki örnekten çıkarılması gereken ders iki reel sayıyı $a == b$ ya da $a != b$ şeklinde karşılaştırmanın beklenmedik sonuçlara yol açabileceğidir. Bunun yerine yeterince küçük bir tolerans değeri tanımlayıp karşılaştırmayı bu tolerans değeri dahilinde yapmak iyi bir yöntemdir." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dogru sonuc!\n" ] } ], "source": [ "a = 1/947.0*947\n", "b = 1\n", "tolerans = 1e-15 # kucuk bir tolerans degeri\n", "# a ile b arasindaki fark tolerans degerinden kucuk ise \n", "# bu iki deger birbirine esit kabul edilsin...\n", "if abs(a - b) < tolerans: # \n", " print(\"Dogru sonuc!\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Listeler\n", "\n", "Python'a özel, elemanları rastgele seçilmiş nesne türleri olabilen, bir nesnedir. Listenin herhangi eleman(lar)ı indeksleme yoluyla çağrılır. Listenin bir bölümünü alma işlemine dilimleme (ing. slicing) denir." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-15\n", "-20\n", "40\n", "[-20, -15]\n", "[-15]\n", "[]\n", "[40, 35]\n", "[30, 35]\n", "[-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "[-20, -15, -10, -5]\n", "[10, 15, 20, 25, 30, 35, 40]\n", "[-20, -15, -10, -5, 0, 5, 10, 15, 20, 25]\n", "[-20, -10, 0, 10, 20]\n", "[-20, -5, 10, 25, 40]\n", "[40, 30, 20, 10, 0, -10, -20]\n" ] } ], "source": [ "C = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "print(C[1]) # Listenin ikinci (1 numarali indeks) elemani\n", "print(C[0]) # Listenin birinci (0 numarali indeks) elemani\n", "print(C[-1]) # Listenin sonuncu (-1 numarali indeks) elemani\n", "print(C[0:2]) # Listenin 1. elemanindan 3. elemanina (3. eleman haric) kadarki bolumu\n", "print(C[1:2]) # Bir dilim oldugu icin tek bir elemani olan (listenin 2. elemani olan bir liste\n", "print(C[-1:-3])\n", "print(C[-1:-3:-1]) # Yukaridaki ornekte [40:35] sonucuna ulasmak istiyorsaniz dogru yolu budur\n", "print(C[-3:-1]) # Listenin sondan 3. elemanindan son elemanina (son eleman haric) kadarki bolumu\n", "print(C[:]) # Listenin tamami\n", "print(C[:4]) # Listenin basindan (0) 5. elemanina (4) kadar (5. eleman haric) kadarki bolumu\n", "print(C[6:]) # Listenin yedinci (6) elemanindan son elemani dahil sonuna kadarki bolumu\n", "print(C[:-3]) # Listenin basindan sondan 3. elemanina (sondan 3. eleman haric) kadarki bolumu\n", "print(C[0:10:2]) # Listenin basindan 11. elemanina (11 haric) 2ser adimla giderek dilimle\n", "print(C[::3]) # Listenin sonuna kadar 3er 3er giderek dilimle\n", "print(C[::-2]) # Listenin basindan sonuna ters yonde (yani sonundan basina) 2ser adimla dilimle" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Listeler Üzerinde İşlemler\n", "\n", "Herhangi bir listeye yeni bir eleman eklemek ($append$), çıkarmak ($delete$ ve $remove$), istediğniz yere eleman yerleştirmek ($insert$), herhangi bir elemanın indeksini bulmak ($index$) gibi işlemleri yapabilmek için verilen fonksiyonları liste.fonksiyon_adi(arguman) şeklindeki yazımla gerçekleştirebilirsiniz. Bu şekilde kullanılan fonksiyonlara $metot$ (ing. method, attribute) adı verilir. Aşağıda verilen metotlar liste nesnesinin metotlarıdır." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-10, -5, 0, 5, 10, 15, 20, 25, 30, 35]\n", "[-15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35]\n", "[-15, -10, -5, 0, 5, 15, 20, 25, 35]\n", "9\n", "4\n" ] } ], "source": [ "C = [-10, -5, 0, 5, 10, 15, 20, 25, 30]\n", "C.append(35) # Listenin sonuna 35 sayisini ekler!\n", "print(C)\n", "C.insert(0,-15) # O. indekse (en basa) -15 sayisini yerlestirir!\n", "print(C)\n", "C.remove(10) # C listesinden 10 sayisini cikarir!\n", "del C[-2] # C listesinin sondan ikinci elemanini siler!\n", "print(C)\n", "print(len(C)) # Listenin eleman sayisini verir\n", "print(C.index(5)) # 5 sayisinin indeksini verir" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "İki listeyi ucuca eklemek için toplama işlemi kullanılır. Dikkat: Toplama işlemi verilen iki listenin elemanlarını birbiri ile toplamaz, bu listeleri ucuca ekler!" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Eklemeden once: [-10, -5, 0, 5, 10, 15, 20, 25, 30]\n", "Ekledikten sonra: [-10, -5, 0, 5, 10, 15, 20, 25, 30, 40, 45]\n" ] } ], "source": [ "C = [-10, -5, 0, 5, 10, 15, 20, 25, 30]\n", "print(\"Eklemeden once: \",C)\n", "C = C + [40, 45]\n", "print(\"Ekledikten sonra: \",C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Liste elemanlarına karşılık gelen yeni değişkenler yaratmak için kompakt bir yazım kuralı (syntax) da bulunmaktadır." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "01 - Adana'da kebap yenir.\n" ] } ], "source": [ "birliste = [\"Adana\", \"kebap\", \"01\"] # istahinizi actiysam ozur diliyorum\n", "il, yemek, plaka = birliste\n", "print(\"{:s} - {:s}'da {:s} yenir.\".format(plaka, il, yemek))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bir listenin kopyasını oluşturmak için atama operatörü farklı bir şekilde kullanılır. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Degisimden once a: [1, 2, 3, 4]\n", "Degisimden once b: [1, 2, 3, 4]\n", "Degisimden sonra a: [1, 2, 3.5, 4]\n", "Degisimden sonra b: [1, 2, 3.5, 4]\n", "Degisimden once c: [1, 2, 3.5, 4]\n", "Degisimden sonra a: [1, 2, 3.5, 4.5]\n", "Degisimden sonra c: [1, 2, 3.5, 4]\n" ] } ], "source": [ "a = [1,2,3,4]\n", "b = a # a listesine bir baska isim verir\n", "print(\"Degisimden once a: \", a)\n", "print(\"Degisimden once b: \", b)\n", "a[2] = 3.5 # a'nin ucuncu elemanini degistirelim\n", "print(\"Degisimden sonra a: \", a)\n", "print(\"Degisimden sonra b: \", b) # bu nedenle a listesi degisince b listesi degisir!\n", "c = a[:] # a listesinin elemanlarindan olusan yeni bir liste\n", "print(\"Degisimden once c: \", c)\n", "a[3] = 4.5 # a'nin dorduncu elemanini degistirelim\n", "print(\"Degisimden sonra a: \", a) # bu nedenle a listesi degisse de c listesi degismez\n", "print(\"Degisimden sonra c: \", c) # bu nedenle a listesi degisse de c listesi degismez" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Listelere Uygulanabilen Bazı Fonksiyonlar ##\n", "\n", "Aşağıda listeler üzerinde işlem yapılmasını ve listelere ilişkin bazı bilgilerin alınmasını sağlayan bazı fonksiyonlar örnekler ile anlatılmıştır." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a listesi: [10, 5, 8, -6, 21, 44, 51, -12.0, 3]\n", "a listesinin uzunlugu: 9\n", "a listesinin minimumu: -12.00\n", "a listesinin maksimumu: 51.00\n", "a listesinin elemanlarının toplami: 124.00\n", "a listesinin sirali hali: [-12.0, -6, 3, 5, 8, 10, 21, 44, 51]\n", "a listesinin tersi: [3, -12.0, 51, 44, 21, -6, 8, 5, 10]\n" ] } ], "source": [ "a = [10, 5, 8, -6, 21, 44, 51, -12.0, 3]\n", "print(\"a listesi: \", a)\n", "print(\"a listesinin uzunlugu: {:d}\".format(len(a))) # a listesinin uzunlugunu veren fonksiyon\n", "print(\"a listesinin minimumu: {:.2f}\".format(min(a))) # a listesinin minimumunu veren fonksiyon\n", "print(\"a listesinin maksimumu: {:.2f}\".format(max(a))) # a listesinin maksimumunu veren fonksiyon\n", "print(\"a listesinin elemanlarının toplami: {:.2f}\".format(sum(a))) # a listesinin elemanlarinin toplami\n", "print(\"a listesinin sirali hali: \", sorted(a)) # a listesinin elemanlarinin siralanmis hali\n", "print(\"a listesinin tersi: \", list(reversed(a))) # a listesinin tersi\n", "# son fonksiyonun (reversed) sadece listeye donusturulebilir bir nesne urettigine \n", "# ve list fonksiyonuyla donusum yapildigina dikkat ediniz!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# For Döngüleri\n", "\n", "$for$ döngüsü, döngü yapısı içerisinde yer alan ifadeleri önceden istenen kadar sayıda (defa) çalıştırır. \n", "\n", "Örnek: Amacımız verilen bir listenin tüm elemanlarını Fahrenheit dereceye çevirip ekrana yazdırmak olsun.\n", "\n", "Algoritma:
\n", "$C = [-20, -15, -10, -5, 0, 5, 10, 15, 20, 30, 35, 40]$
\n", "Her bir $C[index]$ elemanı için
\n", "          F = (9 / 5.) * $C[index]$ + 32
\n", "          C ve F'yi ekrana yazdır
\n", "          Bir sonraki elemana geç
\n", "\n", "Döngü içerisinde çalışmasıı istenen tüm ifadeler içeri doğru aynı miktarda bloklanmalıdır. Bir zorunluluk olmamakla birlikte, standart olarak \\\" ya da 4 boşluk kulllanılmaktır." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", "-20 -4.0\n", "-15 5.0\n", "-10 14.0\n", "0 32.0\n", "5 41.0\n", "10 50.0\n", "15 59.0\n", "20 68.0\n", "25 77.0\n", "30 86.0\n", "35 95.0\n", "40 104.0\n", "------------------\n", "elemanin dongu disindaki degeri: 40\n" ] } ], "source": [ "print(\"------------------\") # tablo basligi)\n", "C = [-20, -15, -10, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "for eleman in C: # C'deki her bir eleman icin\n", " # for dongusune giris\n", " # for dongusunun icinde yapilacaklar\n", " F = (9.0/5)*eleman + 32 # Fahrenheit'e donusum yap\n", " print(eleman, F) # Ekrana yazdır\n", " # for dongusunden cikis\n", "# for dongusunun disinda yapilacaklar\n", "print(\"------------------\") # Dongu sonrasi tablo sonu\n", "print(\"elemanin dongu disindaki degeri: \", eleman)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bu örnekte verilen tablo, yapısı itibarı ile bir tablo gibi düzenli görünmemektedir. Daha düzenli bir görünüm için aşağıdaki kod bloğunu kullanmak daha uygundur." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", " C F\n", " -20 -4.0\n", " -15 5.0\n", " -10 14.0\n", " 0 32.0\n", " 5 41.0\n", " 10 50.0\n", " 15 59.0\n", " 20 68.0\n", " 25 77.0\n", " 30 86.0\n", " 35 95.0\n", " 40 104.0\n", "------------------\n" ] } ], "source": [ "print(\"------------------\") # tablo basligi\n", "C = [-20, -15, -10, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "print(\" C F\")\n", "for eleman in C: # C'deki her bir eleman icin\n", " F = (9.0/5)*eleman + 32 # Fahrenheit'e donusum yap\n", " print(\"{:5d} {:5.1f}\".format(eleman, F)) # Ekrana yazdır\n", "print(\"------------------\") # Dongu sonrasi tablo sonu" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Döngüler ve Listeler #\n", "## range Fonksiyonu ##\n", "\n", "$range(son, [baslangic], [adim])$ özellikle for döngüleri ile sıkça kullanılan ve bir sayı dizisi üreten fonksiyondur. Yaptığı iş, başlangıç değerinin verilmemesi durumunda 0'dan başlayarak verilen son değere ($stop$) kadar (son hariç!) tam sayılardan oluşan bir dizi (range) nesnesi oluşturmaktır. İstenen adım büyüklüğünün sağlanması durumunda bu adım büyüklüğü dahilinde son değere arttırarak (pozitif adım) ya da azaltarak (negatif adım) gider. Hem başlangıç ($start$), hem de adım ($step$) argümanları opsiyonel olup, fonksiyona sağlanmamaları durumunda sırasıyla 0 ve 1 varsayılan değerlerini alırlar. Python 2.x'te $range()$ verilen parametreler dahilinde bir liste oluşturan bir fonksiyondu. Buna karşılık $xrange$ ise sırayla tam sayı üreten bir dizi nesnesi oluşturuyordu. Python 3.x ile birlikte $xrange$ artık kullanılmazken $range$ onun yerini almıştır.\n", "\n", "$$range(n) → 0, 1, 2, 3, …, n-1$$\n", "$$range(5) → 0, 1, 2, 3, 4$$\n", "$$range(3, 27, 6) → 3, 9, 15, 21$$\n", "$$range(2,8) → 2, 3, 4, 5, 6, 7$$\n", "$$range(10, 2, -2) → 10, 8, 6, 4$$\n", "\n", "$range$ ile oluşturulan diziyi bir listeye dönüştürmek için ise $list()$ fonksiyonu kullanılır." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", " C F\n", " -20 -4.0\n", " -15 5.0\n", " -10 14.0\n", " -5 23.0\n", " 0 32.0\n", " 5 41.0\n", " 10 50.0\n", " 15 59.0\n", " 20 68.0\n", " 25 77.0\n", " 30 86.0\n", " 35 95.0\n", " 40 104.0\n", "------------------\n" ] } ], "source": [ "print(\"------------------\") # tablo basligi\n", "print(\" C F\")\n", "C = list(range(-20, 45, 5))\t\t# C listesini olustur\n", "F = [0.0]*len(C) # C listesiyle ayni uzunlukta sadece sifirlardan olusan bir liste olustur\n", "for indeks in range(len(C)): # C'yi indeks uzerinden tara\n", " F[indeks] = (9.0/5)*C[indeks] + 32 # Ayni indekse karsilik gelen F degerini hesapla\n", " print(\"{:5d} {:5.1f}\".format(C[indeks], F[indeks]))\n", "print(\"------------------\") # Dongu sonrasi tablo sonu" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Reel Sayı Adım Kullanmak ##\n", "\n", "$range$ fonksiyonu sadece tam sayı ($int$) üretir. Bu da başlangıç değeri ile son değer arasında hep tam sayı adım atmakla bizi kısıtlar. Adımlarımızın reel sayı olmasını istiyorsak bunu döngü yapısı içerisinde yapmamız gerekir." ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", " C F\n", " -5.0 23.0\n", " -4.5 23.9\n", " -4.0 24.8\n", " -3.5 25.7\n", " -3.0 26.6\n", " -2.5 27.5\n", " -2.0 28.4\n", " -1.5 29.3\n", " -1.0 30.2\n", " -0.5 31.1\n", " 0.0 32.0\n", " 0.5 32.9\n", " 1.0 33.8\n", " 1.5 34.7\n", " 2.0 35.6\n", " 2.5 36.5\n", "------------------\n" ] } ], "source": [ "C_adim = 0.5\n", "C_baslangic = -5\n", "n = 16 # listede istedigimiz eleman sayisi\n", "C = [0.0]*n; F = [0.0]*n # n adet 0.0 'dan olusan birer liste\n", "print(\"------------------\") # tablo basligi\n", "print(\" C F\")\n", "for i in range(n): # indeks üzerinden tarama\n", " C[i] = C_baslangic + i*C_adim\n", " F[i] = (9.0/5)*C[i] + 32\n", " print(\"{:5.1f} {:5.1f}\".format(C[i], F[i]))\n", "print(\"------------------\") # Dongu sonrasi tablo sonu" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", " C F\n", " -5.0 23.0\n", " -4.5 23.9\n", " -4.0 24.8\n", " -3.5 25.7\n", " -3.0 26.6\n", " -2.5 27.5\n", " -2.0 28.4\n", " -1.5 29.3\n", " -1.0 30.2\n", " -0.5 31.1\n", " 0.0 32.0\n", " 0.5 32.9\n", " 1.0 33.8\n", " 1.5 34.7\n", " 2.0 35.6\n", " 2.5 36.5\n", "------------------\n" ] } ], "source": [ "# Ayni islemi alternatif bir cozum olarak while dongusuyle yapalim\n", "C_baslangic = -5; C_adim = 0.5; C_son = 2.5\n", "cent = C_baslangic\n", "C = []; F = []\n", "print(\"------------------\") # tablo basligi\n", "print(\" C F\")\n", "while cent <= C_son:\n", " C.append(cent)\n", " fahr = (9.0/5)*cent + 32\n", " F.append(fahr)\n", " print(\"{:5.1f} {:5.1f}\".format(cent, fahr))\n", " cent += C_adim\n", "print(\"------------------\") # Dongu sonrasi tablo sonu" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Reel sayı adım kullanmanın bir başka yolu da $numpy$ ($arange$ ve $linspace$) ya da $itertools$ modülü fonksiyonları kullanmaktır. Bu konulara daha ilerideki derslerimizde değineceğiz.\n", "\n", "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Döngü İçerisinde Liste Elemanı Değiştirmek ##\n", "\n", "Bir liste içinde gezerken herhangi bir elemana geldiğimizde onu değiştirmek istiyor olalım." ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Donguden once: [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "Donguden sonra: [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n" ] } ], "source": [ "C = list(range(-20,45,5)) # range'in urettigi nesneyi listeye cevirmeliyiz\n", "print(\"Donguden once: \", C) \n", "for cent in C:\n", " cent += 5\n", "print(\"Donguden sonra: \", C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "İstedğimiz şey $C$'deki her elemanı 5 arttırmaktı ama istediğimizi yapamadık. Çünkü $cent$ değişkeni bizi $C$'de sadece “gezdirir”, $C$'deki değerler üzerinde bir etkisi yoktur. İstediğimize aşağıdaki şekilde ulaşabiliriz." ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Donguden once: [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "Donguden sonra: [-15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45]\n" ] } ], "source": [ "C = list(range(-20,45,5)) # range'in urettigi nesneyi listeye cevirmeliyiz\n", "print(\"Donguden once: \", C) \n", "for i in range(len(C)):\n", " C[i] += 5 # C'nin her bir degerine 5 ekle\n", "print(\"Donguden sonra: \", C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## enumerate Fonksiyonu ##\n", "\n", "Aslında bir döngü içerisinde rastlanan bir liste elemanının hem değerini hem de indeksini kullanmanın oldukça basit bir yolu var: $enumerate()$ fonksiyonu size bu olanağı sağlamaktadır.. $enumerate()# fonksiyonu bir dizi nesnesinin (range, list, tuple, array, ...) hem indeks, hem de eleman üzerinden taranabilmesi ve istendiği anda nesnenin herhangi bir elemanının değeri ile birlikte dizide bulunduğu yeri (indeks) edinilebilmesi kolaylığı sağlar." ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Donguden once: [-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "Donguden sonra: [-15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45]\n" ] } ], "source": [ "C = list(range(-20,45,5))\n", "print(\"Donguden once: \", C) \n", "for i, cent in enumerate(C):\n", " C[i] = cent + 5 # C'nin her bir degerine 5 ekle\n", "print(\"Donguden sonra: \", C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bir listeyi ihtiyaca uygun olarak listenin elemanları, indeksi ya da her ikisi üzerinden tarayabilirsiniz. Liste icinde tarama islemleri icin pythonik yol eleman ve enumerate() fonksiyonunun kullanildigi yontemlerdir." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0 AST415\n", "1 3\n", "2 7.5\n", "3 ['m', 'n', 'o']\n", "4 -1\n", "======================\n", "0 AST415\n", "1 3\n", "2 7.5\n", "3 ['m', 'n', 'o']\n", "4 -1\n", "======================\n", "0 AST415\n", "1 3\n", "2 7.5\n", "3 ['m', 'n', 'o']\n", "4 -1\n" ] } ], "source": [ "# Bir listeyi hem indeks, hem eleman, \n", "# hem de enumerate kullanarak ikisinin birden\n", "# uzerinden tarayabilirsiniz\n", "a = ['AST415', 3, 7.5, ['m', 'n', 'o'], -1]\n", "indeks = 0\n", "for eleman in a:\n", " print(indeks, eleman)\n", " indeks += 1\n", "print('======================')\n", "for indeks in range(len(a)):\n", " print(indeks, a[indeks])\n", "print('======================')\n", "for indeks, eleman in enumerate(a):\n", " print(indeks, eleman)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Listelerle Hızlı ve Kompakt İşlemler: List Comprehensions #\n", "\n", "Bir liste içinde gezerken her bir eleman için başka bir liste içerisinde yeni bir eleman yaratmak çok sık ihtiyaç duyulan bir özelliktir. Python bunun için list comprehensions adı verilen kompakt bir yazım kuralına sahiptir." ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "C: [-5.0, -4.5, -4.0, -3.5, -3.0, -2.5, -2.0, -1.5, -1.0, -0.5]\n", "F: [23.0, 23.9, 24.8, 25.7, 26.6, 27.5, 28.4, 29.3, 30.2, 31.1]\n", "C_arti_5: [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]\n" ] } ], "source": [ "n = 10 # Listede istenen eleman sayisi olsun\n", "C = [-5 + i*0.5 for i in range(n)]\n", "F = [(9.0/5)*cent + 32 for cent in C]\n", "C_arti_5 = [cent + 5 for cent in C]\n", "print(\"C: \", C)\n", "print(\"F: \", F)\n", "print(\"C_arti_5: \", C_arti_5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Birden fazla (aynı uzunlukta) liste içinde aynı anda “gezebilmek” de mümkündür. " ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", " C F\n", " -5.0 23.0\n", " -4.5 23.9\n", " -4.0 24.8\n", " -3.5 25.7\n", " -3.0 26.6\n", " -2.5 27.5\n", " -2.0 28.4\n", " -1.5 29.3\n", "------------------\n" ] } ], "source": [ "n = 8\n", "C = [-5 + i*0.5 for i in range(n)]\n", "F = [(9.0/5)*cent + 32 for cent in C]\n", "print(\"------------------\") # tablo basligi\n", "print(\" C F\")\n", "for i in range(len(C)):\n", " print(\"{:5.1f} {:5.1f}\".format(C[i], F[i]))\n", "print(\"------------------\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## zip Fonksiyonu ##\n", "\n", "İki listeyi aynı indekse sahip karşılıklı elemanlarını yan yana getirerek birleştiren (ve bir zip nesnesi oluşturan) önemli ve kullanışlı bir fonksiyondur. $zip()$ fonksiyonu ile oluşturulan $zip$ nesnesi istendiğinde $list()$ fonksiyonu ile listeye dönüştürülebilir." ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "------------------\n", " C F\n", " -5.0 23.0\n", " -4.5 23.9\n", " -4.0 24.8\n", " -3.5 25.7\n", " -3.0 26.6\n", " -2.5 27.5\n", "------------------\n", "[(C, F)]: [(-5.0, 23.0), (-4.5, 23.9), (-4.0, 24.8), (-3.5, 25.7), (-3.0, 26.6), (-2.5, 27.5)]\n" ] } ], "source": [ "n = 6\n", "C = [-5 + i*0.5 for i in range(n)]\n", "F = [(9.0/5)*cent + 32 for cent in C]\n", "print(\"------------------\") # tablo basligi\n", "print(\" C F\")\n", "for cent, fahr in zip(C, F):\n", " print(\"{:5.1f} {:5.1f}\".format(cent, fahr))\n", "print(\"------------------\")\n", "print(\"[(C, F)]: \", list(zip(C,F)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "İndeksler yerine liste elemanları kullanarak “gezmek” daha “Pythonik” 'bir yoldur." ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "harf: x\n", "harf: y\n", "harf: z\n", "------------------\n", "harf: x\n", "harf: y\n", "harf: z\n" ] } ], "source": [ "a = [\"x\", \"y\", \"z\"]\n", "# a listesinin icerigini ekrana sirayla getirmek icin\n", "for i in range(len(a)):\n", " print(\"harf: \", a[i])\n", "print(\"------------------\")\n", "# yerine asagidaki daha Pythonik bir yol olarak tercih edilmelidir\n", "for harf in a:\n", " print(\"harf: \", harf)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# İç İçe Listeler: Nested Lists #\n", "\n", "Elemanlarından en az biri bir liste olan listeler de tanımlamak Python'nda mümkündür." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40]\n", "-10 14.0\n" ] } ], "source": [ "C = list(range(-20,41,5))\n", "F = [(9.0/5)*cent + 32 for cent in C]\n", "tablo1 = [C, F]\n", "print(tablo1[0]) # tablo listesinin birinci elemani C listesi iken\n", "print(tablo1[0][2], tablo1[1][2]) # C listesinin ucuncu elemanina ulasir" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Yapmak istediğimiz her bir elemanı bir liste olan yeni bir liste yerine, bir satırındaki birinci elemanını bir listeden, ikinciyi diğer listeden alan bir tablo oluşturmak ise izleyeceğimiz yol aşağıdaki gibi olmalıdır." ] }, { "cell_type": "code", "execution_count": 69, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[-20, -4.0]\n", "-4.0\n" ] } ], "source": [ "C = list(range(-20,41,5))\n", "F = [(9.0/5)*cent + 32 for cent in C]\n", "tablo2 = []\n", "for cent, fahr in zip(C, F):\n", " tablo2.append([cent,fahr])\n", "print(tablo2[0]) # bu durumda tablo listesinin birinci elemani ilk C, F ikilisidir.\n", "print(tablo2[0][1]) # bu elemanin ikinci elemanina (F'ye) ulasir" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Demet: Tuple Nesneleri #\n", "\n", "Demet nesnesi, liste nesnesine çok benzeyen bir türdür. İçeriği \"sabit\" listeler olarak değerlendirilebilirler ve listlerdeki '\\[ \\]' işaretleri yerine '\\( \\)' işaretleri kullanılarak tanımlanırlar." ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "t: (2, 4, 6, 'AST415.pdf', -1.0, -2.0)\n" ] } ], "source": [ "t = (2, 4, 6, \"AST415.pdf\") # t adinda bir demet nesnesi olusturalim\n", "t = t + (-1.0, -2.0) # Bu demet degiskenin ucuna bir baska demet nesnesi ekleyelim\n", "print(\"t: \", t)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Bu örnekte t $tuple$ (demet) değişkeni değiştiriliyor gibi görünse de gerçekte olan şudur: $t$ adı verilen bir demet değişkenle $(-1.0, 2.0)$ demet değişkeni toplanmakta (ucuca eklenmekte), bunun sonucunda yeni bir tuple (demet) değişken oluşmaktadır. Bu yeni demet değişkene de $t$ ismi verildiği için $t$ isimli eski değişken yok olmaktadır. Yani t değişmemekte, yeni bir t oluşturulmaktadır! İndeksleme ve dilimleme de tıpkı listelerde olduğu gibidir." ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "6, t1 nesnesinin bir elemani midir?: True\n", "6, t2 nesnesinin bir elemani midir?: True\n", "2, t1 nesnesinin bir elemani midir?: True\n", "2, t2 nesnesinin bir elemani midir?: False\n" ] } ], "source": [ "t1 = (2, 4, 6, \"AST415.pdf\") # t adinda bir demet nesnesi olusturalim\n", "t2 = t1[2:]\n", "print(\"6, t1 nesnesinin bir elemani midir?: \", 6 in t1) # 6 t1'in bir elemani midir?\n", "print(\"6, t2 nesnesinin bir elemani midir?: \", 6 in t2) # 6 t2'nin bir elemani midir?\n", "print(\"2, t1 nesnesinin bir elemani midir?: \", 2 in t1) # 2 t1'nin bir elemani midir?\n", "print(\"2, t2 nesnesinin bir elemani midir?: \", 2 in t2) # 2 t2'nin bir elemani midir?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Demet nesenleri, liste nesnelerinde olduğu gibi nesneye eleman ekleyecek ($append$), çıkaracak ($remove$), ya da eleman değiştirecek metotlara sahip değildirler. Çünkü liste nesneleri değiştirilebilir (mutable) iken, demet nesneler değiştirilemezdir (immutable). " ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "'tuple' object has no attribute 'append'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"AST415.pdf\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'" ] } ], "source": [ "t = (2, 4, 6, \"AST415.pdf\")\n", "t.append(0)" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "ename": "AttributeError", "evalue": "'tuple' object has no attribute 'remove'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"AST415.pdf\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'remove'" ] } ], "source": [ "t = (2, 4, 6, \"AST415.pdf\")\n", "t.remove(6)" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"AST415.pdf\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "t = (2, 4, 6, \"AST415.pdf\")\n", "t[1] = -6" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object doesn't support item deletion", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"AST415.pdf\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion" ] } ], "source": [ "t = (2, 4, 6, \"AST415.pdf\")\n", "del t[1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Madem listeler daha yetenekli ve onlarla daha çok şey yapabiliyoruz, neden demet değişkenlere ihtiyaç duyuyoruz?\n", " \n", "1. Demet değişkenler içeriklerinin yanlışlıkla silinmesinden bizi korur!\n", "2. Listelere dayalı kodlar demet nesnelerine dayalı kodlardan yavaş çalışır.\n", "3. Karşılaştığınız pek çok kodda demet nesnesi kullanılmıştır. O kodları anlamak ve kullanmak için demet değişkenleri de öğrenmeniz gerekir!\n", "\n", "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Alıştırmalar #\n", "\n", "1. Fahrenheit derece cinsinden 0, 10, 20, ... , 100 şeklinde verilen sıcaklıkları santigrat dereceye dönüştürerek bir tablo halinde ekrana yazdıran bir program yazınız.\n", "\n", "2. Fahrenheit dereceyi santigrat dereceye hızlı dönüştürmek için C = (F - 30) / 2 formülü sıklıkla kullanılır. Standart Fahrenheit - Santigrat derece dönüşüm formülünün yanı sıra bu formülü de kullanarak Fahrenheit derece cinsinden 0, 10, 20, ... , 100 şeklinde verilen sıcaklıkları santigrat dereceye dönüştürerek üç sütunlu (birinci sütun F$^{\\circ}$, ikinci ve üçüncü sütun iki ayrı fomülle hesaplanmış C$^{\\circ}$) içerecek şekilde) bir tablo halinde ekrana yazdıran bir program yazınız.\n", "\n", "3. 20'den küçük tüm asal sayıları (2, 3, 5, ... , 19) bir liste oluşturup, bir for döngüsü içerisinde bu listenin elemanlarını sırayla ekrana yazdıran bir program yazınız.\n", "\n", "4. 1'den n = 100'e kadar tam sayıları bir listeye aldıktan sonra, bu listedeki her bir sayı için o sayıya (n) kadarki tüm sayıların toplamını Gauss'un meşhur $n*n(+1) / 2$ formülüyle hesaplayan ve yeni bir listeye yazdıran bir program yazınız.\n", "\n", "5. x ekseni üzerinde $[a, b]$ kapalı aralığında n+1 tane birbirinden eşit uzaklıkta koordinat içeren bir liste oluşturunuz. İpucu: Öncelikle boş bir liste oluşturup, a ile b arasında herhangi ardışık iki koordinatın arasının ne büyüklükte (h = (b - a) / n) olacağını hesapladıktan sonra bu listeyi bir for döngüsünün içinde doldurunuz.\n", "\n", "6. $q = [[\"a\", \"b\", \"c\"], [\"d\", \"e\", \"f\"], [\"g\", \"h\"]]$ listesinden $a$ harfini, $[\"d\", \"e\", \"f\"]$ listesini, q listenin son elemanını ve $g$ harfini verebilecek ikişer ayrı indeksleme öneriniz.\n", "\n", "7. Altıncı (6.) soruda verilen q listesinin tüm harflerini sırayla (her satıra bir harf) ekrana yazdıran bir döngü (ipucu: içiçe döngü) yazınız." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[Başa Dön](#Bu-derste-neler-öğreneceksiniz?)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.6.9" } }, "nbformat": 4, "nbformat_minor": 2 }