while_for_loops.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "while_for_loops.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Comp-Wolf/Assignments/blob/main/while_for_loops.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9pn1A0RCSBDM"
      },
      "source": [
        "##############  while and for loops "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6g0J5P7qSFB7"
      },
      "source": [
        "# looplar vasitasi ile biz bir kodumuzu yada elimizde bulunan birseyi tekrar ettiririz\n",
        "\n",
        "\n",
        "# while loop ile for loop birbirine benzer seylerdir ancak calisma prensipler farklidir\n",
        "\n",
        "# for loop iterable lar üzerinden gider. Bir iterable verinin elemanlari sayisinca iterate eder\n",
        "# iterable in elemanlari bitince for döngüsünün calismasi da durur\n",
        "\n",
        "# while loop ise condition lar üzerinden gider. Bizim kosulumuz saglandigi sürece while loop \n",
        "# calisir kosulumuz False a döndügünde while loop calismayi durdurur"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4pfe9xMVSFDw"
      },
      "source": [
        "## while loop temel yapisi:\n",
        "\n",
        "# while condition: (: colon önemli)\n",
        "#    body   ## 4 space indentation "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JNTWZOYDSFGM"
      },
      "source": [
        "# while looplar, condition kismina boolean degerler yada Truthy Falsy degerler alirlar\n",
        "# peki biz condition kismina neler yazabiliriz?\n",
        "\n",
        "while 3 > 2:   ##  Biz durdurmadigimiz sürece sonsuz döngü\n",
        "\n",
        "while True:\n",
        "\n",
        "while None:\n",
        "\n",
        "while False:\n",
        "\n",
        "while {}:\n",
        "\n",
        "while bool(1,2,3,4) + bool(\"A\", \"b\", \"c\"):\n",
        "\n",
        "while \"ahmet\":\n",
        "  print(\"ahmet\")\n",
        "  break \n",
        "\n",
        "while \"ali\" and None or 2021:\n",
        "\n",
        "# mesela cay kahve makinesi:\n",
        "\n",
        "while para < 1:\n",
        "  print(\"Lütfen para ilave ediniz\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eCbdUOX4SFOi"
      },
      "source": [
        "condition = 6.5  ##  Attention: Burada 6.5 degilde mesela 6.8 yazarsak\n",
        "                    # sürekli 0.5 azalacagindan sonuc 0 a hic düsmez ve sonsuz döngü olur\n",
        "while condition:\n",
        "  condition -= 0.5\n",
        "  print(condition)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8xfyMlmQYaWE"
      },
      "source": [
        "# ayni kosulu su sekilde de calistirabilirdik\n",
        "\n",
        "condition = 5   \n",
        "\n",
        "while condition > 0:\n",
        "  condition -= 1\n",
        "  print(condition)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vZ0HIwKzfiFe"
      },
      "source": [
        "# Attention: Bizim while döngümüz, kodumuzun herhangi bir bölümünde False a dönmesi \n",
        "# gerekir. Aksi takdirde kodumuz sonsuz döngüye girecektir.\n",
        "\n",
        "# yani bu demek olur ki while döngülerinde, elimizdeki veriyi yani rakamlari harfleri\n",
        "# bir sekilde degistirmemiz lazim. Eger elimizdeki veri hep sabit, yada hep True sonuc verirse\n",
        "# bu durumda sonsuz döngü ile sonuclanir\n",
        "\n",
        "# a += 1  yada a -= 1 gibi degiskenler kullanarak her iteration da \n",
        "# verimizin degistirilebilir\n",
        "\n",
        "# eger kodumuzdan cok emin degil isek o zaman break kelimesini kullanabiliriz\n",
        "\n",
        "condition = 5\n",
        "\n",
        "while True:     ## mesela burada, condition kismi True, o nedenle condition = 5 gözardi edilir                 \n",
        "  condition -= 1        # ve burada if yapisi olmasa bu hic degismeyecektir\n",
        "  print(condition)\n",
        "  if condition == 0:\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Js4Hm8wVWRh"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-_f3ZQzaVWTt"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wqhJpopYVWV9"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "flJ55nVoghxu"
      },
      "source": [
        "# Not: Eger ic ice yani nested while loop lar ile calisiyorsak\n",
        "\n",
        "# ve en icteki loop umuzda break kullaniyorsak o zaman, en icteki looptan\n",
        "\n",
        "# cikar bir üst while loop ise calismaya devam eder\n",
        "\n",
        "condition = 20\n",
        "\n",
        "while condition > 0: \n",
        "  print(condition)\n",
        "  condition -= 1              ## 1 kez burada calisir\n",
        "\n",
        "  while 19 >= condition >= 13:    # 7 kez burada calisti      \n",
        "    print(\"condition >= 13\")\n",
        "    condition -= 1      \n",
        "\n",
        "    while 13 > condition > 7:    ## Burada sayi 8 den büyük oldugu sürece calisacak\n",
        "      print(\"condition >= 8\")    ##    7 e esit olunca icteki while dan cikacak ve distaki loop \n",
        "      condition -= 1             # # calismaya devam edecek\n",
        "      if condition == 7:\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B_LKrdTba-yL"
      },
      "source": [
        "# peki print() func iki kez yazarsak nasil bir output aliriz ??\n",
        "\n",
        "condition = 5\n",
        "\n",
        "while condition > 0:\n",
        "  condition -= 1\n",
        "  print(condition)\n",
        "  print(condition)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BB1c5zTcbFn3"
      },
      "source": [
        "# print func while loop disinda yazilirsa output ne olur ??\n",
        "\n",
        "condition = 5\n",
        "\n",
        "while condition > 0:\n",
        "  condition -= 1\n",
        "print(condition)\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BOtzX6wbbFp9"
      },
      "source": [
        "## print while döngüsü üzerine yazilirsa ne sonuc aliriz ??\n",
        "\n",
        "condition = 5\n",
        "print(condition)\n",
        "\n",
        "while condition > 0:\n",
        "  condition -= 1\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3yw0WRtafBxU"
      },
      "source": [
        "## condition while loop altinda yazilirsa:\n",
        "\n",
        "\n",
        "while condition > 0:\n",
        "  condition = 5\n",
        "  print(condition)\n",
        "  condition -= 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RFoQVaJLfXSs"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B867vnTNfXaV"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z5ImU4VPYaYu"
      },
      "source": [
        "# buradaki while loop'un calisma prensibini manuel olarak kendimiz yapalim:\n",
        "condition = 5\n",
        "\n",
        "while condition > 0:\n",
        "  condition -= 1\n",
        "  print(condition)\n",
        "  \n",
        "condition = 4\n",
        "print(condition)   ## bu artik yeni degisken olarak düsünelim. yeni degiskenimiz artik 4 print(condition)\n",
        "\n",
        "condition = 3           ## yeni degisken burada 3 oldu\n",
        "print(condition)\n",
        "\n",
        "condition = 2        \n",
        "print(condition)      \n",
        "                      \n",
        "condition = 1\n",
        "print(condition)\n",
        "\n",
        "condition = 0\n",
        "print(condition)   # ama dikkat 0 basildi. cünkü bu islem yapilirken degiskenimiz 1 yani truthy"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y8qiPnnHZweg"
      },
      "source": [
        "## while calisma prensip:\n",
        "\n",
        "while statement  ==>> condition ==>> False ise döngüden cikar bir sonraki condition a gider\n",
        "                                ==>> True ise loop u calistirir"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UUQ7rvAOZwlx"
      },
      "source": [
        "number = 0\n",
        "\n",
        "while number < 6:  ## numara 6 dan kücük oldugu sürece bu kod calissin\n",
        "  print(number)    ## bu örnekte number += 1 print' in altinda.alt hücrede ise farkli\n",
        "  number += 1    ## bu satira gelince artik yani number degiskeni 0 degil  1 olur\n",
        "                  ## ve tekrar kontrol eder. 1 < 6 midir. evet kücüktür ve tekrar calisir\n",
        "                  # bu siralama ta ki 6 < 6 yi görene kadar devam eder. \n",
        "                  # ve döngümüz bittikten sonra kod blokumuz devam ediyor. \n",
        "                  # cünkü print while disinda\n",
        "print(\"simdi sayi 6 ya esit veya daha büyük\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9HWeWy-0ZwoT"
      },
      "source": [
        "number = 0\n",
        "\n",
        "while number < 6: \n",
        "  number += 1\n",
        "  print(number)    \n",
        "\n",
        "## Dikkat edersek burada print etmeden önce number degiskenine 1 ekliyoruz.\n",
        "# python yukaridan asagi calistigi icin üstteki hücrede 0 dan baslamistik\n",
        "# simdi ise 1 den basladik.\n",
        "\n",
        "# Burada önemli husus sudur. Döngümüzün kac iteration yaptigi ?\n",
        "# kactan baslarsak baslayalim loop umuz 6 iteration yapar"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3BZW-aW-Zwqw"
      },
      "source": [
        "# while döngüleri condition lar ile calisir demistik ama\n",
        "# bu condition'i, for döngüsünde kullandigimiz  bir iterable\n",
        "# vasitasi ile de saglayabiliriz \n",
        "\n",
        "liste = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "a = 0\n",
        "\n",
        "while a < len(liste):      \n",
        "  a += 1\n",
        "  print(\"{}'in karesi = {}\" .format(a, a ** 2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a7qhHAJ4gPCa"
      },
      "source": [
        "yas = input(\"yasinizi giriniz: \")\n",
        "\n",
        "while not yas.isdigit():            ## isdigit \n",
        "  print(\"Yanlis formatta girdiniz\")\n",
        "  yas = input(\"Lütfen yasinizi dogru formatta giriniz: \")\n",
        "\n",
        "print(\"Tesekkür ederiz. Yasiniz: \", yas)\n",
        "\n",
        "# Not: Neden print() func'i while döngüsü disina yazdik?\n",
        "# Cünkü, eger kullanici yasini dogru formatta girerse kodumuz hic while döngüsü \n",
        "# icerisine girmeden dogrudan print satirina atlayacaktir.\n",
        "\n",
        "# Eger biz print func'i while döngüsü icinde yazarsak o zaman\n",
        "# kullanici ilk girme hakkinda dogru format girdiginde kodumuz while döngüsü\n",
        "# icine girmez ama while döngüsü disinda da bir islem olmadigindan\n",
        "# biz bu durumda hicbir cikti alamayiz."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DYhtrUi-DE9U"
      },
      "source": [
        "# Not: yukaridaki kod da isdigit() zaten kendisi True ve False gibi boolean \n",
        "# degerler döndürdügü icin o nedenle tekrar bir daha == True yada\n",
        "# == False demeye ihtiyac duymuyoruz"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kj8PqP_3_GAI"
      },
      "source": [
        "## isdigit() calisma prensibi\n",
        "\n",
        "# isdigit() gibi methodlar string methodlaridir. Bu nedenle integer yada\n",
        "# diger veri tipleri ile kullanamayiz\n",
        "\n",
        "a = \"55\".isdigit()\n",
        "print(a)\n",
        "\n",
        "b = \"55.0\".isdigit()\n",
        "print(b)\n",
        "\n",
        "c = \"abc\".isdigit()\n",
        "print(c)\n",
        "\n",
        "d = \"-55\".isdigit()\n",
        "print(d)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0VUmIllFZwsm"
      },
      "source": [
        "## Dersteki Kahoot sorulari:\n",
        "\n",
        "# if elif ve else ler condition olarak bilinir\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uVxM7TGKZwus"
      },
      "source": [
        "condition = (3 > 1) and (1 < 1)\n",
        "\n",
        "if not condition:   # Dikkat: not var\n",
        "  print(\"it works\")   \n",
        "                      \n",
        "else:\n",
        "  print(\"something is wrong\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q_mUuRsdYaan"
      },
      "source": [
        "price = \"2200\"\n",
        "\n",
        "if price <= 2200:\n",
        "  print(\"ucuz\")\n",
        "\n",
        "else:\n",
        "  print(\"pahali\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u6U6rllDYaci"
      },
      "source": [
        "price = \"2200\"          ### Burada dikkat etmemiz gereken 2 husus vardir\n",
        "                        ## birincisi <= dedigimizde icerisinde = oldugu icin \n",
        "if price <= \"2200\":     #  ayni zamanda hem kücük hem de esittir demektir.\n",
        "  print(\"ucuz\")         # ikincisi ise string icerisinde bulunan 2 tane sayiyi\n",
        "                        # kücük ve büyük olarak kiyas edebilirz\n",
        "else:                   #  yani bizim kodumuzda <= degil de sadece < olsa bile\n",
        "  print(\"pahali\")       ## kodumuz calisirdi    \n",
        "\n",
        "                       "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F1yTFbgTjiy3"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bzdt8pGtji35"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0b8iqpiWYaer"
      },
      "source": [
        " ## Dikkat: string veri tipi icerisindeki sayi ve harfleri birbirleri ile\n",
        "# karsilastirabiliriz. Yani price = \"abcd\" desek de kodumuz calisir \n",
        "\n",
        "# burada ise ascii kodlar devreye girer\n",
        "\n",
        "print(\"a\" < \"aa\")\n",
        "\n",
        "print(\"a\" < \"A\")\n",
        "\n",
        "print(\"a\" < \"1234\")\n",
        "\n",
        "print(\"a\" < \"+\")\n",
        "\n",
        "print(\"a\" == \"a\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bwREjOaJGIUw"
      },
      "source": [
        "# aklindan bir sayi tut oyunu:\n",
        "# Not bu sorunun kolay cözümü bu sekildedir. Yani True kullanacagiz ve bir kosul saglandiginda\n",
        "# break kullanacagiz ve break bizi döngüden cikaracak \n",
        "\n",
        "print(\"Hadi sayi oyunu oynayalim\")\n",
        "sayi = 55\n",
        "\n",
        "while True:          \n",
        "  girdi = int(input(\"Bil bakalim aklimdan gecen sayiyi: \"))\n",
        "\n",
        "  if girdi > sayi:                ## neden girdi degiskenini while loop icerisine yazdik\n",
        "    print(\"Biraz azalt: \")        # cünkü dogru cevap bilinmedigi sürece, her defasinda \n",
        "  elif girdi < sayi:              # kullanicidan yeni sayi isteyecegiz. Ve dikkat:\n",
        "    print(\"biraz artir: \")        ##  while altinda girdi istedigimizden bir daha if ler \n",
        "  else:                           # altinda girdi istemiyoruz\n",
        "    cevap = \"Tebrikler bildin\"\n",
        "    break\n",
        "print(cevap)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9eqLPomUGIX4"
      },
      "source": [
        "\n",
        "# bu sekilde 3 while ile de calistirilabilir\n",
        "\n",
        "girdi = int(input(\"Bir sayi söyle!!!: \"))\n",
        "sayi = 55\n",
        "\n",
        "while girdi < sayi:                 ### Dikkat buralarda break kullanmadik ve buna\n",
        "  print( \"Biraz artir!!!\")          # ragmen sonsuz döngü olusmuyor !!!\n",
        "  girdi = int(input(\"yeni sayi: \")) #  neden ??\n",
        "\n",
        "while girdi > sayi:\n",
        "  print(\"Biraz azalt!!!\")\n",
        "  girdi = int(input(\"Yeni sayi: \"))\n",
        "\n",
        "while girdi == sayi:\n",
        "  print(\"Tebrikler bildin\")\n",
        "  break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9D8vEGRHGIZ_"
      },
      "source": [
        "# not: Bu tarz kodlari while ve for kullanmadan sadece if ve else ler ile\n",
        "# yazamayiz. cünkü kullanicinin kac sefer de bilecegini bilemeyiz ve\n",
        "# sadece if ler ile bir döngü olusturamayiz "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4a_cFMQGIc5"
      },
      "source": [
        "# kullanicinin girdigi cümlede en uzun kelimenin uzunlugunu bulma\n",
        "\n",
        "girdi = input(\"Lütfen bir cümle giriniz(kelime aralarinda bosluk birakiniz): \")\n",
        "new = girdi.split()\n",
        "counter = 0\n",
        "longest = 0\n",
        "\n",
        "while counter < len(new):\n",
        "  a = new[counter]\n",
        "  counter += 1\n",
        "\n",
        "  if len(a) > longest:\n",
        "    longest = len(a)\n",
        "  else:\n",
        "    longest = longest        ### else' i kullanmasak da kodumuz calisir\n",
        "\n",
        "print(longest)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RxtYvc9qGIgF"
      },
      "source": [
        "## hocanin cözümü:\n",
        "\n",
        "sentence = input(\"Lütfen bir cümle giriniz: \")\n",
        "\n",
        "word_list = sentence.split()\n",
        "i = 0\n",
        "longest = 0\n",
        "\n",
        "while i < len(word_list):\n",
        "\n",
        "  if len(word_list[i]) > longest:   # sadece if kullandik else e gerek kalmadi\n",
        "\n",
        "    longest = len(word_list[i])    ### eger yeni kelime uzunlugu longest tan uzun degilse\n",
        "                                    ## bu durumda longest in eski halinde bir degisiklik olmaz\n",
        "  i += 1                            #  ve bu durumda sadece alt satirdaki i bir tane artar.\n",
        "\n",
        "print(longest)         ###  Dikkat eger i counter'i if altinda yazarsak calismaz"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gpkCzQWd4UnP"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4JDA_ajs4Up0"
      },
      "source": [
        "####### 13. Session"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xN_xSxip4Ury"
      },
      "source": [
        "#### Not:  if yapilarinda indentation lar cok önemli oldugu gibi \n",
        "# while ve for loop larda da cok önemlidir.\n",
        "\n",
        "\n",
        "while condition:\n",
        "  body\n",
        "  while condition:\n",
        "    body\n",
        "    break\n",
        "\n",
        "# Buradaki break kelimesi sadece ic kisimdaki while icindir\n",
        "## eger disaridaki döngüyü de cikarmak istersek onun hizasinda ayrica break yazmamiz gerekir"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lq__KnPT4Uug"
      },
      "source": [
        "#### attention:\n",
        "\n",
        "# while döngüsü kurarken condition olusturma asamasinda dikkat\n",
        "# edilmesi gereken bir husus:\n",
        "\n",
        "liste = [1, 2, 3, 4, 5]\n",
        "bos = []\n",
        "i = 0\n",
        "\n",
        "while i <= len(liste):  ## burada <= kullanirsak toplam iterate sayisi ne olur?\n",
        "  bos.append(i)          # sadece < kullanirsak ne olur?\n",
        "  i += 1\n",
        "print(bos)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wgaShixq4UwE"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TPbj7n2h4Uye"
      },
      "source": [
        "################       for loop        ###############"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zy_cYk2a4U0R"
      },
      "source": [
        "# for döngülerinde ana yapimiz:\n",
        "\n",
        "for variable in iterable:\n",
        "  body\n",
        "\n",
        "# while yapisina benzerlikler:\n",
        "# for satiri sonunda colon yani : kullanimi\n",
        "# body ye baslamadan önce 1 tab indentation\n",
        "\n",
        "\n",
        "# while dan farkli olan hususlar:\n",
        "\n",
        "# iterable lar ile döngü olusturur yani bir iterable verinin elemanlari\n",
        "# üzerinde gezinir\n",
        "# condition ile calismaz\n",
        "# while dan farkli olarak \"i\" gibi bir degisken alir\n",
        "# for döngüsünde list comprehension mümkün, while da yok\n",
        "\n",
        "# Soru? for döngüsünde de while döngüsünde oldugu gibi sonsuz döngü var midir?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BRP38fNn4U_Z"
      },
      "source": [
        "# for döngüsü calisma prensibini bu örnekte hem manuel olarak uygulayarak\n",
        "# hem de for döngüsü calistirarak görelim:\n",
        "\n",
        "# döngülerde kullanilan \"i\" harfini genelgecer bir kural olarak görebiliriz.\n",
        "# uluslararasi olarak bu sekilde alisilmis ve iteration kelimesinden gelmektedir\n",
        "\n",
        "# for döngüsü her iteration da, i degiskenine atama assigning yapar.\n",
        "# yani her iteration da i'nin degerinde bir güncelleme gerceklesir.\n",
        "\n",
        "liste = [1, 2, 3, 4, 5]\n",
        "# for i in liste:\n",
        "#   print(i)\n",
        "\n",
        "i = 0\n",
        "i = liste[0]\n",
        "print(i)\n",
        "\n",
        "\n",
        "i = 1\n",
        "i = liste[1]\n",
        "print(i)\n",
        "\n",
        "\n",
        "i = 2\n",
        "i = liste[2]\n",
        "print(i)\n",
        "\n",
        "\n",
        "i = 3\n",
        "i = liste[3]\n",
        "print(i)\n",
        "\n",
        "\n",
        "i = 4\n",
        "i = liste[4]\n",
        "print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ft7vqSGW4VBj"
      },
      "source": [
        "## for döngüsünün body kisminda variable'i yani i degiskenini kullanmak \n",
        "# zorunda degiliz. Bunun yerine herhangi bir sey konulabilir.\n",
        "\n",
        "liste = [1, 2, 3, 4, 5]\n",
        "\n",
        "for i in liste:  ## bunun yerine range(0, 5) de kullanabiliriz\n",
        "  print(\"mehmet\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jkpiIx714VDp"
      },
      "source": [
        "# for döngüsünden ciktiktan sonra i'nin degerini kullanmaya ihtiyac duyarsak:\n",
        "# Bu durumda ne output aliriz ??\n",
        "\n",
        "for i in range(0,8):\n",
        "  print(i)   \n",
        "              \n",
        "\n",
        "print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oRSj_mW44VFw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KdBQiK1S4VJj"
      },
      "source": [
        "##  hatirlatma:\n",
        "# range func icerisindeki degerleri ortaya cikarmanin birkac yolu vardir\n",
        "# 1:  for döngüsü icinde kullanma\n",
        "# 2:  list, tuple ve set gibi func'lar icerisinde kullanma\n",
        "# 3:  range func önünde yildiz kullanma(asteriks)\n",
        "\n",
        "\n",
        "print(*range(0,10))\n",
        "\n",
        "print(list(range(0,10)))\n",
        "print(tuple(range(0,10)))\n",
        "print(set(range(0,10)))\n",
        "# print(dict(range(0,10)))  # dict ile e calisir mi?\n",
        "\n",
        "for i in range(0,10):\n",
        "  print(i)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NS2X_IILojZv"
      },
      "source": [
        "##  Peki: * ile tüm elemanlari ayirip daha sonra bir yerde \n",
        "# kullanma sansimiz var midir ? Yani listelerdeki gibi indexleme \n",
        "# slayslama yapilabilir mi??\n",
        "\n",
        "print(*range(0,10))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fsGSDAnn4VLr"
      },
      "source": [
        "tuplem = (1, \"cilek\", 2.5, True, None, 0, 3+5j)\n",
        "\n",
        "for i in tuplem:         ### tuple larda for loop calisir mi??\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tvburELv4VNw"
      },
      "source": [
        "setim = {1, \"kiraz\", 2.5, True, None, 0, 3+5j}\n",
        "\n",
        "for i in setim:   ## setler unordered dir. setlerde de for loop calisir mi?\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wB8KDnr7ECNQ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zD7y4Gd9IUq7"
      },
      "source": [
        "a = [5]  ### Burada a degiskenini for döngüsü ile iterate edebilir miyiz??\n",
        "\n",
        "for i in a:\n",
        "  print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LmAV7N0Fps-X"
      },
      "source": [
        "a = (5,)\n",
        "\n",
        "for i in a:\n",
        "  print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QOki4LGdptAl"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YeFQ1Ds7IVEG"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZmbxIpy1ECQ8"
      },
      "source": [
        "### Task:\n",
        "# elimizde isimlerden olusan bir liste var.\n",
        "# ve biz her bir ismin önüne hello \n",
        "# ve her bir isimden sonra iyi günler yazmak istiyoruz.\n",
        "# nasil yapariz?\n",
        "\n",
        "liste = [\"ayse\", \"emine\", \"hakan\", \"gökhan\", \"tomy\"]\n",
        "\n",
        "## vvvv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "43Sphv4GpKQp"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rmEwOsc6pKTG"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lcgjQ1jspKVJ"
      },
      "source": [
        "for i in liste:\n",
        "  print(\"hello\", i, \"iyi günler\")       \n",
        "  print(f\"Hello, {i}, iyi günler\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JPkJ2dB2pKW4"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X9dp0_bAECUz"
      },
      "source": [
        "## task\n",
        "# bir tane listemiz var ve biz bu listenin elemanlarini alt alta degil de\n",
        "# yan yana ve bir liste icerisinde yazdirmak istiyoruz\n",
        "# ve sadece tek satir output almak istiyoruz.  nasil yapariz ??\n",
        "\n",
        "liste = [1, \"kiraz\", 2.5, True, None, 0, 3+5j, \"Ankara\", \"Istanbul\"]\n",
        "bos = []\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-m9zuDe8ECW7"
      },
      "source": [
        "# task \n",
        "# elimizde bir string var ve biz bu string'in her bir elemani arasina\n",
        "#  # karakteri koymak istiyoruz. ve hepsini tek satirda yan yana\n",
        "# cikti almak istiyoruz. Output'un Veri tipinin de string olmasini\n",
        "# istiyoruz.   nasil yapariz??\n",
        "\n",
        "girdi = input(\"lütfen bir kelime giriniz: \")\n",
        "bos = []\n",
        "\n",
        "for i in girdi:             #  <<<==  2. cözüm yolu\n",
        "  bos.append(i)\n",
        "  bos.append(\"#\")\n",
        "a = \"\".join(bos)\n",
        "print(a.strip(\"#\"))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wOxyUDr1ECYl"
      },
      "source": [
        "#### Hocanin cözümü:\n",
        "\n",
        "girdi = input(\"lütfen bir kelime giriniz: \") # ankara\n",
        "\n",
        "counter = 0\n",
        "\n",
        "for i in girdi:\n",
        "  counter += 1          ### Bu yöntem de counter kullanma sebebi son karaktere # gelmemesi\n",
        "  if counter < len(girdi):\n",
        "    print(i, end = \"#\")\n",
        "  else:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dqep4XMe0OTJ"
      },
      "source": [
        "## burada da diger bir yöntem:\n",
        "# sadece sonda print yaziyoruz\n",
        "\n",
        "girdi = input(\"lütfen bir kelime giriniz: \")\n",
        "\n",
        "counter = 0\n",
        "\n",
        "for i in girdi:\n",
        "  counter += 1\n",
        "  if counter < len(girdi):\n",
        "    i = i + \"#\"\n",
        "  else:\n",
        "    i = i\n",
        "  print(i, end =\"\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F_DRa9YfstWR"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lzvuASAn0OVv"
      },
      "source": [
        "## dict örnegi:\n",
        "# normalde bir degiskeni print ettirmek istedigimizde output da o degiskenin\n",
        "# value sunu görürüz. peki bu durum dict lerde nasildir ?\n",
        "\n",
        "# önce bu örnege bakalim.Sonra da eger \n",
        "# bu kod calisir ise value lari output alalim\n",
        "# en sonunda da itemlari alalim\n",
        "\n",
        "user = {\"name\" : \"Daniel\",\"Surname\" : \"Smith\",\"age\" : 35}\n",
        "\n",
        "for i in user:\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MoDF5BZBtE8-"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2jRjKWTpt8wS"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FmATOVk86d2Y"
      },
      "source": [
        "### value lar\n",
        "\n",
        "user = {\n",
        "    \"name\" : \"Daniel\",\n",
        "    \"Surname\" : \"Smith\",\n",
        "    \"age\" : 35\n",
        "}\n",
        "\n",
        "for i in user.values():\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LWCj3QyL0OZa"
      },
      "source": [
        "#   Dikkat: Bu sekilde print edersek nasil  bir sonuc aliriz\n",
        "# asagidaki hücredeki gibi olsa nasil olur?\n",
        "\n",
        "user = {\n",
        "    \"name\" : \"Daniel\",\n",
        "    \"Surname\" : \"Smith\",\n",
        "    \"age\" : 35\n",
        "}\n",
        "\n",
        "for i in user.items():\n",
        "  print(i)              ## dikkat sadece i print ediliyor. ama asagida i ve j\n",
        "  print(type(i))        ## output da item ve value aralarina ne girer??\n",
        "                        # ayrica outputlarda parantez ve \"\" var mi dikkat edelim\n",
        "\n",
        "                        # son olarak da burada veri type imiz ne olur??"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l41EXC3M7GLL"
      },
      "source": [
        "user = {\n",
        "    \"name\" : \"Daniel\",\n",
        "    \"Surname\" : \"Smith\",\n",
        "    \"age\" : 35\n",
        "}\n",
        "\n",
        "for i, j in user.items():\n",
        "  print(i , j)  ##  burada output nasil olur. asagida nasil olur?\n",
        "  print(type(i), type(j))  ###  type dikkat"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hMsAAFIu7hop",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "480313c9-52d9-4e6f-bb88-07f993aa8f55"
      },
      "source": [
        "user = {\n",
        "    \"name\" : \"Daniel\",\n",
        "    \"Surname\" : \"Smith\",\n",
        "    \"age\" : \"35\"\n",
        "}\n",
        "\n",
        "for i, j in user.items():\n",
        "  print(i + \":\"+ j)  ###  Dikkat: aralara + koyduk. Ne sonuc aliriz?"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "name:Daniel\n",
            "Surname:Smith\n",
            "age:35\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zdhc3jGtIc--",
        "outputId": "23d45584-fe52-4c3b-e2a1-96a579fbd554"
      },
      "source": [
        "a = list (map(str, \"mustafa ahmet göksel \".split() ))\n",
        "\n",
        "print(a)"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['mustafa', 'ahmet', 'göksel']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "LzlwhLwiIdJO",
        "outputId": "7e4e89a0-376b-4ff0-d387-cdaed5d05208"
      },
      "source": [
        "a = list (map(str, \"mustafa ahmet göksel \".split() ))\n",
        "print(a)\n",
        "bos = []\n",
        "for i in a:\n",
        "  i = [i]\n",
        "  bos.append(i\n",
        "print(bos)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-4568daab1e57>\"\u001b[0;36m, line \u001b[0;32m7\u001b[0m\n\u001b[0;31m    print(bos)\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D6SQjnjC0Oc7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fac1c25b-83d4-4aed-c36e-9f0acde8f348"
      },
      "source": [
        "###  task :\n",
        "# kullanicilardan öncelikle isim ve soyisim bilgilerini alacak sekilde bir\n",
        "# kod yazalim. sonrasinda alinan bu girdileri dict formatinda olacak sekilde\n",
        "# isim ve soyisim itemlari yapalim. ve en sonunda da bilgi giris tarih siralamasina\n",
        "# göre bir liste icinde data base simizde muhafaza edelim.\n",
        "\n",
        "girdi = list(map(str, input(\"Aralarda bosluk ile lütfen isim ve soyisimleri giriniz: \").split()))\n",
        "\n",
        "isim = []\n",
        "soyisim = []\n",
        "\n",
        "counter = 0\n",
        "database = []         ## Not bu kod ile tüm isim soyisimler ayri bir dictionary\n",
        "\n",
        "\n",
        "for i in girdi:\n",
        "  if counter % 2 == 0:\n",
        "    i = [i]\n",
        "    isim.append(i)\n",
        "  else:\n",
        "    i = [i]\n",
        "    soyisim.append(i)\n",
        "    \n",
        "  counter += 1\n",
        "\n",
        "for i, j in zip(isim, soyisim):      \n",
        "  zipp = dict(zip(i, j))\n",
        "  database.append(zipp)\n",
        "print(database)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Aralarda bosluk ile lütfen isim ve soyisimleri giriniz: li er kaya kıl\n",
            "[{'li': 'er'}, {'kaya': 'kıl'}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ARqVr1v0KHxF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WXFDSfb73a8X",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6060500e-aa05-4f6b-c20a-247d025cc79e"
      },
      "source": [
        "# Burada da tüm veriler sadece bir dict icerisinde \n",
        "\n",
        "girdi = list(map(str, input(\"Aralarda bosluk ile lütfen isim ve soyisimlerini giriniz: \").split()))\n",
        "\n",
        "new = []\n",
        "new2 = []\n",
        "counter = 0\n",
        "\n",
        "\n",
        "for i in girdi:\n",
        "  if counter % 2 == 0:\n",
        "    new.append(i)\n",
        "  else:\n",
        "    new2.append(i)\n",
        "  counter += 1 \n",
        "\n",
        "zipp = dict(zip(new, new2))\n",
        "database = []\n",
        "database.append(zipp)\n",
        "print(database)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Aralarda bosluk ile lütfen isim ve soyisimlerini giriniz: ali erdoğan feyza zeyrek\n",
            "[{'ali': 'erdoğan', 'feyza': 'zeyrek'}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sZRp9tf53bIF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z0Wlxiy40OfO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "adcc8fb2-05f2-43f4-e283-ca0eedda1c89"
      },
      "source": [
        "## for döngüsünde birden cok variable ile tuple lar icerisinde gezme:\n",
        "# unpacking\n",
        "\n",
        "liste = [(\"a\",\"b\"), (\"c\", \"d\")]\n",
        "\n",
        "for x, y in liste:\n",
        "  print(x, y)\n",
        "\n",
        "## Dikkat: burada a  ve b ciftlerimizin tuple olmasi sart degildir.\n",
        "# liste icinde tuple degil de liste de olsa, set de olsa python cift olduklarini algilar \n",
        "# sadece dict ler de calismaz (asagida oldugu gibi)"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a b\n",
            "c d\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xmo6mH1erK54",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c975301b-fb57-4fe5-99f1-208f6d849d60"
      },
      "source": [
        "##  sadece x degiskeni kullansak output ne olur?\n",
        "\n",
        "liste = [(\"a\",\"b\"), (\"c\", \"d\")]\n",
        "\n",
        "for x in liste:\n",
        "  print(x)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('a', 'b')\n",
            "('c', 'd')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t7TbZNkB_jLj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 214
        },
        "outputId": "783755ae-a3d1-47d3-b500-79aed90d72a6"
      },
      "source": [
        "liste = [{\"a\" : \"b\"}, {\"c\" : \"d\"}] \n",
        "\n",
        "for x, y in liste:\n",
        "  print(x, y)        ##  Burada sadece x kullanirsak o zaman calisir "
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-15-0b3246b92102>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mliste\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;34m\"a\"\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0;34m\"b\"\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m\"c\"\u001b[0m \u001b[0;34m:\u001b[0m \u001b[0;34m\"d\"\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mliste\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m        \u001b[0;31m##  Burada sadece x kullanirsak o zaman calisir\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: not enough values to unpack (expected 2, got 1)"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a7bxr0e70Og-"
      },
      "source": [
        "## tuple larin bu özelligi ile yine tuple larin immutable özelliklerini\n",
        "# birlestirerek biz nerede kullanabiliriz.\n",
        "# Mesela diyelim sirketimizde calisan personelin ocak, temmuz ve aralik maaslarini\n",
        "# personelimizden istiyoruz ve bunlarin sirasi degismeden ve bu bilgilerin kaybolmadan\n",
        "# muhafaza edilmesini istiyoruz. O durumda kullanicidan gelen 3 bilgiyi\n",
        "# aninda tuple yapip dogrudan liste icine append edebiliriz.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_xaSadxI0OjL"
      },
      "source": [
        "#######         Operations with for loops\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3PKwA_Ch0OlA"
      },
      "source": [
        "##  kullaniciya bir islemi kac kez yapmamiz gerektigini soruyoruz\n",
        "# daha sonra o islemi o kadar kez icra ediyoruz.\n",
        "# Mesela telefon alarmi düsünelim. Alarm kac kez tekrar etsin kullaniciya soralim\n",
        "\n",
        "a = input(\"Lütfen alarm saatini giriniz: \")\n",
        "\n",
        "print(f\"Saatiniz {a} olarak ayarlandi\")\n",
        "\n",
        "tekrar = int(input(\"Alarmin kac kez tekrar etmesini istersiniz? \"))\n",
        "\n",
        "for i in range(tekrar):\n",
        "  print(\"Guguk Guguk Guguk\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dqzf7ftVECa4"
      },
      "source": [
        "##  Simdi de hepimiz icin sinir bozucu olan Alarm algoritmasi yapalim\n",
        "\n",
        "saat = round(float(input(\"Lütfen alarm saatini (18.05) formatinda giriniz: \")), 2)\n",
        "print(f\"Alarminiz {saat} olarak basariyla kuruldu\")\n",
        "print(f\"Guguk Guguk Guguk, Uyanma Zamani, Saat = {saat}\")\n",
        "\n",
        "tus = input(\"Lütfen bir tusa basiniz: \")\n",
        "\n",
        "while tus == \"ortatus\" or tus == \"erteleme\":  ##  burada and olursa calismaz \n",
        "  saat += 0.05\n",
        "  tepki = \"Guguk Guguk Guguk\"\n",
        "  print(\"{} saat {} \" .format(tepki, round(saat, 2)))\n",
        "  tus = input(\"Lütfen bir tusa basiniz: \")\n",
        "\n",
        "  if tus == \"kapatma\":\n",
        "    print(\"Alarm Kapatildi\")\n",
        "    break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R64mnYjE4VQD"
      },
      "source": [
        "### basit bir hesap makinesi\n",
        "# kullanicidan kullanicinin istedigi miktarda sayi alalim ve\n",
        "# hangi matematiksel islemi yapmak istedigini soralim\n",
        "\n",
        "sayilar = list(map(int, input(\"Lütfen sayi giriniz: \").split()))\n",
        "print(f\"Girdiginiz sayilar: {sayilar}\")\n",
        "islem = input(\"Lütfen yapmak istediginiz islemi giriniz: \")\n",
        "bos = 1\n",
        "\n",
        "\n",
        "for i in sayilar:\n",
        "  if islem == \"*\":\n",
        "    bos *= i\n",
        "    \n",
        "  elif islem == \"+\":  ## Not burada islem + - olunca bos degiskeni 0 olmasi gerekir\n",
        "    bos += i           #  nasil yapabiliriz ??\n",
        "     \n",
        "  elif islem == \"/\":\n",
        "    bos /= i\n",
        "    \n",
        "  elif islem == \"-\":\n",
        "    bos -= i\n",
        "  elif islem == \"**\":\n",
        "    bos **= i\n",
        "  else:\n",
        "    print(\"Hatali giris yaptiniz üzgünüz!!!\")\n",
        "\n",
        "print(bos)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0YuADsG4OwPB"
      },
      "source": [
        "\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Uqe7_fXQOwRk"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lqyZPYREIXht"
      },
      "source": [
        "# derste yaptigimiz basit carpim tablosu\n",
        "\n",
        "sayi = int(input(\"Lütfen bir sayi giriniz: \"))\n",
        "\n",
        "for i in range(11):\n",
        "  print(f\"{sayi} * {i} = {sayi * i}\")\n",
        "\n",
        "  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tE5Wsd4cIXmG"
      },
      "source": [
        "# derste yaptigimiz basit carpim tablosu\n",
        "# formatlama methodu ile\n",
        "\n",
        "sayi = int(input(\"Lütfen sayi giriniz: \"))\n",
        "\n",
        "for i in range(11):\n",
        "  print(\"{} x {} = \" .format(sayi, i), sayi * i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7JbmTGhSIXrl"
      },
      "source": [
        "####  yari piramit:\n",
        "\n",
        "sayi = int(input(\"Lütfen bir sayi giriniz: \"))\n",
        "\n",
        "for i in range(1, sayi +1):\n",
        "  print(str(i) * i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JLSXUgtJbeSs"
      },
      "source": [
        "##  stringlerin formatlama yöntemlerini hatirlayalim:\n",
        "\n",
        "# 1:   Aritmetik operatörler ile formatlama(yukarida yaptigimiz gibi)\n",
        "#      \"*\" ve \"+\" isaretleri birden cok stringi birbirine concat yapar\n",
        "# 2:   f formating ile formatlama\n",
        "# 3:   .format ile formatlama"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LgIsd6UlIXub"
      },
      "source": [
        "#####  13. session Kahoot\n",
        "condition = (3 > 1) and (1 < 1)\n",
        "\n",
        "if \"condition\":  ##  string icinde dikkat\n",
        "  print(\"It works\")\n",
        "else:\n",
        "  print(\"Something is wrong\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MHn81sFmIXwJ"
      },
      "source": [
        "condition = (3 > 1) and (-1 < 1)\n",
        "\n",
        "if condition: \n",
        "  print(\"It works\")\n",
        "else:\n",
        "  print(\"Something is wrong\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hzm1MR9QIXx4"
      },
      "source": [
        "condition = (3 > 1) and (1 < 1)\n",
        "\n",
        "if [\"condition\"]:  ##  liste icinde dikkat\n",
        "  print(\"It works\")\n",
        "else:\n",
        "  print(\"Something is wrong\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aZa1CG0zIX0I"
      },
      "source": [
        "condition = (3 > 1) and (0 < 1)\n",
        "\n",
        "if not condition:    ### not condition\n",
        "  print(\"It works\")\n",
        "else:\n",
        "  print(\"Something is wrong\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o91nSghbIX-B"
      },
      "source": [
        "## range func calisma prensibi:\n",
        "\n",
        "# range(start, stop, step) seklindedir.\n",
        "\n",
        "## Önemli: eger parantez icerisinde tek bir rakam görürsek bu stopdur. range(10) gibi\n",
        "\n",
        "# listelerde ve stringler de ise bu durum farkli idi. liste[1] seklinde tek rakam\n",
        "# gördügümüzde bu sadece start oluyordu. liste[1: 5] ise start ve stop du.\n",
        "\n",
        "# eger range icerisinde range(1, 11) seklinde 2 rakam görürsek bu start ve stop olur\n",
        "# 3 rakam görürsek bu da start stop ve step olur.\n",
        "\n",
        "a = list(range(1, 20, 2))  ## stop ayni listeler gibi -1 olarak calisir\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bYw1AKvFIYCd"
      },
      "source": [
        "# peki range func da da negativ step var midir?\n",
        "##  var ise nasil calisir ??\n",
        "\n",
        "print(*range(10, 1, -1))     ###  vvvvvvvvvvvv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X7OTPDQ3hh3z",
        "outputId": "57222a14-5db8-4f11-ac57-1246e8b58d78"
      },
      "source": [
        "### Attention:\n",
        "# Burada önemli olan husus sudur:  Biz parantez icerisinde 1 yazdik ama \n",
        "# buna ragmen output da 1 rakamini göremiyoruz.\n",
        "# Bunun sebebi: calisma prensibi olarak stop -1 olarak calismasidir.\n",
        "# Bu demek oluyor ki, hangi yönde gidersek gidelim stop dan bir önce duruyoruz\n",
        "\n",
        "# Burada dikkat etmemiz gereken ikinci husus ise sudur:\n",
        "\n",
        "a = [1, 2, 3, 4, 5, 6]\n",
        "\n",
        "print(a[::-1])\n",
        "\n",
        "# Dikkat edersek listelerde negativ step kullandigimizda ilk eleman 6 ve son eleman\n",
        "# ise 1 dir. Yani ilk eleman en sagdaki, son eleman da en soldaki elemandir.\n",
        "\n",
        "# Ancak range de ki ilk ve son elemana baktigimizda bu durumun farkli oldugunu görürüz.\n",
        "# range de ilk eleman yine en soldaki, son eleman yine en sagdaki elemandir.\n",
        "# Bunun sebebi sudur: \n",
        "\n",
        "# Burada listeyi sadece tersten yazdirdik. Eger listede negatif slayslama yapmak isteseydik\n",
        "# Bu durumda yine elemanlarin yerini degistirmek zorunda kalacaktik\n",
        "\n",
        "# örnegin asagidaki kod bos liste döndürür\n",
        "\n",
        "a = [1, 2, 3, 4, 5, 6]\n",
        "\n",
        "print(a[0:5:-1])  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9sngM0U0IYEY"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jL4N3J8ZIYGm"
      },
      "source": [
        "##  *  asteriks'in range haricinde kullandigimizda nasil calisir?\n",
        "#  iterable lar ile kullandigimizda, iterable' i elemanlarina böler:\n",
        "# peki iterable larda nasil calisir ona bakalim \n",
        "\n",
        "\n",
        "\n",
        "print(*[\"ankara\", \"a\", \"b\", \"c\"])\n",
        "\n",
        "print(*(*\"ankara\", \"1\", \"2\", \"3\"))  ## burada cift yildiz var\n",
        "\n",
        "print(type(* [1]))  # * kullandigimizda veri tipi verinin orjinal tipi olur\n",
        "\n",
        "## Dikkat: biz bir string in elemanlarini list veya tuple func lari ile\n",
        "# elemanlarina ayirdigimizda, o elemanlari tek tek kullanabiliyor ve\n",
        "# üzerlerinde islem yapabiliyorduk.\n",
        "#  * kullandigimizda da yine elemanlari tek tek baska bir islem icin kullanabilir miyiz?? "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3WdinLHnIYIi"
      },
      "source": [
        "# dict lerde yildiz kullanirsak ne aliriz??\n",
        "\n",
        "dictim = {\"a\" : \"2\", \"b\" : \"4\"}\n",
        "\n",
        "print(*dictim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MuHiu7HbIYKr"
      },
      "source": [
        "###  zip func calisma prensibi:\n",
        "\n",
        "# fermuar gibi calisir ve 2 iterable'in elemanlarini karsilikli eslestirir.\n",
        "\n",
        "# iterable larin eleman sayilari esit olmak zorunda degildir.\n",
        "\n",
        "# Dikkat: zip func da range gibi ketum functionlardandir. O nedenle cözmek gerekir\n",
        "# (for ile, *  ile, list, tuple, set vb ile)\n",
        "\n",
        "# Dikkat: zip() func icerisine sinirsiz sayida arguman alabilir. Sadece 2 tane iterable'i\n",
        "# zip yapmak sart degildir. Alt hücrelerde örneklerini yapacagiz\n",
        "# Yani bu argumanlar birlestirmek \n",
        "# istedigimiz farkli iterable'larin variable isimleridir. Yada direkt olarak zip func icerisine\n",
        "# iterable larin kendisini de yazabiliriz. Bunun örnegi bir alt hücrede\n",
        "\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "\n",
        "b = (1, 2, 3, 4, 5)\n",
        "\n",
        "c = set(zip(a, b))\n",
        "\n",
        "print(c)\n",
        "\n",
        "# Burada dikkat etmemiz gereken husus:\n",
        "# Zip ile ürettigimiz tuple lari daha sonra teker teker alip baska bir yerde \n",
        "# kullanma sansimiz var midir ??"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lj_4lopIAEHT"
      },
      "source": [
        "# parantez icerisinde direkt iterable lari yazma\n",
        "\n",
        "x = list(zip([1, 2, 3], (\"a\", \"b\", \"c\")))       \n",
        "\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E0hEl-1VwPs2"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v0lfggS1wP2n"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QvKEWtotAm4c"
      },
      "source": [
        "## Dikkat!!!\n",
        "\n",
        "## peki zip func icerisine iki degil de tek argüman yazarsak ne olur ??\n",
        "# error mu aliriz?\n",
        "\n",
        "x = [1, 2, 3]      \n",
        "\n",
        "print(list(zip(x)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dOiCA7JkIYM3"
      },
      "source": [
        "## iterable larin tüm elemanlarini degil de, belirli elemanlarini\n",
        "# zip yapabilir miyiz??\n",
        "\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "\n",
        "b = (1, 2, 3, 4, 5)\n",
        "\n",
        "c = list(zip(a[1], b[1]))   #  <<<====  Dikkat: Bu sekilde calisir mi?\n",
        "                                ##    asagidaki hücre calisir mi?\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1UOa9ymu-bh8"
      },
      "source": [
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "\n",
        "b = (1, 2, 3, 4, 5)\n",
        "\n",
        "c = list(zip(a[0:4], b[0:4]))   \n",
        "                               \n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8XwCvHEDD276"
      },
      "source": [
        "### Task:\n",
        "# Diyelim ki iki iterable'i zipledik ama su an icin bizim zipledigimiz \n",
        "# iterable larin ürettigi tüm tuple lar bize lazim degil. Su an icin sadece\n",
        "# her bir iterable' in cift veya tek sayili elemanlarinin ürettigi tuple lar bize lazim ve \n",
        "# bunlari cekip almamiz gerekiyor. nasil yapariz?\n",
        "\n",
        "# Mesela söyle düsünelim. asagidaki iterable larda clarusway ögrenci no ve notlari \n",
        "# yaziyor. ve biz bunlari tek sayili ögrenci notlari ve cift sayili ögrenci notlari\n",
        "# diye ayiracagiz\n",
        "\n",
        "ögrenci = [\"1490\", \"1491\", \"1492\", \"1493\", \"1494\", \"1495\", \"1496\"]\n",
        "\n",
        "notlar = (80, 85, 83, 75, 90, 79, 60)\n",
        "\n",
        "counter = 0\n",
        "\n",
        "for i, j in zip(ögrenci, notlar):\n",
        "  if counter % 2 == 0:   ##  >>>   bu cift sayili olanlari üretir\n",
        "    print(i, \":\", j)\n",
        "  counter += 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pXl_nkVeBWY8"
      },
      "source": [
        "##  dikkat!!!\n",
        "# zip func ile sadece i degiskeni kullanirsak ne output aliriz?\n",
        "# asagidaki hücrede oldugu gibi i ve j kullanirsak output ne olur ??\n",
        "\n",
        "# !!!!!!    outputlarin veri tiplerine Dikkat\n",
        "\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "\n",
        "b = (1, 2, 3, 4, 5)\n",
        "\n",
        "for i in zip(a, b):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xXRfVbg5-bkD"
      },
      "source": [
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "\n",
        "b = (1, 2, 3, 4, 5)\n",
        "\n",
        "for i, j in zip(a, b):\n",
        "  print(i, j)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "juOUu7wl-bn9"
      },
      "source": [
        "# zip de ikiden fazla degisken calisir mi?\n",
        "\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "\n",
        "b = (1, 2, 3, 4, 5)\n",
        "\n",
        "c= {\"ben\", \"sen\", \"o\", \"biz\", \"siz\"}\n",
        "\n",
        "print(*zip(a, b, c))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qI1Mwfd1-bp2"
      },
      "source": [
        "###  Dikkat: zip func tek seferlik output verir ve sonra icerisi bosalir demistik.\n",
        "# Eger biz tekrar cikti almak istersek zip func i tekrar doldurmamiz gerekir.\n",
        "\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "\n",
        "b = (1, 2, 3, 4, 5)\n",
        "\n",
        "zipp = zip(a, b)\n",
        "print(*zipp)\n",
        "print(*zipp)\n",
        "print(zipp)  # asteriks kullanmaz isek ne olur??"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i3nFtxolGt0d"
      },
      "source": [
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "b = (1, 2, 3, 4, 5)\n",
        "zipp = zip(a, b)\n",
        "\n",
        "for i in zipp:\n",
        "  print(i)\n",
        "\n",
        "print(list(zipp))  ##  BU satir ne döndürür??"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sNYOsOHQGt2m"
      },
      "source": [
        "### Bu konulari internette generator ve iterator olarak bulabiliriz\n",
        "# zip func i her doldurusumuz bir generate dir"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cYabJ8H9Gt4U"
      },
      "source": [
        "###  Dikkat zip() func dict üretimi icin cok uygundur.\n",
        "# Yani bizim dictlerde ihtiyacimiz olan key value pair lari \n",
        "# zip func otomatik olarak üretir.\n",
        "\n",
        "# Elimizde bir tuple ve bir liste olmasina ragmen bunlari\n",
        "# tek bir komut ile birlestiriyoruz ve daha önemlisi de \n",
        "# dict komutu vasitasi ile outputumuz orijinal bir dict görüntüsünde oluyor  \n",
        "\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "b = (1, 2, 3, 4, 5)\n",
        "zipp = dict(zip(a, b))\n",
        "\n",
        "print(zipp)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9jogGX9XcDX_"
      },
      "source": [
        "##  zip' i string func ile kullanirsak output ne olur??\n",
        "\n",
        "a = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n",
        "b = (1, 2, 3, 4, 5)\n",
        "zipp = dict(zip(a, b))\n",
        "\n",
        "print(zipp)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hUOyzBETcQ6X"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1xeZ7WdmcRDJ"
      },
      "source": [
        "a = [\"a\", \"b\", \"c\"]\n",
        "b = (1, 2, 3)\n",
        "zipp = str(zip(a, b))\n",
        "\n",
        "print(zipp)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m5PuMxSwcXST"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9FulUdnVcXXU"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VB1Ri_DEGt6J"
      },
      "source": [
        "###  derste cözdügümüz task:\n",
        "\n",
        "# Range func ile 0 dan 20 ye kadar bir liste olusturacagiz. \n",
        "# Ve bu listenin tek elemanlarini tek isimli listeye cift elemanlarini cift\n",
        "# isimli listeye atacagiz.\n",
        "# en sonunda da listenin elemanlarini toplayip\n",
        "# her bir listenin elemanlarinin toplamini söyleyecegiz\n",
        "\n",
        "tek = []\n",
        "cift = []\n",
        "\n",
        "for i in range(20):\n",
        "  if i % 2:\n",
        "    tek.append(i)\n",
        "  else:\n",
        "    cift.append(i)\n",
        "\n",
        "print(tek)\n",
        "print(cift)\n",
        "\n",
        "# simdi de listenin elemanlarini toplayalim:\n",
        "\n",
        "tekbos = 0\n",
        "ciftbos = 0\n",
        "\n",
        "for i in tek:\n",
        "  tekbos += i\n",
        "print(f\"Tek sayilarin toplami = {tekbos}\")\n",
        "\n",
        "for i in cift:\n",
        "  ciftbos += i\n",
        "print(f\"Cift sayilarin Toplami = {ciftbos}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JgADKhAyGt79"
      },
      "source": [
        "###   Task:\n",
        "\n",
        "#  kullanicidan birden cok sayi aliyoruz. Ve kullanicinin kac adet tek sayi\n",
        "# kac adet cift sayi girdigini tekrar kullaniciya söylüyoruz:\n",
        "\n",
        "# Bu task a baslamadan önce map func integer ve float ile nasil calisir \n",
        "# mantigina bakalim:\n",
        "\n",
        "# öncelikle map() func su sekilde kurulur:\n",
        "\n",
        "# map(func, iterable) ==>> tüm bu yapiya map object denir\n",
        "\n",
        "# yani map object iterable bir eleman alir. eger biz integer gibi\n",
        "# bir veri girersek bu durumda elemanlarina ayiramaz ve hata verir.\n",
        "\n",
        "# peki map() func calismayi ne zaman durdurur?\n",
        "# ayni for döngüsü gibi icerisinde bulunan iterable'in elemanlari son buldugunda\n",
        "#  calismasi son bulur. \n",
        "\n",
        "# map() func ismi mapping den gelmektedir yani eşleme olarak bilinir,\n",
        "#  çünkü yinelenebilir bir girdideki her öğeyi sonuçta yinelenebilir bir şekilde \n",
        "# yeni bir öğeyle eşler. Bunu yapmak için, map() yinelenebilir girdideki \n",
        "# tüm öğelere bir dönüşüm işlevi uygular.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MpeMvDnBrWc2"
      },
      "source": [
        "#  map()  func'nin calisma prensibini anlamak icin for döngüsü\n",
        "# ile kiyas edelim.\n",
        "\n",
        "# elimizde bir liste olsun ve biz bu listenin her bir elemaninin karesini \n",
        "# alarak yeni bir liste olusturalim\n",
        "\n",
        "liste = [1, 2, 3, 4, 5]\n",
        "bos = []\n",
        "\n",
        "for i in liste:\n",
        "  i = i ** 2\n",
        "  bos.append(i)\n",
        "\n",
        "print(bos)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jIp2T9xtiKkv"
      },
      "source": [
        "##  simdi ayni islevi map() ile yapalim.\n",
        "\n",
        "def kare(sayi):\n",
        "  return sayi ** 2\n",
        "\n",
        "liste = [1, 2, 3, 4, 5]\n",
        "\n",
        "a = map(kare, liste) \n",
        "\n",
        "print(list(a))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ncmnzqg7rWfy"
      },
      "source": [
        "# Not: eger map func'in sonunda split kullanmaz isek girdigimiz her bir \n",
        "# karakteri tek tek ayirir. Örnegin:\n",
        "\n",
        "sayi = list(map(int, input(\"Lütfen bir sayi giriniz: \" )))\n",
        "\n",
        "print(sayi)\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IzjAYXi_kJmU"
      },
      "source": [
        "# map() func'nin split ile calisma prensibi\n",
        "\n",
        "sayi = list(map(int, input(\"Lütfen birden cok sayi giriniz: \" ).split()))\n",
        "\n",
        "print(sayi)\n",
        "\n",
        "# Burada dikkat etmemiz gereken husus nedir?\n",
        "# split() methodunu tam olarak nereye yazacagimiz hususudur.\n",
        "\n",
        "\n",
        "# Buradaki mantik su sekilde isler. map() methodu bizim verimizi tek tek\n",
        "# ayirmadan önce bizim kendi istegimize göre ayirmamiz gerekir.\n",
        "# Bu nedenle  split() methodunu direkt input verisinin pesine yazariz ki\n",
        "\n",
        "# verimiz henüz map() islemine tabi tutulmadan ayirma islemini kendimiz\n",
        "# gerceklestiririz\n",
        "\n",
        "# eger map() func parantezi disina yazarsak error aliriz"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v82iarPjkJoy"
      },
      "source": [
        "\n",
        "## Dikkat: Normal de input str cikti üretir. Biz burada input alir almaz\n",
        "# verimizi map func ile int yapiyoruz.\n",
        "\n",
        "# Burada dikkat etmemiz gereken husus sudur ve önemlidir:\n",
        "# normalde biz asagida oldugu gibi map func icerisinde int bir deger yazarsak\n",
        "# hata aliriz demistik\n",
        "\n",
        "# a = map(int, 123456)\n",
        "\n",
        "# print(a)\n",
        "\n",
        "\n",
        "\n",
        "# map burada su sekilde calisir:\n",
        "\n",
        "# user'in girdigi string veri tipindeki sayisal degeri alir,\n",
        "# iterable oldugu icin elemanlarina ayirir ve her bir elemani integer'a\n",
        "# cevirir. Ve son olarak da biz liste istedigimiz icin bunu liste icerisine atar.\n",
        "\n",
        "\n",
        "\n",
        "# asagidaki hücrede verilerin type'ina bakalim"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m8tWKIgbGt9y"
      },
      "source": [
        "sayi = list(map(int, input(\"Lütfen birden cok sayi giriniz: \" ).split()))\n",
        "\n",
        "print(type(sayi[0]))  #  user'in girdigi rakamin 0. index numarasinin veri tipi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2I_sBe3R-bte"
      },
      "source": [
        "# map func float ile nasil calisir?\n",
        "\n",
        "sayi = list(map(float, input(\"Lütfen bir sayi giriniz: \" )))\n",
        "\n",
        "print(sayi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u_9qsG4q-bvG"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FbP-POYI-bxU"
      },
      "source": [
        "## Simdi task imiza geri dönelim:\n",
        "\n",
        "###   Task:\n",
        "\n",
        "#  kullanicidan birden cok sayi aliyoruz. Ve kullanicinin kac adet tek sayi\n",
        "# kac adet cift sayi girdigini tekrar kullaniciya söylüyoruz:\n",
        "\n",
        "# Not: Bu task'in iki farkli cözüm methodu vardir.\n",
        "\n",
        "# önce 1. method ile cözelim: (counter kullanarak)\n",
        "\n",
        "sayilar = list(map(int, input(\"Lütfen birden cok sayi giriniz: \").split() ))\n",
        "\n",
        "countertek = 0\n",
        "countercift = 0\n",
        "\n",
        "for i in sayilar:\n",
        "  if i % 2:\n",
        "    countertek += 1\n",
        "  else:\n",
        "    countercift += 1\n",
        "\n",
        "print(\"{} adet tek sayi girdiniz\" .format(countertek))\n",
        "\n",
        "print(\"{} adet cift sayi girdiniz\" .format(countercift))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0fX-M9hEfinr"
      },
      "source": [
        "## ikinci methodumuz ise append() ve len() methodu ile cözüm yoludur:\n",
        "\n",
        "sayilar = list(map(int, input(\"Lütfen birden cok sayi giriniz: \").split() ))\n",
        "\n",
        "tekliste = []\n",
        "ciftliste = []\n",
        "\n",
        "for i in sayilar:\n",
        "  if i % 2:\n",
        "    tekliste.append(i)\n",
        "  else:\n",
        "    ciftliste.append(i)\n",
        "\n",
        "print(f\"{len(tekliste)} adet tek sayi girdiniz\")\n",
        "\n",
        "print(f\"{len(ciftliste)} adet cift sayi girdiniz\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1j2-6xYkfiqI"
      },
      "source": [
        "## sum()  func kullanimi:\n",
        "\n",
        "# calisma prensibi:\n",
        "\n",
        "# sum(iterable, start)  seklinde calisir.\n",
        "\n",
        "# buradaki iterable dan kasit numeric bir iterable olmasi gerektigidir.\n",
        "# Bu func,  numeric olmayan degerleri reddeder. Ama ilerleyen \n",
        "# hücrelerde buna bir care arayacagiz\n",
        "\n",
        "# start ifadesindeki anlam ise indexleme ve slicing deki start stop ve step den\n",
        "# tamamen farklidir. sum() daki start kelimesi toplama islemine baslarken\n",
        "# baslangic degerini kac kabul ettigimizdir. yani 1, 2, 3 sayilarini topladigimizda\n",
        "# toplam 6 dir. eger biz baslangic degerini 4 kabul edersek. sonuc 4 + 6 = 10 eder.\n",
        "\n",
        "a = sum([1,2,3,4,5], 0)  #  start yazmaz isek default 0 dir\n",
        "\n",
        "print(a)\n",
        "\n",
        "# Not: sum() icerisinde tek bir iterable kullanilmalidr. Bu nedenle tuple\n",
        "# kullanmak istersek parantez icerisinde kullanmamiz gerekir.\n",
        "\n",
        "# Simdi sum func' i biraz inceleyelim:\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Pj6MAnQkA_v"
      },
      "source": [
        "# Not: mesela bos bir liste kullanirsak sum() icerisinde;\n",
        "\n",
        "# Bu durumda sonuc bos liste dönmez. Bu func sayilar ile is yaptigi icin \n",
        "# sonuc 0 olur.\n",
        "\n",
        "a = sum([])\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3AsVid7SkBCP"
      },
      "source": [
        "# sum hangi collection type larda calisir?\n",
        "# liste evet\n",
        "# tuple evet\n",
        "# set evet\n",
        "# dict ? (asagidaki hücrede bakalim)\n",
        "\n",
        "a = sum({1,2,3,4,5}, 0)\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YT4gVtuEkBEJ"
      },
      "source": [
        "# dictlerde sum() func kullanmanin birkac yöntemi vardir:\n",
        "# eger items yada values keys gibi parametreler yazmaz isek ve\n",
        "# bizim keylerimizin hepsi sayisal deger ise o zaman hata vermeden\n",
        "# default olarak sadece keyleri toplar.\n",
        "\n",
        "\n",
        "# ama eger tüm value larimiz sayisal deger ise  o zaman sadece value larda toplanabilir\n",
        "\n",
        "\n",
        "# Ancak item()  lara gelince is biraz degisir. item in elemamlari olan\n",
        "# value ve keyler bir tuple icerisinde  birlestirildiginden burada toplama\n",
        "# islemi gerceklesmez ve hata verir. Yani bu islemi tek satir da yapamayiz.\n",
        "# Ancak burada söyle bir alternatif yol üretebiliirz:\n",
        "\n",
        "# bir satir da keyler toplanir. Diger satirda value lar ve bunlar\n",
        "# 3. satirda birlestirilir\n",
        "\n",
        "a = {1 : 10, 2 : 20, 3 : 30, 4 : 40, 5 : 50}\n",
        "\n",
        "x = sum(a.keys())\n",
        "y = sum(a.values()) \n",
        "z = x + y\n",
        "\n",
        "print(z)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nwijnfcCkBGH"
      },
      "source": [
        "#   sum()  func sayisal olmayan degerleri reddeder demistik.\n",
        "# yani sum ile string icerisinde sayisal degerlerde yazsa biz bu stringin \n",
        "# elemanlarini toplayamayiz.\n",
        "\n",
        "# peki bizlere verilen string bir degerin icerisindeki rakamlari toplamak\n",
        "# zorunda kalirsak neler yapabilirz ?? Cevabimiz asagida var.\n",
        "# ama biraz beyin firtinasi yapalim\n",
        "\n",
        "string = \"123456789\" # bu string icerisindeki degerleri sum ile toplayalim\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UI-sLatrfisL"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QIA5aa-lst5w"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CATC_Mm1ssTJ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7rGCV2HEssXT"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wwMTCgLqfiuC"
      },
      "source": [
        "# birinci yöntem \n",
        "\n",
        "string = \"123456789\"\n",
        "\n",
        "toplam = sum(map(int, string))   ## Dikkat burada map'i listeye yada tuple'a \n",
        "                                  # cevirmeye ihtiyac kalmadi\n",
        "print(toplam)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p7JIVitefiv1"
      },
      "source": [
        "# Ikinci yöntem\n",
        "\n",
        "string = \"123456789\" \n",
        "toplam = 0\n",
        "\n",
        "for i in string:\n",
        "  i = int(i)\n",
        "  toplam += i\n",
        "print(toplam)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zMdjqRq_twDC"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7w2g1RnhtwFd"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4qft245Gfixg"
      },
      "source": [
        "##########         14. session        ###############"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aa7Aj4PBfi1q"
      },
      "source": [
        "### derste cözdügümüz Task:\n",
        "# 1 ile 74 arasindaki sayilarin toplamini veren kodu yaziniz:\n",
        "# counter methodu ile cözüm\n",
        "\n",
        "counter = 0\n",
        "\n",
        "for i in range(1,75):\n",
        "  counter += i\n",
        "print(counter)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hcbybAo7fi3o"
      },
      "source": [
        "# uzun cözüm, iki adet for döngüsü\n",
        "\n",
        "bos = []\n",
        "\n",
        "for i in range(1,75):\n",
        "  bos.append(i)\n",
        "\n",
        "counter = 0\n",
        "for i in bos:\n",
        "  counter += i\n",
        "\n",
        "print(counter)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "prZUere9-bzR"
      },
      "source": [
        "#######   nested for loop    #########"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5lNhNmN9da0c"
      },
      "source": [
        "##  normal de for döngüsü yapilari su sekildedir:\n",
        "\n",
        "for variable in iterable:\n",
        "  body\n",
        "\n",
        "# nested for döngülerinde ise en distaki for döngüsünün body si \n",
        "# alt kisimda bulunan for döngüsüdür\n",
        "\n",
        "for variable1 in iterable1:\n",
        "  for variable2 in iterable2:\n",
        "    body\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P0wC9raTda2u"
      },
      "source": [
        "## if yapilari genel calisma prensibi nasildi?\n",
        "# i degiskenimiz yazmis oldugumuz iterable icerisine girer ve bu iterable\n",
        "# icerisinde sadece bir döngü yapar. Ve sonra body kismina gecer, body nin ise tamamini \n",
        "# calistirir. \n",
        "# yani body nin tamamini calistirdigi icin altta bulunan iterable in tüm elemanlari \n",
        "# döndürülür, daha sonra tekrar üstteki for döngüsüne dönüs yapilir.  \n",
        "\n",
        "a = [\"1 \", \"2 \", \"3 \", \"4 \"]  ### Burada output nasil olur?\n",
        "\n",
        "b = [\"bir\", \"iki\", \"üc\", \"dört\"]\n",
        "\n",
        "for i in a:\n",
        "  for ii in b:\n",
        "    print(i + ii)    # vvv  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uyB6R6iEwAMi"
      },
      "source": [
        "# nested for loop larda kac adet output umuz olacagini, iki degiskenimizin value \n",
        "# sayilarini carparak hesap edebiliriz.\n",
        "\n",
        "\n",
        "# yani asagidaki sekilde degerlendirdigimizde, sagdaki tüm degerleri soldaki\n",
        "# ilk elemana teker teker assign eder, daha sonra soldaki ikinci elemana \n",
        "# assign islemine gecer\n",
        "\n",
        "# [\"1 \", \"2 \", \"3 \", \"4 \"] <=====> [\"bir\", \"iki\", \"üc\", \"dört\"] "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CrWc4Rrkda4p"
      },
      "source": [
        "## nested for loop lari daha iyi anlamak  ve nested for yapisinin \n",
        "# nasil calistigini aklimizda daha iyi tutabilmek icin söyle bir örnek düsünelim.\n",
        "\n",
        "# ilkokullarda ortaokullarda ve listeler de 1 den 11 e kadar sinif\n",
        "# numaralari vardir. Ve her bir sinif kendi icerisinde a  b c d e f g\n",
        "# seklinde harflendirilmistir. Iste bu sinif numaralari ve harflendirme\n",
        "# islemini tek bir kod ile yapmaya calisalim.\n",
        "\n",
        "# Burada dikkat etmemiz gereken husus, hangi verinin önce return ettirilmesi istiyorsak\n",
        "# o veriyi üstteki yani ilk for döngüsü icerisine yerlestirmemiz gerekir\n",
        "\n",
        "sinif = [1, 2, 3, 4, 5, 6, 7, 8]\n",
        "\n",
        "harfler = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n",
        "\n",
        "for i in sinif:\n",
        "  for ii in harfler:\n",
        "    print(i, ii)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2fKzurmPda6h"
      },
      "source": [
        "## Bir diger örnegimizde su sekildedir:\n",
        "# Her bir araba markasinin a, b, c, d ve suv segmentleri ve\n",
        "# bu segmentlere göre adlandirilmis özel isimleri bulunmaktadir.\n",
        "# araba markalarindan ve modellerinden olusan bir kod yazalim\n",
        "\n",
        "marka = [\"mercedes\", \"bmw\", \"volkswagen\", \"seat\", \"audi\"]\n",
        "\n",
        "model = [\"a\", \"b\", \"c\", \"d\", \"suv\"]\n",
        "\n",
        "for i in marka:\n",
        "  for ii in model:    ### Dikkat: nested for'larda, ayni degisken kullanilmaz\n",
        "    print(i, \":\", ii)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DmhmwwWxiMos"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "apjLhC-c0LNS"
      },
      "source": [
        "# List Comprehension"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jgLr5YXKiMrS"
      },
      "source": [
        "# normal bir for loop yapisi:\n",
        "for item in iterable:\n",
        "  expression(body)   ## yani önce for satiri sonra body"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AYoWvq2wiMtg"
      },
      "source": [
        "# list comprehension yapisi ise su sekildedir:\n",
        "\n",
        "[expression for item in iterable]\n",
        "\n",
        "# yani önce body sonra for\n",
        "\n",
        "## Not: Kafa karisikligi olusturmamasi acisindan list comprehension yapisi\n",
        "# kurmanin en kolay yolu; normal for döngüsü siralamasinda yapi kurularak\n",
        "# en son basa dönüp body kismini yazmaktir\n",
        "\n",
        "# normal for loop da, python a öncelikle nerede döngü yapacagini söyleriz\n",
        "# daha sonra ise bu döngü icerisinde ne yapacagini söyleriz.\n",
        "\n",
        "# list comp da ise; önce python a ne yapacagini söyleriz daha sonra\n",
        "# bunu nerede yapacagini söyleriz\n",
        "\n",
        "# list comprehension kullanarak daha az degisken kullanacagimiz icin,\n",
        "# ve bu kullanim sayesinde normal for döngüsüne göre daha az kod yazmamiz gerektiginden \n",
        "# olusturdugumuz programin hizini artirabiliriz"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U5fuMVBYiMvX"
      },
      "source": [
        "##  normal for döngülerinde elimizde bos bir liste bulunur ve \n",
        "\n",
        "# biz bu listenin icerisine disaridan attigimiz elemanlar ile doldurururuz\n",
        "\n",
        "# list comprehension da ise listenin icerisindeyiz ve önemli olan sudur\n",
        "\n",
        "# liste icerisine disaridan eleman cekmiyoruz. Liste icerisinde bulunurken\n",
        "\n",
        "#  listenin disina cikmadan for döngüsü calistiriyoruz ve iceride eleman üretiyoruz\n",
        "\n",
        "# expression kismina ne yazdi isek, hepsi listenin elemanlari haline gelir ve\n",
        "\n",
        "# virgüller ile birbirinden ayrilir.\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k8qX5LP2iMxN"
      },
      "source": [
        "## klasik bir for döngüsünü list comp yapalim\n",
        "\n",
        "bos = []\n",
        "\n",
        "for i in range(8):  ## Dikkat etmemiz gereken husus: Normal for döngülerinde bulunan\n",
        "  bos.append(i)     # noktalama isaretlerini burada kullanmiyoruz.  sadece space yeterli \n",
        "\n",
        "print(bos)    ##  bunu simdi beraber list comp yapalim"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-iLl-lnkx-A1"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cYwrTj-YiMy2"
      },
      "source": [
        "##   Dikkat normal for döngüsünde listenin disarisinda oldugumuz icin, \n",
        "# listenin icerisine eleman eklemek icin append methodu kullanilir.\n",
        "\n",
        "# Ancak list comp' larda listenin icerisinde bulundugumuzdan dolayi,\n",
        "# append kullanmamiza gerek yoktur.\n",
        "\n",
        "# expression kismina, neyi output almak istiyorsak onu yaziyoruz\n",
        "# yani bu kisimda outputumuzu istedigimiz sekilde formüle ediyoruz\n",
        "\n",
        "a = [(i ** 2) / 2 for i in range(8)]\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RQZb0Hw6iM0x"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3exMaiqwda8a"
      },
      "source": [
        "##  output taki her elemanimizi nasil ayri ayri liste, tuple yada set yapariz?\n",
        "\n",
        "# liste ve set icin sadece i'yi [] icerisine yada {} icerisine almamiz yeterlidir.\n",
        "# ancak tuple yaparken sadece () icerisine almamiz yeterli degildir.\n",
        "# cünkü tek elemanli tuple yapimi farklidir\n",
        "\n",
        "\n",
        "a = [[i] for i in range(10)]\n",
        "\n",
        "print(a)\n",
        "\n",
        "a = [{i} for i in range(10)]\n",
        "\n",
        "print(a)\n",
        "\n",
        "a = [(i,) for i in range(10)]\n",
        "\n",
        "print(a)\n",
        "\n",
        "# a = [tuple(i) for i in range(10)]   ##  Bu sekilde ne output aliriz???\n",
        "\n",
        "# print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LhnT2AgUda-L"
      },
      "source": [
        "# kücük listeler seklinde islem yapmak da mümkündür:\n",
        "# Mesela elimizde iki tane liste var. Biz bu listenin elemanlarini zip ile\n",
        "\n",
        "# birlestirelim. birbirleri ile toplayip ikiye bölelim ve karelerini alalim.\n",
        "# son olarak da hepsini liste icine atip saklayalim\n",
        "\n",
        "# Not burada ayni zamanda round() func kullanimini hatirlayalim\n",
        "\n",
        "a = [1, 2, 3, 4, 5]\n",
        "\n",
        "b = [6, 7, 8, 9, 10]\n",
        "\n",
        "a = [[round(((i + ii) / 2) ** 2, 1)] for i, ii in zip(a, b)]\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Xr5rIUSda_-"
      },
      "source": [
        "a = [1, 2, 3, 4, 5]\n",
        "\n",
        "b = [6, 7, 8, 9, 10]\n",
        "\n",
        "for i, ii in a, b:  ##  Önemli:  eger burada oldugu gibi iki listenin ismi \n",
        "  print(i, ii)      # zip gibi herhangi bir func yada method kullanmadan yazarsak\n",
        "                    # kodumuz calismayacaktir."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1CToZ9rCIYO4"
      },
      "source": [
        "###  if statements ile list comprehension birlesimi:\n",
        "# Bu if yapilarina ternary if condition denir. yani tek satirda if yapilari\n",
        "\n",
        "# Burada yapimiz su sekildedir:\n",
        "\n",
        "#  [ne yapmali?(body)   ne icin ve nerede yapmali?(for)   hangi durumda yapmali(if else) ]\n",
        "\n",
        "# bunu asagidaki örnekle inceleyelim"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pIUEAuTKdP83"
      },
      "source": [
        "# elimizde bir liste var. Biz bu listenin elemanlarindan tek sayi olanlarin\n",
        "# karesini almak istiyoruz ve bunu bos bir listede depolamak istiyoruz.\n",
        "# bunu öncelikle normal for döngüsü ile yapalim\n",
        "\n",
        "\n",
        "listem = [10, 11, 12, 13, 14, 15, 16, 17, 18]\n",
        "bos= []\n",
        "for i in listem:\n",
        "  if i % 2: \n",
        "    bos.append(i ** 2)          ## bu yapida bos bir liste atamak ve append kullanmak\n",
        "print(bos)                      # zorundayiz"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fm1BB9Oa4VRo"
      },
      "source": [
        "##  simdi de list comprehension ile yapalim\n",
        "\n",
        "# Dikkat: bir liste icerisinde for if else ve body leri ayni anda kullaniyoruz\n",
        "\n",
        "# ve aralarda hicbir noktalama isareti kulanmiyoruz\n",
        "\n",
        "listem = [10, 11, 12, 13, 14, 15, 16, 17, 18]\n",
        "\n",
        "a = [i ** 2 for i in listem if i % 2]\n",
        "\n",
        "print(a)           \n",
        "\n",
        "#  Bu yapilarda elif yoktur. sadece if ve else vardir\n",
        "\n",
        "# Dikkat: Eger kurdugumuz yapida body, for ve if'in yerlerini degistirir isek,\n",
        "# o zaman kodumuz calismaz.\n",
        "\n",
        "# Dikkat etmemiz gereken bir diger husus sudur:\n",
        "# for döngüsü  body si for un solunda kalan kisimdir.\n",
        "# if döngüsü body si ise if in solunda kalan komple kisimdir.(for da buna dahildir)\n",
        "\n",
        "\n",
        "\n",
        "# yani buradan cikan sonuc sudur: \n",
        "# normal yapilarda hem for loop'un hem de if statement'in body leri \n",
        "# kendilerinden sonra yani alt satirda gelir. Ama list comprehension larda\n",
        "# bu durum tam tersine döner ve body ler kendilerinden önce gelir.\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ro96IfY5o5o"
      },
      "source": [
        "## peki else de kullanmak istersek nasil  bir yapi kurmaliyiz ??\n",
        "\n",
        "listem = [10, 11, 12, 13, 14, 15, 16, 17, 18]\n",
        "\n",
        "a = [i ** 2 for i in listem if i % 2]\n",
        "\n",
        "print(a)         "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "09bxaRA96Uis"
      },
      "source": [
        "#  diger bir else' li örnek\n",
        "\n",
        "# fruits = [\"mango\" if i%3 == 0 else \"orange\" for i in range(10)]\n",
        "# print(fruits)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g6ikArSC7XdT"
      },
      "source": [
        "# nested for looplar ile list comprehension\n",
        "\n",
        "liste = [f\"{str(i)} - {j}\" for i in range(1, 4) for j in [\"a\", \"b\", \"c\"]]\n",
        "\n",
        "print(liste)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LhVnu6548lk9"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3o5EqPyA8mUp"
      },
      "source": [
        "## nested if statements lar ile list comprehension:\n",
        "\n",
        "\n",
        "liste = [i for i in range(50) if i % 2 == 0 if i % 3 == 0 if i % 4 == 0]\n",
        "\n",
        "print(liste)\n",
        "\n",
        "# Dikkat bu örnekte sadece tek bir cikti var o da i dir.\n",
        "# Peki list comprehension ile birden cok cikti print ettirebilir miyiz?\n",
        "# mesela \n",
        "# if i % 2 == 0   print(2)\n",
        "# if i % 3 == 3   print(3)\n",
        "# else            print(\"x\")    # vvv"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7-PGFiIRq3_m"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G_-nxAdUq4B6"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TTAJPDEbq4Ee"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLOy0qTrq4Hm"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9cslk2Kb9dKc"
      },
      "source": [
        "liste = [\"2\" if i % 2 == 0 else \"3\" if i % 3 == 0 else \"x\" for i in range(10)]\n",
        "\n",
        "print(liste)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z9uCZd2spbmv"
      },
      "source": [
        "a = [1, 2, 3, 4, 5]\n",
        "\n",
        "b = [\"yes\" if i == 1 else \"no\" if i == 2 else \"idle\" for i in a]\n",
        "\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ui6497h-zdOB"
      },
      "source": [
        "##  araba modelleri sorusunu list comprehension ile cözelim:\n",
        "\n",
        "marka = [\"mercedes\", \"bmw\", \"volkswagen\", \"seat\", \"skoda\"]\n",
        "\n",
        "model = [\"a\", \"b\", \"c\", \"d\", \"suv\"]\n",
        "\n",
        "\n",
        "# Dikkat nested for yapisi kuracagiz ve ana for nerede olacak\n",
        "# nested for nerede olacak?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YKPHbxRq-aGz"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sx2FXIm7-aJg"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gDKJEBiz-aL_"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kuh0x8MNfYzZ"
      },
      "source": [
        "marka = [\"mercedes\", \"bmw\", \"volkswagen\", \"seat\", \"skoda\"]\n",
        "\n",
        "model = [\"a\", \"b\", \"c\", \"d\", \"suv\"]\n",
        "\n",
        "new = [i + \" -\" + ii for i in marka for ii in model]\n",
        "                                               \n",
        "print(new)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YprVUiBSkzrs"
      },
      "source": [
        "# Dikkat:\n",
        "\n",
        "## list comprehension kullanarak ayni liste icerisine degil de baska\n",
        "\n",
        "# bir liste icerisine append yapilabilir mi??\n",
        "\n",
        "bos = []\n",
        "\n",
        "a = [bos.append(i) for i in range(5)]\n",
        "\n",
        "print(bos)   ##  print(a)  dersek output ne olur?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tGLw2442lmRR"
      },
      "source": [
        "### Dikkat!!!!!!\n",
        "# peki bu list comprehension a disaridaki bir for ile eleman\n",
        "# ekleyebilir miyiz??\n",
        "\n",
        "bos = []\n",
        "a = [bos.append(i) for i in range(5)]\n",
        "\n",
        "print(a)\n",
        "\n",
        "for i in range(5):\n",
        "  a.append(i)\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JwbMAtfcfY1v"
      },
      "source": [
        "a = [\"a\", \"b\", \"c\", \"d\"]\n",
        "b = [\"1\", \"2\", \"3\", \"4\"]\n",
        "\n",
        "for i in a, b:          # Burada i ve ii zip seklinde 2 degisken kullanirken\n",
        "   print(i)             # zip kullanmazsak kodumuz calismaz demistik.\n",
        "                        # peki iki listede tek i degiskeni kullanirsak\n",
        "                        # ne sonuc aliriz ?  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d5kbA-t1fZA0"
      },
      "source": [
        "# derste cözdügümüz örnek\n",
        "\n",
        "(monday, tuesday, wednesday, thursday, friday, saturday, sunday) = range(1, 8)\n",
        "\n",
        "print(monday)\n",
        "print(friday)\n",
        "\n",
        "## dikkat 1 deyince gün gelmez"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tb7-FT-rzdQR"
      },
      "source": [
        "## enumerate kullanimi:\n",
        "\n",
        "günler = (\"monday\", \"tuesday\", \"wednesday\", \"thursday\", \"friday\", \"saturday\", \"sunday\")\n",
        "\n",
        "yeni = list(enumerate(günler, 1))  ## ketum function dir\n",
        "\n",
        "# yeni.reverse()      #  reverse kullanirsak output ne olur?\n",
        "\n",
        "print(yeni)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nVZHA1TmzdSm"
      },
      "source": [
        "## enumerate ve for ile terse cevirme:\n",
        "\n",
        "günler = (\"monday\", \"tuesday\", \"wednesday\", \"thursday\", \"friday\", \"saturday\", \"sunday\")\n",
        "\n",
        "yeni = list(enumerate(günler, 1))  \n",
        "\n",
        "listyeni = []\n",
        "\n",
        "for i in yeni:    ## enumerate verileri tuple'a dönüstürdügü icin önce liste yapiyoruz\n",
        "  i = list(i)\n",
        "  listyeni.append(i)\n",
        "  i = i.reverse()\n",
        "  \n",
        "print(listyeni)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ozo1kuQ7zdUa"
      },
      "source": [
        "###  append() methodu ile bir seferde en fazla tek eleman eklenebilir\n",
        "\n",
        "# ve append() ile bir listeye baska birden cok elemani liste olarak eklemek istersek\n",
        "# bu listenin elemanlarini tek tek degil, asagida oldugu gibi\n",
        "# listeyi komple append() eder.\n",
        "\n",
        "a = [1, 2 ,3]\n",
        "b= [4, 5, 6]\n",
        "\n",
        "a.append(b)\n",
        "\n",
        "print(a)             \n",
        "\n",
        "# bu nedenle birden cok elemani bir seferde eklemek istersek\n",
        "#asagidaki methodu kullanabiliriz"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pv_yGz8OzdWZ"
      },
      "source": [
        "a = [1, 2 ,3]\n",
        "b= [4, 5, 6]\n",
        "\n",
        "c = a + b\n",
        "\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TCx3o488zdYQ"
      },
      "source": [
        "# Hatirlatma:\n",
        "\n",
        "x, y,*z = (11, 22, 33, 44, 55)\n",
        "\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)  ###   dikkat * kullaninca output umuz liste olur"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JP1pFfqvzdaF"
      },
      "source": [
        "### placeholder\n",
        "\n",
        "## binlerce elemandan olusan bir tuple var\n",
        "# ve biz bunun sadece ilk 2 elemanini simdi atamak istyoruz\n",
        "# digerleri de hafiza da yer kaplamasin istiyoruz\n",
        "\n",
        "\n",
        "x, y, *_ = (10, 20, 30, 40 ,50, 60, 70, 80 ,90)\n",
        "\n",
        "print(x)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VwYCUfkozdcJ"
      },
      "source": [
        "# asteriks herhangi bir yerde kullanilabilir\n",
        "\n",
        "x, y, *z, t= (10, 20, 30, 40 ,50, 60, 70, 80 ,90)\n",
        "\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)\n",
        "print(t)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wORoastdzdeN"
      },
      "source": [
        "## iki yildiz kullaninca hata aliriz\n",
        "\n",
        "x, *y, *z, t= (10, 20, 30, 40 ,50, 60, 70, 80 ,90)\n",
        "\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)\n",
        "print(t)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hFxqJF6azdf7"
      },
      "source": [
        "### derste cözdügümüz örnek\n",
        "\n",
        "names = [\"susan\", \"tom\", \"edward\"]\n",
        "\n",
        "mood = [\"happy\", \"sad\"]\n",
        "\n",
        "a = [i + \" is \" + j for i in names for j in mood]\n",
        "\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Bu-CLYczdhp"
      },
      "source": [
        "## derstek örnek:\n",
        "\n",
        "count = 0\n",
        "\n",
        "while count >= 0:\n",
        "  print(count)\n",
        "  count += 1\n",
        "  if count == 10:\n",
        "    count = -1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y7uILoEJ4VUA"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V9Bz6mODGIic"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yEE9PtFFb2pb"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tdajW1tEb2rv"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ttY1tXib2tc"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GJMkrLRqb2vc"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1x3QOabKb2xZ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w2JsvEvwGIlN"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wf9qzhJa4SSx"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bhiCcQFW4SVX"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_n8_M1Wk4SXF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qC6mTLJk6ICs"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vJvHVzaw6IFY"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AunV3WEZ6IHw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q8RTo-nK6IJ8"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e-ddtPd14SeZ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F7xrWmBjGInq"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I70_srJcDQXv"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O0i_ZGhCDQZx"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "68Upbk_DDQb9"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ga2AzQFfDQfw"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kqXVDKbwDQhy"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b_pXYB93Gw4Q"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NAi8KhVPGw6X"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3tjQdno_Gw8o"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cNhU4OD3Gw-1"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y-x_S56MGxBz"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qBRI9WLMIsQt"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-0qjzAo-IsTJ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wxyjhrctIsVO"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y8wWWhI8IsbJ"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pChDgcLHmOTF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xmkmL0epmOVC"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s62iiQYAmOW7"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n6-ouE7fnCTc"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cFAACzKMnCVe"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wA6zS5sOnCZO"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EjuolBOXnCbE"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tcJpEuFpnCc_"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "djPZ1O65mOYq"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eF1BII-0fIbF"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o4pWJqwcfIc_"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z3gnsiy0fIep"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4bWyyskZfIgg"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}