03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bu dersteki bütün IPython Notebook'lar  adresinde https://github.com/sinanonur/Python-Lectures mevcuttur ve [bu adres](https://github.com/rajathkumarmp/Python-Lectures)teki içerik Türkçe'ye çevirilerek hazırlanmıştır.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Veri Yapıları"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basit bir ifadeyle bir grup verinin bir yapı kullanarak ifade edilmesidir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listeler (List)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listeler en çok kullanılan veritürleridir. Köşeli parantezler içine alınmış ve virgülle ayırılmış veriler şeklinde düşünülebilir. Bu verilerden her birine indis(index) değeri ile erişilebilir.\n",
    "\n",
    "Liste tanımlamak için bir değişken '[ ]' e ya da list'e eşitlenebilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vir dizi veri aşşağıda görüldüğü gibi doğrudan atanabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = ['elma', 'armut']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### İndisleme (Indexing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pythonda indisler 0dan başlar. Böylece x listesi 0ç indiste elma 1. indiste armut bulunduravaktır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "İndisleme ters sırada da yapılabilir. Böylece son elemana erişim önce sağlanır. Bu şekildeki indisleme -1 den başlar. Böylece -1 inci indiste armut -2 inci indiste elma olacaktır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Böylece tahmin etmiş olabileceğiniz gibi x[0] = x[-2], x[1] = x[-1] olacaktır. Bu özellik daha fazla elemanlı listelere de uygulanabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y = ['havuc','patates']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Böylece kendi verisini içeren x ve y listeleri tanımlamoş olduk. Bu iki liste de bunları içeren başka bir z listesine koyulabilir. Liste içinde liste yer alma durumuna iç içe (nested) listeler denir ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ´len(z) = ?´"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "len(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "z  = [x,y]\n",
    "print z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "İndislemenin nasış çalıştığı anlaşılmazsa iç içe listeler biraz kafa karıştırıcı olabilir. Bu yüzden parça parça inceleyerek bir sonuca varalım.\n",
    "\n",
    "üstteki listede 'elma'ya ulaşmak istediğimizi varsayalım. 0ıncı indiste ['elma','armut'] listesi ve 1inci indiste başka bir şiste olan ['havuc', 'patates'] listesi vardır.\n",
    "\n",
    "öyleyse z[0] bize elma içeren ilk listeyi vermelidir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "z1 = z[0]\n",
    "print z1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Görüldüğü gibi z1 iç içe girmiş bir liste değildir. Böylece 'elma' ya erişmek için 0ıncı indise bakılmalıdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "z1[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yukarıdakini yapmak yerine pythonda indis değerleri yan yana yazılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "z[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste içinde liste içinde liste olması durumunda en içerideki veriyez[ ][ ][ ] şeklinde ulaşılabilir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kesme (Slicing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "İndisleri kullanarak sadece tek bir elemana ulaşabildik. Fakat kesme(slicing) kullanarak listenin içindeki bir sıra veriye erişim sağlayaibliriz. Diğer bir deyişle listeyi \"keseriz\".\n",
    "\n",
    "Kesme(slicing) alınacak ilk eleman ve son elemanın indislerini vererek yapılır. [ a : b] şeklinde ifade edilir. Burada a ve b kaynak listedeki indislerdir. Eğer atanımlı değilse listenin ilk elemanı b tanımlı değilse listenin son elemanı olduğu varsayılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "num = [0,1,2,3,4,5,6,7,8,9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print num[0:4]\n",
    "print num[4:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kaynak listeyi belli bir genişlikte ya da adım büyüklüğünde de kesebilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "num[:9:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gömülü(built-in) Liste fonksiyonları"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "bir listenin uzunluğunu bulmak için **len( )** kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "len(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eğer liste sayılardan oluşuyorsa **min( )** ve **max( )** minimum ve maksimum değerleri verir.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "min(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "max(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listeler '+' kullanarak birleştirilebilir. Sonuç listesi eklenen listelerin bütün elemanalrını içerir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "[1,2,3] + [5,4,7]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir elemanın bir listede bulunup bulunmadığını kontrol etmek istediğiniz durumlar olabilir. Aşşağıdaki listeyi ele alalım."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "elementler = ['Toprak','Ateş','Su','Tahta']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "'Ateş' ve 'Hava' nın elementler listesine yer alıp almadığına bakmak için geleneksel yaklaşım bir döngü kurarak teker teker kontrol etmektir. Ama pythonda 'a in b' şeklinde ifadeler kullanabilir. Bu ifadeler eğer a b nin içerisinde mevcutsa 'True' değilse 'False' döner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "'Ateş' in elementler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "'Hava' in elementler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elemanları string olan bir listede **max( )** ve **min( )** fonksiyonları uygulanabilir. **max( )** ASCII değeri en yüksek olan stringi **min( )** ise en düşük olanı döndürecektir. Öncelikle ilk karakterlerine göre karşılaştırma yapılır. İlk karakterlerin aynı olması durumunda ikinci karakterlere bakılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mlist = ['bzaa','ds','nc','az','z','klm']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print max(mlist)\n",
    "print min(mlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Burada bütün elemanların ilk karakterleri dikkate alınmışrır. böylece znin değeri en yüksek çıkmıştır. Minimum ascii değeri ise a dır. Peki ya sayılar karakter olarak tanımlanırsa?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nlist = ['1','94','93','1000']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print \"max:\", max(nlist)\n",
    "print \"min:\", min(nlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sayılar string içinde tanımlı bile olsa her elemanın ilk indisi dikkate alınır ve maksimum minimum değerler ona göre döndürülür."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**max( )** string elemanını stringin uzunluğu üzerinden bulmak istiyorsanız **max( )** ve **min( )** fonksiyonlarına 'key=len' parametresi verilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print max(elementler, key=len)\n",
    "print min(elementler, key=len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**max()** or **min()** fonksiyonları eğer aynı uzunlukta iki tane eleman varsa ilkini döndürürler. \n",
    "\n",
    "Başka bir gömülü fonksiyon ya da lambda fonksiyonu(ileride gösterilecek) len yerine koyulabilir. len.\n",
    "\n",
    "Bir string **list()** fonksiyonu kullanarak bir listeye çevirilebilir.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list('merhaba')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**append( )** listenin sonuna eleman eklemek için kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst = [1,1,4,8,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.append(1)\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**count( )** is used to count the number of a particular element that is present in the list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.count(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**append( )** fonksiyonu aynı zamanda başka bir listeyi listenin sonuna eklemek için de kullanılabilir. Sonuç iç içe girmiş listedir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lst1 = [5,4,2,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.append(lst1)\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Eğer istenen şey iç içe geçmiş listeler değilse **extend( )** fonksiyonu kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.extend(lst1)\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**index( )** bir elemanın indisini bulmak için kullanılır. Aynı elemandan birden fazla varsa ilk indis döndürülür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.index(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.index(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**insert(x,y)** x indisine y elemanını yerleştirmek için kullanılır. **append( )** sadece listenin sonuna ekleme imkanı verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.insert(5, 'name')\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**insert(x,y)** yeni bir eleman ekler fakat elemanı değiştirmez. O indizteki elemanı değiştirmek istiyorsanız o indise yeni bir atama yapabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst[5] = 'Python'\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pop( )** fonksiyonu listenin son elemanını döndürür. Böylece listeler yığıt(stack) olarak kullanılabilirler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Belirli bir indisteki değeri pop etmek isterseniz indis değeri pop fonksiyonuna verilebilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pop( )** bir elemanı indisine göre silmek için kullanılır ve sonuc başka bir değişkene atanabilir. Listeden belirli bir elemanı silmek için **remove( )** fonksiyonu kullanılaiblir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.remove('Python')\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**remove** fonksiyonuna alternatif olarak indis değeri ile **del** kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "del lst[1]\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Listenin bütün elemanları **reverse()** fonksiyonu kullanarak tersine çevirilebilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.reverse()\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[5,4,2,8] listesinin üst listenin herhangi bir elemanı gibi muamele gördüğüne dikkat edin. İç listenin içindeki elemanlar tersine çevirilmeyecektir.\n",
    "\n",
    "Python gömülü olarak gelen **sort( )** işlemiyle elemanları artan sırada sıralama imkanı verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.sort()\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Azalan sıra için reverse parametresi True olarak verilebilir. reversin varsayılan değeri False'tur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lst.sort(reverse=True)\n",
    "print lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Benzer şekilde string içeren listeler için **sort( )** elemanları ACII değerine göre artan sırayla sıralayacaktır. reverse=True kullanarak azalan sırada sıralamak mümkündür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "elementler.sort()\n",
    "print elementler\n",
    "elementler.sort(reverse=True)\n",
    "print elementler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uzunluğa göre sıralamak için key=len belirtildiği gibi gösterilmelidir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "elementler.sort(key=len)\n",
    "print elementler\n",
    "elementler.sort(key=len,reverse=True)\n",
    "print elementler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listeleri kopyalamak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Çoğu yeni python programcısı bu hatayı yapar. Aşşağıdaki örneğe bakalım:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lista= [2,1,4,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "listb = lista\n",
    "print listb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Burada, lista = [2,1,4,3] şeklinde bir liste tanımladık. Atama yaparak bu liste listb ye kopyalanır. Şimdi lista üzerinde rastgele işlemler yapalım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lista.pop()\n",
    "print lista\n",
    "lista.append(9)\n",
    "print lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print listb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Üzerinde hiçbir işlem yapılmadığı halde listb de değişti. Çünkü lista ve listb için aynı bellek adresi kullanılmaktadır. Peki bunu nasıl düzeltiriz?\n",
    "\n",
    "Eğer hatırlarsanız lesme işlemleri sırasında  ataliste[a:b] atalistenin a indsinden başlayarak b indisine kadar alıyordu. Ve a ve b belirtilmediğinde varsayılan olarak ilk ve son elemanlar alınıyordu. Aynı kavramı burada da kullanabiliriz. Böylece lista içindeki beriyi listbye koyalamış oluruz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lista = [2,1,4,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "listb = lista[:]\n",
    "print listb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "lista.pop()\n",
    "print lista\n",
    "lista.append(9)\n",
    "print lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print listb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplelar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TupleLar listelere benzer. Fakar en büyük farkı listelerin içindeki elemanlar değişeiblirken tupleların içindeki elemanların değişememesidir.Tupleları belli bir şey için doğru olması gereken ama dğer şeyler için doğru olmayan şeyler olarak düşünün. Daha iyi anlayabilmek için **divmod()** fonksiyonunu hatırlayalım."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "xyz = divmod(10,3)\n",
    "print xyz\n",
    "print type(xyz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Burada bölüm 3 kalan da 1 olmak zorundadır. 10 3'e bölünüyordsa bu değerler değişemez.Bu yüzden divmod bu değerleri bir tuple içinde döndürür."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir tuple tanımlamak için değişkene parantezler () ya da tuple() atanır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tup = ()\n",
    "tup2 = tuple()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eğer doğrudan bir tuple tanımlamak istiyorsanız verinin sonuna bir virgül koyaiblirsiniz. data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "27,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "27nin 2 katı 54tür, fakat tuple 2 ile çarpılınca iki kez tekrar eder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "2*(27,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir tuple tanımlarken değer atanabilir. Bir listeyi ya da stringi alır ve bunu bir tuple'a dönüştürür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tup3 = tuple([1,2,3])\n",
    "print tup3\n",
    "tup4 = tuple('Merhaba')\n",
    "print tup4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listelerle aynı indisleme ve kesme(slicing) işlemleri uygulanabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print tup3[1]\n",
    "tup5 = tup4[:3]\n",
    "print tup5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tupleları birbirine yörelemek (mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(a,b,c)= ('alpha','beta','gamma')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print a,b,c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d = tuple('SinanOnur')\n",
    "print d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gömülü Tuple fonksiyonları"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**count()** fonksiyonu tuple içerisinde belirtilen elemandan kaç tane olduğunu sayar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.count('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**index()**fonksiyonu belirtilen elemanın indisini döndürür.Eğer birden fazla o eşemandan varsa listede ilk karşılaşılan eleman döndürülür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "d.index('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kümeler(Sets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kümeler genellikle bir dizi ya da listede tekrar eden elemanlardan kaçınmak için kullanılır. Bunun dışında standart bazı küme işlemlerini yapmak için de kullanılır.\n",
    "\n",
    "Kğmeler set() şeklinde tanımlanır. Bu boş bir küme oluşturur. set([dizi]) elemanlı bir küme tanımlamak için kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1 = set()\n",
    "print type(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set0 = set([1,2,2,3,3,4])\n",
    "print set0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 ve 3 elemanları iki kez tekrar etmesine rağmen görüldüğü gibi bir kez bulunurlar. Böylece kümedeki her eleman diğerlerinden farklı olur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gömülü fonksiyonlar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1 = set([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set2 = set([2,3,4,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**union( )** fonksiyonu kümelerin birleşimini verir. Birleşim tekrar olmadan her iki kümedeki elemanları içerir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1.union(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**add( )** will add a particular element into the set. Note that the index of the newly added element is arbitrary and can be placed anywhere not neccessarily in the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1.add(0)\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**intersection( )** foksiyonu her iki kümede de olan elemanların bir kümesini döndürür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1.intersection(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**difference( )** fonksiyonu birinci kümede olup ikinci kümede olmayan fonksiyonların kümesini döndürür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1.difference(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**symmetric_difference( )** fonksiyonu iki kümeden yalnızca birisinde olan elemanların kümesini döndürür.."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set2.symmetric_difference(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**issubset( ), isdisjoint( ), issuperset( )** fonksiyonları sırasıyla set1 set2 için alt kümesi mi, ayrık mı, üst kümesi mi kontrollerini yapar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1.issubset(set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set2.isdisjoint(set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set2.issuperset(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pop( )** kümeden  herhangi bir eleman çıkartmak için kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print set1\n",
    "set1.pop()\n",
    "print set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**remove( )** belirtilen elemanı kümeden siler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1.remove(2)\n",
    "set1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**clear( )** bir kümeden bütün elemanları çıakrtarak boş küme olmasını sağlar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "set1.clear()\n",
    "set1"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}