Ders4 - Sıralı nesnelerle işlemler.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bu yazının konusu _sıralı nesne_ (sequential object) olarak anılan liste, çokuz ve dize tipleriyle ilgili bazı işlemlerdir. Bunlara sıralı nesne denmesinin sebebi, içlerinde barındırdıkları nesnelerin sırasının önemli oluşu. Söz gelişi, `\"merhaba\"` dizesi ile `\"baharem\"` dizesi farklıdır, aynı harfleri barındırmalarına rağmen. Buna karşılık bir sözlük sıralı nesne değildir, çünkü `{\"ahmet\":123, \"ayşe\":456}` ile `{\"ayşe\":456, \"ahmet\":123}` aynı sözlüğü tanımlarlar.\n",
    "\n",
    "Burada göreceklerimiz:\n",
    "* Dilimleme (slicing)\n",
    "* Öntanımlı fonksiyonlar: `range, len, del, list, tuple, join, all, any, enumerate, max, min, sorted, sum, zip`\n",
    "* Türkçe alfabeye göre sıralama"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dilimleme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Daha önce, bir `L` sıralı nesnesinin `i` indeksli bir elemanına `L[i]` işlemi ile ulaşabildiğimizi görmüştük. Python'da indeksler sıfırdan başladığı için `L[i]` listenin `i+1`'inci elemanını verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [3,4,5,6,7,8]\n",
    "L[0] # birinci eleman"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[1] # ikinci eleman"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bazen sonuncu, sondan ikinci vs. elemanları elde etmek isteriz. Genellikle listenin kaç elemanlı olduğunu tam olarak bilmediğimiz için bunu genel bir ifadeyle yazmamız gerekir. Bunun bir yolu, listenin kaç elemanlı olduğunu veren `len` fonksiyonunu kullanmaktır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste indeksleri sıfırdan başlayıp `len(L)`-1 değerine kadar gider. O zaman sonuncu elemanı `L[len(L)-1]` ile elde edebiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "L = [3,4,5,6,7,8]\n",
    "print( L[len(L)-1] ) # sonuncu eleman\n",
    "print( L[len(L)-2] ) # sondan bir önceki eleman"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python bu zahmetli yazım yerine doğrudan negatif indeks kullanmaya izin verir. Negatif indeks kullanmak sondan itibaren saymak anlamına gelir. `L[-i]` ifadesi, sondan `i`'inci elemanı verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "print( L[-1] ) # sonuncu eleman\n",
    "print( L[-2] ) # sondan bir önceki eleman"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizinin belli bir alt kümesini almak için `L[a:b]` ifadesini kullanırız. Bu _dilimleme_ işlemi `L[a]` elemanından `L[b-1]` elemanına kadar bir alt dizi verir. Dikkat: Bu alt diziye `L[b]` dahil değildir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[1:4] # ikinci elemandan dördüncü elemana kadar alır."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dilimleme işleminde başlangıç indeksini vermezsek, ilk elemandan başlanır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 6]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[:4]  # birinci elemandan dördüncü elemana kadar alır."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bitiş indeksini vermezsek, son elemana kadar gider."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 8]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[4:]  # beşinci elemandan sonuncuya kadar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bitiş indeksi olarak negatif bir sayı verirsek, o negatif sayıyla belirtilen indeksin bir öncesine kadar gider."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[4:-1] # beşinciden, sondan ikinciye kadar dilim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ne başlangıç ne de bitiş indeksi verirsek dizinin aynısı geri verilir. Bu ilk başta faydasız görünse de, listenin bir kopyasını çıkarma amacıyla sık kullanılan bir kalıptır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[:]   # baştan sona dilim. Listenin bir kopyasını çıkarmakta kullanılabilir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dilimleme yaparken elemanları atlamamız da mümkündür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 6, 8]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[1:6:2]  # Birinciden altıncıya kadar iki atlayarak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 7]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[::2]    # baştan sona kadar iki atlayarak"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negatif adım vererek diziyi sondan başa tarayabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 6, 4]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[::-2]   # sondan başa iki atlayarak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 7, 6, 5, 4, 3]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[::-1]   # listeyi tersten yaz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Liste dilimlerine atama yaparak listeyi değiştirmemiz mümkün olur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, -1, -2, -3, 7, 8]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [3,4,5,6,7,8]\n",
    "L[1:4] = [-1,-2,-3]   # birinciden dördüncüye kadar elemanları değiştir\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, -1, 0, -3, 0, 8]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L[::2] = [0,0,0]      # baştan sona kadar birer atlayarak elemanları sıfıra ata.\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dize ve çokuzlarla dilimleme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yukarıda gösterdiğimiz indeksleme ve dilimleme kuralları, sıralı nesne olan dize (string) ve çokuz (tuple) tiplerinde de aynen geçerlidir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = \"abcçdefgğ\"\n",
    "t = (3,4,5,6,7,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ğgfedçcba'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 6, 7)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tek fark, dize ve çokuzlar _değiştirilemez_ (immutable) veri tipleri oldukları için elemanlarında dilimleme ile değişiklik yapılamaz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "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<ipython-input-21-9ffe2cc1beca>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\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:5] = (-1,-2,-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eğer amacımız ortadaki bazı elemanları değiştirilmiş olan bir çokuz elde etmekse, bunu dilimleri birleştirerek sağlayabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4, -1, -2, -3, 8)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (3,4,5,6,7,8)\n",
    "t = t[:2] + (-1,-2,-3) + t[5:]\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aynı yöntem tabii dizelerde de geçerli olur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abXYZefgğ'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"abcçdefgğ\"\n",
    "s = s[:2] + \"XYZ\" + s[5:]\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Temel fonksiyonlar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python'un öntanımlı fonksiyonlarının bir kısmı sıralı nesneler üretmekte veya sıralı nesneler hakkında bilgi edinmekte kullanılırlar. Bunların en yaygınlarının nasıl kullanıldığına bakalım şimdi. Python'daki öntanımlı fonksiyonların tam listesini [Python belgelerinde](https://docs.python.org/3/library/functions.html) bulabilirsiniz. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tamsayılardan oluşan bir liste üretmek için `range(baş, son, adım)` işlemini kullanabilirsiniz. Aslında `range` bir fonksiyon değil, bir veri tipi döndürür. Onu bir listeye çevirmek için ayrıca `list` işlemi gerekir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(2,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(2,10,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range` işlemi bir liste değil, dizinin başlangıç, bitiş ve adım bilgilerini barındıran bir nesne geri verir sadece. Bu sayede, `range(1000000)` gibi çok uzun görünen bir dizi bile bellekte ancak `range(10)` kadar yer kaplar. Elemanlar ve alt aralıklar gerektiğinde aritmetik olarak hesaplanır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 20, 2)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = range(0,20,2)\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11 in r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 in r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10, 2)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir `range` nesnesi `for` döngüsünde doğrudan kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 2 4 6 8 10 12 14 16 18 "
     ]
    }
   ],
   "source": [
    "for i in range(0,20,2):\n",
    "    print(i,end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### len"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kapsayıcı bir nesnenin kaç nesne barındırdığını verir. Sıralı olmayan tiplerle de kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len({\"a\": 45, \"b\": 5.4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(range(0, 20, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### del"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Genel olarak, belli bir isme bağlı bir nesneyi bellekten kaldırır. Sıralı nesnelerde, bir dilimi silmek için de kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-39-281c77bb7324>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m23\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "a = 23\n",
    "del a\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1,2,3,4,5,6]\n",
    "del L[1]   # ikinci elemanı siler\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 6]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del L[2:4]    # üçüncüden dördüncüye kadar olan elemanları siler\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del L[:]      # bütün elemanları siler, ama L listesini silmez.\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'L' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-43-c66d86760815>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mL\u001b[0m         \u001b[0;31m# L listesini siler\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mL\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'L' is not defined"
     ]
    }
   ],
   "source": [
    "del L         # L listesini siler\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list, tuple, join"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`list` fonksiyonu herhangi bir sıralı nesneyi bir liste nesnesine4 çevirmek için kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['m', 'e', 'r', 'h', 'a', 'b', 'a']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"merhaba\"\n",
    "list(s)  # dizeyi listeye çevirir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (1,2,3,4)\n",
    "list(t)  # çokuzu listeye çevirir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`tuple` fonksiyonu ise bir sıralı diziyi çokuza çevirir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('m', 'e', 'r', 'h', 'a', 'b', 'a')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"merhaba\"\n",
    "tuple(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [1,2,3,4]\n",
    "tuple(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir dizenin harflerinden oluşan bir liste veya çokuz oluşturmak kolay olsa da, bunun tersi, yani harf listesini dizeye çevirmek için tek bir komut yok. Bu işlem için kabul edilen kalıp, dizelerin `join` metodunu kullanmaktır (bir _metod_, bir nesnenin içinde tanımlanmış bir fonksiyondur)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'merhaba'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = ['m', 'e', 'r', 'h', 'a', 'b', 'a']\n",
    "\"\".join(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Genel olarak `s.join(L)` işlemi `L` listesinin her elemanını aralarına `s` dizesini koyarak birleştirir. Yukarıdaki örnekte `s` bir boş dizeydi, o yüzden `L`'nin elemanları yanyana yazıldı. Eğer istersek, araya başka karakterler de koyabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'m-*-e-*-r-*-h-*-a-*-b-*-a'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = ['m', 'e', 'r', 'h', 'a', 'b', 'a']\n",
    "\"-*-\".join(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dize birleştirmeyi aşağıdaki gibi bir `for` döngüsüyle de yapabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'merhaba'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"\"\n",
    "for ls in L:\n",
    "    s = s + ls\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### all"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir sıralı nesne içindeki *bütün elemanlar* mantıksal doğruya denkse `True` verir, yoksa `False` verir. Python'da sıfır, boş liste `[]`, boş dize `\"\"` gibi yapıların da `False` sayıldığını; sıfır olmayan sayıların ve boş olmayan nesnelerin de `True` sayıldığını hatırlayın."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all( [1, 2, 3, 4] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all( (0, 1, 2, 3) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all( \"abc\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all( [1, 2, ()] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### any"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir liste içinde _en az bir eleman_ mantıksal doğruya denkse `True` verir, yoksa `False` verir. Python'da sıfır, boş liste `[]`, boş dize `\"\"` gibi yapıların da `False` sayıldığını; sıfır olmayan sayıların ve boş olmayan nesnelerin de `True` sayıldığını hatırlayın."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any( [0, '', True] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any( [0, '', False] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "any( [0, 'abc', False] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### enumerate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir sıralı nesnenin elemanlarına sıra numarası atamak için kullanılır. Özellikle döngülerde, bir nesne üzerinden iterasyon yaparken yararlı olur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(\"abcd\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n",
      "3 ç\n",
      "4 d\n",
      "5 e\n",
      "6 f\n",
      "7 g\n",
      "8 ğ\n"
     ]
    }
   ],
   "source": [
    "for i,c in enumerate(\"abcçdefgğ\"):\n",
    "    print(i,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bazı problemlerde, bir veri listesini tararken o verinin bulunduğu konuma dair bilgiye de ihtiyaç duyarız. Basit bir örnek olarak, bir isim listesinde Z ile başlayan isimlerin listedeki konumunu görmek isteyebiliriz. Bu amaçla yazdığımız bir `for` döngüsünde `enumerate` kullanabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 Ziya\n"
     ]
    }
   ],
   "source": [
    "isimler = [\"Kaan\",\"Meral\",\"Ziya\",\"Fındık\"]\n",
    "for i, isim in enumerate( isimler ):\n",
    "    if \"Z\" in isim:\n",
    "        print(i,isim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python dışındaki dillere alışık olan programcılar bu işlemi bir `while` döngüsüyle ve bir sayaçla yapmaya çalışırlar, örneğin şöyle bir kodla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 Ziya\n"
     ]
    }
   ],
   "source": [
    "isimler = [\"Kaan\",\"Meral\",\"Ziya\",\"Fındık\"]\n",
    "i = 0\n",
    "while i < len(isimler):\n",
    "    if \"Z\" in isimler[i]:\n",
    "        print(i,isimler[i])\n",
    "    i += 1\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ancak `enumerate` ile `for` kullanmak sadeliği ve okunaklılığı açısından tercih edilir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### max, min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`max` fonksiyonu bir sıralı nesne veya bir dizi parametre alır, aralarından en büyük değerli olanını geri verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(4,2,8,3,1,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [4,2,8,3,1,7]\n",
    "max(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizelerden oluşan bir sıralı nesne verildiğinde `max` alfabetik sırada en ileride olanını döndürür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'zxy'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max([\"dfg\",\"zxy\",\"abc\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(\"merhaba\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`key` parametresi ile her elemana önceden uygulanacak bir fonksiyon belirleyebilirsiniz ve maksimum bu fonksiyonun sonucuna göre tespit edilir. Söz gelişi, mutlak değer olarak en büyük elemanı bulmak için `key=abs` verebilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = [-1,-3, 4, -5, 2]\n",
    "max(L, key=abs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`min` fonksiyonu verilen bir dizinin içinde, veya parametreler içinde en küçük olanını döndürür. Kullanımı `max` ile aynıdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(L, key=abs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(\"merhaba\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sorted"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir dizi nesnesi alır ve nesne elemanlarının düzgün sıralanmış olduğu bir liste döndürür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-3, -1, 1, 3, 4, 4, 6]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([1, 3, -1, 4, -3, 6, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`reverse` parametresiyle sıralama ters çevrilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 4, 4, 3, 1, -1, -3]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " sorted([1, 3, -1, 4, -3, 6, 4], reverse=True)      # ters sıralama"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizeler alfabetik sıraya konur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'a', 'b', 'e', 'h', 'm', 'r']"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(\"merhaba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Fındık', 'Kaan', 'Meral', 'Ziya']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted((\"Ziya\",\"Meral\",\"Kaan\",\"Fındık\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`key` parametresine verilen bir fonksiyon sıralamadan önce her elemana uygulanır; sonuç sıralaması bu fonksiyona göre belirlenir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, -2, 3, 4, 4, -5, 6]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([1, 3, -2, 4, -5, 6, 4], key=abs)    # mutlak değere göre sıralar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, -1), (0, 2), (1, 2), (3, 4)]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted( [(1,2), (0,2), (3,4), (2,-1)] , key=sum)  # çokuz elemanların toplamına göre sıralar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, -1), (1, 2), (0, 2), (3, 4)]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted( [(1,2), (0,2), (3,4), (2,-1)], key=lambda x:x[1]) # ikinci elemana göre sıralar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Türkçe sıralama"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3 Unicode kullandığı için İngilizce dışı harfleri kullanırken zorluk çıkarmaz. Ama alfabetik sıralama yapmaya çalıştığımızda doğru cevabı alamayabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ahmet', 'Mehmet', 'Ziya', 'Ümit', 'İsmail', 'Şebnem']"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted((\"Ahmet\",\"Şebnem\",\"Mehmet\",\"Ziya\",\"İsmail\",\"Ümit\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Türkçe alfabeye göre sıralama yapmak için yerellik ayarı yapmalıyız. Bunun için `locale` modülünü yüklemeli, ardından da `sorted` fonksiyonuna `key` parametresi olarak `locale.strxfrm` fonksiyonunu vermeliyiz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ahmet', 'İsmail', 'Mehmet', 'Şebnem', 'Ümit', 'Ziya']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import locale\n",
    "locale.setlocale(locale.LC_ALL, (\"tr\", 'UTF-8'))\n",
    "sorted((\"Ahmet\",\"Şebnem\",\"Mehmet\",\"Ziya\",\"İsmail\",\"Ümit\"), key=locale.strxfrm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir sıralı nesnenin elemanlarının toplamını verir. Elemanlar sayısal değere sahip olmalıdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5050"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(1,101))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aynı uzunlukta iki veya daha çok listenin aynı konumdaki elemanlarını sırayla alır, bu elemanlardan çokuzlar oluşturur ve bu çokuzların listesini verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(4, 'a'), (5, 'b'), (9, 'c')]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = [4, 5, 9]\n",
    "L2 = ['a', 'b', 'c']\n",
    "list(zip(L1, L2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`zip` ile farklı verileri birleştirerek bir `for` döngüsünde işlemek mümkün olur. Tıpkı `enumerate` gibi `zip` de bizi elemanları bir sayaç değişkeniyle takip etme mecburiyetinden kurtarır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yaş: 19 Boy: 170 Ağırlık: 75\n",
      "Yaş: 25 Boy: 180 Ağırlık: 78\n",
      "Yaş: 32 Boy: 175 Ağırlık: 81\n",
      "Yaş: 27 Boy: 169 Ağırlık: 71\n"
     ]
    }
   ],
   "source": [
    "yaşlar = [19, 25, 32, 27]\n",
    "boylar = [170, 180, 175, 169]\n",
    "ağırlık = [75, 78, 81, 71]\n",
    "for y, b, a in zip(yaşlar, boylar, ağırlık):\n",
    "    print(\"Yaş:\", y, \"Boy:\", b, \"Ağırlık:\",a)"
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}