Python_v1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_v1.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "hNRIM0tGApaW",
        "MAJ4JjbGDRim",
        "TkTFHDkMLaQ4",
        "KyBCJTvhLnd1",
        "Cq9w-TSmR7OV",
        "nK-7JFhFTTdv",
        "eQjrwUBTTmqr",
        "tfKSaV8yTuTR",
        "5N1GqbZlT8AP",
        "EMlZGMGvUYqy",
        "LESLchtBUpem",
        "_NuAIfx9VDUG",
        "V3nDNxjSfaWp",
        "7d6sdxN7fxEy",
        "uHXgsA21f8-h",
        "e6JgjkJ9gjy8",
        "8gNUdk_9knhu",
        "9yc46aGRknmt",
        "20dkCYyQ0aCe",
        "L4-6RGY700Jh",
        "MKjSytIi04lD",
        "daSnnIwz0_2r",
        "W0q8EQ0Y1Gx8"
      ],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNb7LTyApEhqWG5q9I2LVqH",
      "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/Big-Data-Turkey/Python_egitimi/blob/master/Python_v1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-czQM3KWAW5A"
      },
      "source": [
        "## Programlama Nedir ?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MLOfISMg2cXc"
      },
      "source": [
        "Programlama kısaca, bilgisayara ne yapması gerektiğini söylemektir. Bilgisayar tek başına anlam ifade etmez, ona ne yapması gerektiğini, nasıl davranması gerektiğini siz gösterirsiniz.  Bilgisayar diyince aklınıza sadece Dizüstü Masaüstü bilgisayarlar gelmesin. Hesap Makinesi bile bir bilgisayardır.\n",
        "\n",
        "Programlama yaparken yazdığınız sözcüklerin (kodların) bütününe de yazılım denir. Yazılım kullanıcı ile bilgisayar arasında iletişim kurmayı sağlar.\n",
        " "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yIFMGpmb2gi6"
      },
      "source": [
        "## Programlama Nasıl Yapılır ?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XDSU3-Y52tmD"
      },
      "source": [
        "Programlama geçmişten günümüze sürekli geliştirilerek gelmiştir ve hala da gelişmektedir. Her geçen gün işlerimizi kolaylaştıran diller, kütüphaneler ortaya çıkıyor.  Programlama yapabilmek, program yazabilmek için Bazı programlama dillerine ihtiyaç duyarız.\n",
        "Programlama Dilleri\n",
        "\n",
        "Programlama dilleri, program yazarken kullandığımız söz dizimleridir. Farklı programlama dilleri vardır, geçmişten günümüze sürekli farklı programlama dilleri geliştirilmiştir.\n",
        "Yani programı, herhangi bir programlama diliyle yazabilirsiniz. Mantık olarak hepsi aynıdır, yazımlarında farklılıklar vardır o kadar. Örnek olarak: csharp, visual basic, java, c, c++, python.. programlama dillerinden sadece bazıları.. Daha çok sayıda programlama dili vardır ve hepsi ihtiyaçlara göre farklı alanlarda kullanılır. Örneğin bazıları yazarken kolaylık sağlar bazıları hızda kolaylık sağlar vs.. Tüm hepsini bilmemize gerek yok. Sadece bir tanesini bilseniz yeterli.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VxkmFFL0AlD6"
      },
      "source": [
        "## Python Nedir Neler Yapılabilir avantajları nelerdir?\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zSJKvOfv23yV"
      },
      "source": [
        "Python son zamanların en popüler programlama dillerinden biridir. Python programlama dili makine öğrenimi, sistem otomasyonları, web ve API’lerini geliştirme, bot sistemleri, yapay zeka, veri bilimi ve veri işleme gibi konular için temel yapıdadır.\n",
        "\n",
        "makine öğrenimi veya veri analizi denildiğinde ilk akla gelen programlama dillerinden biri olmayı başarmış ve gün geçtikçe ününü daha da büyütmeye devam etmiştir.\n",
        "\n",
        "\n",
        "Python Programlama Dilinin Kullanımı ve Öğrenimi Çok Basit.\n",
        "\n",
        "Python syntaxı (söz dizimi) hem rahat okunabilir hem de ileriyi hedefleyen bir yapıdadır. Python programlama dilinin öğrenimi, kararlı yapısı sayesinde oldukça basittir.\n",
        "\n",
        "Yazılıma yeni başlayanlara en ideal ve basit dil olarak görüldüğü için Python programlama dili önerilir. Sadede gelecek olursak, Python programlama dili yazılıma yeni başlayan herkes için hızlı ve basit bir şekilde ilerlemeyi sağlar. Diğer programlama dillerine göre söz konusu basitlik olduğunda Python diğer programlama dillerine nazaran iki adım daha öndedir.\n",
        "\n",
        "Python,  yazılımcılar arasında oldukça popüler ve oldukça yaygın bir programlama dilidir. Github projelerinin çoğunda Python yazılım dili kullanılmıştır. Stackoverflow ve Github gibi programcıların genel olarak gezdikleri programlama örnek sıralama sistemlerinde, Python dili en üst sıralarda yer almaktadır.\n",
        "\n",
        "Kullanım alanlarını anlatacak olursak, en küçük işletim sistemlerinden en büyük işletim sistemlerine kadar neredeyse bütün OS tarafından desteklenir. İnternette bulunan birçok kütüphane ve API servislerinin kesinlikle Python tabanlı bindings veya wrappers’ları bulunmaktadır. Bunun sayesinde Python, servislerle serbest bir şekilde arayüz oluşturur veya kütüphaneler doğrudan kullanılır.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fCFIsCid29Fo"
      },
      "source": [
        "## Makine Öğreniminde Python’un Yeri ve Veri Bilimi\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CId2pbI-2-qb"
      },
      "source": [
        "\n",
        "Karmaşık veri analizleri günümüz IT için önemli bir konu haline gelmiştir. Python bu durumlarda en kullanışlı programlama dilidir. Python kütüphanelerinin çoğu veri bilimi ve makine öğrenimi konularında gayet kullanışlıdır. Bu alandaki kütüphanelerde bulunan yüksek kaliteli komutlar, makine öğrenimi kütüphanelerinin ve diğer algoritma kütüphanelerinin sürekli gelişmesinde büyük katkı sağlamıştır."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hNRIM0tGApaW"
      },
      "source": [
        "## Çalışma Ortamları\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5_AbpeybMqxZ"
      },
      "source": [
        "- python(resmi python ortamı)\n",
        "- conda\n",
        "- google colab"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MAJ4JjbGDRim"
      },
      "source": [
        "## Print fonksiyonu"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-2FUOttSMk3L"
      },
      "source": [
        "\n",
        "print python öğrenirken en çok kullanıcağımız fonksiyondur. İçine girilen değeri yazdırır"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "896Bj41qKu9j"
      },
      "source": [
        "print(\"merhaba\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t1zQzkeNKz2S"
      },
      "source": [
        "\"merhaba\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CZiwE8fdLI_B"
      },
      "source": [
        "5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYqSI-GWLKBQ"
      },
      "source": [
        "3+5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t6GB6pZlLMao"
      },
      "source": [
        "9/5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zN26vgYHLN01"
      },
      "source": [
        "11//3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FnJcvHvDLO1x"
      },
      "source": [
        "11%3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jLfRibTxLRqG"
      },
      "source": [
        "2*5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WUQZQcNfLTFV"
      },
      "source": [
        "2**5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QlyzouFzLUrz"
      },
      "source": [
        "a=5\n",
        "b=2\n",
        "a+b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TkTFHDkMLaQ4"
      },
      "source": [
        "## Değişkenler"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oOKzmFpOLcHi"
      },
      "source": [
        "tamSayi = 5\n",
        "ondalikli_sayi = 3.2\n",
        "metin = \"merhaba\"\n",
        "liste = [1,1,3.2,\"elma\",\"armut\"]\n",
        "dogru_yanlis = True\n",
        "sozluk = {\"elma\":\"apple\",\"muz\":\"banana\"}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nrlyP8W5LeMP"
      },
      "source": [
        "type(tamSayi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KyBCJTvhLnd1"
      },
      "source": [
        "### Standart Veri Tipleri\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fEdayHLxMgbg"
      },
      "source": [
        "Programların çalışmasında farklı amaçlar için farklı türlerde verilere ihtiyaç duyarız. Örneğin cinsiyet durumu için true/false, isim için string yada yaş bilgisi için int türünde verir.\n",
        "\n",
        "Python birçok veri tipi içermektedir. Bunlardan bazıları:\n",
        "\n",
        "\tİnt\n",
        "    Float\n",
        "\tString\n",
        "\tList\n",
        "\tTupple\n",
        "    Dictionary\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xhlHVam1Luoy"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cq9w-TSmR7OV"
      },
      "source": [
        "### Değişken isimlendirme kuralları\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TYSipbWvSgvv"
      },
      "source": [
        "Değişken isimlerini açık ve anlaşılır yazmak işinize gelir.büyük bir kod yazarken “a” değişkeni yerine “sayi” adlı değişken daha açıklayıcı ve sade olur.\n",
        "\n",
        "Değişken isimleri hem harf hem sayı içerebilir. Fakat mutlaka harfle başlamalıdır"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YH91ENUFR-Ir"
      },
      "source": [
        "34python = \"algoritma\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1EBZOqIWSnz6"
      },
      "source": [
        "python34 = \"algoritma\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N5-YXa16Sybr"
      },
      "source": [
        "Değişkenlerin içinde alt çizgi karakteri (“_”) \n",
        "\n",
        "*   Liste öğesi\n",
        "*   Liste öğesi\n",
        "\n",
        "kullanabilirsiniz."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4VGCRrvTSyy5"
      },
      "source": [
        "demet = 0,3256,1,2\n",
        "demet"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Lrb5QJFS087"
      },
      "source": [
        "virgullu_sayi = 0.3256\n",
        "virgullu_sayi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dCusuUeKS2o0"
      },
      "source": [
        "Değişken isimleri büyük-küçük harf duyarlıdır.\n",
        "\"Sayi\" degişkeni ile \"sayi\" degişkeni aynı değildir"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AMsUws02S4iB"
      },
      "source": [
        "a=5\n",
        "A=4\n",
        "a,A"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKgtbh12S7qH"
      },
      "source": [
        "'”`;,<>/?|\\/()!@#$%^&*~-+  gibi karakterler değişken isimlerinde bulunamazlar"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t3XG74GnS8DI"
      },
      "source": [
        "s@yı = 5"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f-wU3xLqS9f8"
      },
      "source": [
        "kişi.com = \"ahmet\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O_XP1qLRS_bb"
      },
      "source": [
        "Değişkenlere isim verirken anahtar kelimeler kullanamazsınız"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8hsdLCy8TB6J"
      },
      "source": [
        "and = \"and adında degişken\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnpqFg7UTEx7"
      },
      "source": [
        "Python'da kullanılan tüm anahtar kelimeler:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ju0v90OATKBB"
      },
      "source": [
        "import keyword\n",
        "keyword.kwlist"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ydlVqHX4TP3d"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nK-7JFhFTTdv"
      },
      "source": [
        "## Operatörler"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eQjrwUBTTmqr"
      },
      "source": [
        "### Matematik Operatörleri"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZkyVGvd1TcVB"
      },
      "source": [
        "# Atama / işlemli atam operatoru (=)\n",
        "sayi=5\n",
        "sayi=7\n",
        "sayi = sayi+2\n",
        "sayi"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rn5JT4M4Tj_3"
      },
      "source": [
        "sayi+=2 # sayi = sayi+2\n",
        "sayi-=2 # sayi = sayi-2\n",
        "sayi*=2 # sayi = sayi*2\n",
        "print(sayi) # 18\n",
        "\n",
        "sayi/=2 # sayi = sayi/2\n",
        "print(sayi) # 9.0\n",
        "\n",
        "sayi=10\n",
        "sayi/=3\n",
        "print(sayi)\n",
        "\n",
        "# bölme işleminde ondalık kısmı yok edip sadece tam sayıyı alma\n",
        "sayi=10\n",
        "sayi//=3\n",
        "print(sayi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tfKSaV8yTuTR"
      },
      "source": [
        "### Karşılaştırma Operatörleri"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iQIbAoKdT2h0"
      },
      "source": [
        "== ,> ,<= karşılaştırma operatörlerinden bazılarıdır"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uGYomziSTy5Z"
      },
      "source": [
        "sayi1=8\n",
        "sayi2=4\n",
        "\n",
        "bool1 = sayi1==sayi2 # eşitse True değilse False\n",
        "bool2 = sayi1!=sayi2 # eşitse False değilse True\n",
        "bool3 = sayi1>=sayi2 # sayi1 sayi2 den büyük veya eşitse True\n",
        "bool4 = sayi1<=sayi2 # sayi1 sayi2 den küçük veya eşitse True\n",
        "print(bool1,bool2,bool3,bool4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I2-JurqQT5aB"
      },
      "source": [
        "isim0=\"Ali\"\n",
        "isim1=\"Veli\"\n",
        "isim2=\"ali\"\n",
        "\n",
        "bool5= isim0==isim1\n",
        "bool6= isim0==isim2\n",
        "bool5,bool6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6vsSsJlYT6gP"
      },
      "source": [
        "sayi3=\"5\"\n",
        "sayi4=5\n",
        "bool7= sayi3==sayi4\n",
        "bool7"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5N1GqbZlT8AP"
      },
      "source": [
        "### Mantıksal Operatörler"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1rL5htDWUBYx"
      },
      "source": [
        "\n",
        "#### AND\n",
        "\n",
        "00=0\n",
        "\n",
        "01=0\n",
        "\n",
        "10=0\n",
        "\n",
        "11=1\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T-hyemMWULIC"
      },
      "source": [
        "#### OR\n",
        "\n",
        "00=0\n",
        "\n",
        "01=1\n",
        "\n",
        "10=1\n",
        "\n",
        "11=1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PTlypw6wT-xA"
      },
      "source": [
        "1 and 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0BiUSxROUQr9"
      },
      "source": [
        "1 and 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gJTLHfakUR-J"
      },
      "source": [
        "1 or 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dwaLrTGIUSml"
      },
      "source": [
        "a=5\n",
        "a>0 and a<10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AQHLtuvKUUBx"
      },
      "source": [
        "a=5\n",
        "a>0 and a%2==0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GpVBREtoUUFc"
      },
      "source": [
        "a=5\n",
        "a>0 or a%2==0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EMlZGMGvUYqy"
      },
      "source": [
        "## Veri Girişi (input)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ab-p9kKMUjN9"
      },
      "source": [
        "Pythonda veri girişi için birçok yöntem vardır. Bunlar ses kamera verisi olacağı gibi terminale yazacağımız bir yazı da olabilir. Terminalde veri almak için de input fonksiyonunu kullanırız"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GPXVaBmEUUJh"
      },
      "source": [
        "isim = input(\"İsminiz nedir? \")\n",
        "print(\"merhaba\", isim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IB6NcXhrUlb5"
      },
      "source": [
        "sayi = input(\"sayı giriniz? \")\n",
        "type(sayi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kxr_N_jSUmxP"
      },
      "source": [
        "sayi = input(\"sayı giriniz? \")\n",
        "sayi2 = input(\"2. sayıyı giriniz? \")\n",
        "sayi + sayi2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LESLchtBUpem"
      },
      "source": [
        "## Tip Dönüşümleri"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7D10p1LtU6__"
      },
      "source": [
        "Bazen veri tiplerini birbirlerine çevirmemiz gerekir. En basit örneğiyle input ile aldığımız veri string tipindedir onu tamsayı olarak toplama çıkarma gibi işlemlere tabi tutabilmek için int tipine çevirmemiz gerekir"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p8gYHK2MUqdx"
      },
      "source": [
        "sayi = \"5\"\n",
        "print(type(sayi))\n",
        "print(type( int(sayi) ))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dNaV3a7yU9-P"
      },
      "source": [
        "str(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_j0SkLAmU-CC"
      },
      "source": [
        "int(\"5\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gJKSmy39U-Fu"
      },
      "source": [
        "sayi1 = input(\"1. sayıyı giriniz? \")\n",
        "sayi2 = input(\"2. sayıyı giriniz? \")\n",
        "sayi1 + sayi2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3_IjtVLGVBBK"
      },
      "source": [
        "sayi1 = int(input(\"1. sayıyı giriniz? \"))\n",
        "sayi2 = input(\"2. sayıyı giriniz? \")\n",
        "sayi1 + int(sayi2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_NuAIfx9VDUG"
      },
      "source": [
        "## Diziler"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZIg9dADoe3LP"
      },
      "source": [
        "Python array değişken türünün en önemli özelliklerinden birisi dizi içinde farklı değişken türlerini bir arada tutabilmenizdir. Böylece oldukça kolay bir şekilde farklı türleri aynı dizide depolayabilirsiniz. Öyleyse birçok farklı yöntemle liste/dizi nasıl oluşturulur hemen onu görelim."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oLdo2dFkVGKv"
      },
      "source": [
        "# boş liste değişkeni \n",
        "liste =  []\n",
        "print(liste)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3qlVoil1e5Qm"
      },
      "source": [
        "# dizi/liste(array) oluşturmanın farklı bir tarzı\n",
        "liste =  list()\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xf7ekgW5e5TO"
      },
      "source": [
        "# sadece int değerler tutan dizi/liste\n",
        "liste =  [1,2,3,4,5,6,7]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qMsfBeure5Wc"
      },
      "source": [
        "# string tutan array\n",
        "liste =  list([\"İstanbul\",\"Ankara\",\"İzmir\"])\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gMtvW67Ce5YY"
      },
      "source": [
        "# farklı değişken türleri tutan liste isimli array değişkeni\n",
        "liste =  [10,11,12,\"Python\",3.14,51.035]\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "olLR7DHxe5c8"
      },
      "source": [
        "# string parçalayarak dizi/liste oluşturma\n",
        "isim = \"İstanbul\"\n",
        "liste =  list(isim)\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dA2yRMhYe5fI"
      },
      "source": [
        "# array indexleme /basit dizi\n",
        "liste = [\"Elma\",\"Armut\",\"Kivi\",\"Muz\",[\"armut\",2]]\n",
        "liste[2],liste[4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T0hgAmqQe5hj"
      },
      "source": [
        "# array indexleme /iç içe dizi\n",
        "liste1 = [1,2,3]\n",
        "liste2 = [4,5,6]\n",
        "liste3 = [7,8,9]\n",
        "yeniliste = [liste1,liste2,liste3]\n",
        "yeniliste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LOlHW9rHe5kc"
      },
      "source": [
        "# liste2[2] = yeniliste[1][2]\n",
        "yeniliste[1][2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j26THu42fALp"
      },
      "source": [
        "# Listenin sonuncu elemanını gösterme\n",
        "liste = [3,4,5,6,7,8,9]\n",
        "len(liste)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dwHlig9JfAOS"
      },
      "source": [
        "uzunluk = len(liste)\n",
        "liste[-uzunluk+1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_MhRpB6MfAQ8"
      },
      "source": [
        "liste[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jFmfP3eifAUN"
      },
      "source": [
        "# Baştan 4. indekse kadar (dahil değil)\n",
        "liste = [3,4,5,6,7,8,9]\n",
        "liste[:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jr9-I1jtfAWQ"
      },
      "source": [
        "# 2. ve 4. arasını alma\n",
        "liste = [3,4,5,6,7,8,9]\n",
        "liste[2:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WZaWJu5CfAYV"
      },
      "source": [
        "# 3. indexten sonuna kadar alma\n",
        "liste = [3,4,5,6,7,8,9]\n",
        "liste[3:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8aInnmxxfFee"
      },
      "source": [
        "# Listeleri birleştirme\n",
        "liste1 =  [1,2,3,4,5]\n",
        "liste2 =  [6,7,8,9,10]\n",
        "liste3 = liste1 + liste2\n",
        "liste3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q4-sXTFpfFhU"
      },
      "source": [
        "# Diziye eleman dahil etme\n",
        "liste =  [\"Manisa\",\"Düzce\",\"Bolu\"]\n",
        "liste += [\"Çankırı\"]\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-YdkmYu-fFkr"
      },
      "source": [
        "# Listedeki elemanı değiştirme /Yöntem1\n",
        "liste =  [1,2,3,4,5]\n",
        "liste[2]=\"Merhaba\"\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cWehIQWVfFnN"
      },
      "source": [
        "liste =  [1,2,3,4,5]\n",
        "liste[:3]=[10,20]\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jmoN8ESxfJct"
      },
      "source": [
        "# Dizi çarpma işlemi ile tekrarlama\n",
        "liste =  [1,2,3,4,5]\n",
        "liste *= 2\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kFqYTQrtfJfV"
      },
      "source": [
        "# Liste eleman sayısı\n",
        "liste = [3,4,5,6,6,7,8,9,0,0,0]\n",
        "len(liste)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j5EZ_V9-fJip"
      },
      "source": [
        "liste =  [1,2,3,4,5]\n",
        "liste.append([1,2])\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qpM3yZX5fJlf"
      },
      "source": [
        "# Dizi sonundaki elemanı çıkarma\n",
        "liste =  [1,2,3,4,5]\n",
        "çıkarılan_değer = liste.pop()\n",
        "liste, çıkarılan_değer"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S0MNFGswfJnt"
      },
      "source": [
        "# Dizide istediğim indexteki elemanı çıkarma /çıkan elemanı ekrana basar\n",
        "liste =  [\"Ali\",\"Yunus\",\"Deniz\",\"Asım\"]\n",
        "print(liste.pop(2))\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nqxqEzVXfJqN"
      },
      "source": [
        "# Dizi elemanlarını küçükten büyüğe doğru sıralar\n",
        "liste =  [43,35,78,13,5,86,90,1000]\n",
        "liste.sort()\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X40c4GEifOuK"
      },
      "source": [
        "# Dizi elemanlarını küçükten büyüğe doğru sıralar\n",
        "liste =  [\"43\",\"35\",\"78\",\"13\",\"5\",\"86\",\"90\",\"1000\"]\n",
        "liste.sort()\n",
        "liste"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cUqgkYEYfOxM"
      },
      "source": [
        "# Dizi elemanlarını büyüktenten küçüğe doğru sıralar\n",
        "sayılar =  [43,35,78,13,5,86,90]\n",
        "sayılar.sort(reverse=True)\n",
        "sayılar"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PNwB8ixAfSKl"
      },
      "source": [
        "## Koşullu İfadeler"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UgYxXwIUfYZv"
      },
      "source": [
        "Pythonda koşullu durumlar ile bir koşuldan elde ettiğimiz True ya da False değere göre programın farklı yönlerden ilerlemesini sağlayabiliriz.\n",
        "\n",
        "Aşağıda bazı koşul ifadeleri verilmiştir. Bu koşullar bize True ya da False değer üretirler.\n",
        "\n",
        "Eşit mi : a == b,\n",
        "\n",
        "Eşit değil mi: a != b\n",
        "\n",
        "Küçük mü : a < b\n",
        "\n",
        "Küçük ya da eşit mi: a <= b\n",
        "\n",
        "Büyük mü: a > b\n",
        "\n",
        "Büyük ya da eşit mi: a >= b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V3nDNxjSfaWp"
      },
      "source": [
        "### İf"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "51a_omPwfVFH"
      },
      "source": [
        "a = 30\n",
        "b = 20\n",
        "if b > a:\n",
        "    print(\"b, a'dan büyüktür\")\n",
        "    print(\"ok\")\n",
        "\"bu kısım her zaman çalışır\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-LXsZlimftuH"
      },
      "source": [
        "a = 20\n",
        "b = 20\n",
        "if b > a:\n",
        "    print(\"b, a'dan büyüktür\")\n",
        "if b <= a:\n",
        "    print(\"a, b'den büyük yada eşittir\")\n",
        "if b==a:\n",
        "    print(\"a b eşittir\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7d6sdxN7fxEy"
      },
      "source": [
        "### Elif"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PEmjYEdCftxS"
      },
      "source": [
        "a = 10\n",
        "b = 10\n",
        "if b >= a:\n",
        "  print(\"b, a'dan büyüktür\")\n",
        "elif a == b:\n",
        "  print(\"a ile b eşittir\")\n",
        "\"bitiş\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EGE28cKigAM6"
      },
      "source": [
        "a = 15\n",
        "b = 15\n",
        "if b > a:\n",
        "  print(\"b, a'dan büyüktür\")\n",
        "elif a == b:\n",
        "  print(\"a ile b eşittir\")\n",
        "elif a >= b:\n",
        "  print(\"a, b'den büyüktür\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uHXgsA21f8-h"
      },
      "source": [
        "### Else"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "docihN_-f785"
      },
      "source": [
        "a = 15\n",
        "b = 10\n",
        "if b > a:\n",
        "  print(\"b, a'dan büyüktür\")\n",
        "elif a == b:\n",
        "  print(\"a ile b eşittir\")\n",
        "else:\n",
        "  print(\"a, b'den büyüktür\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9lHXBCdKgES0"
      },
      "source": [
        "num = int(  input('sayı: ')  )\n",
        "\n",
        "if num > 0:\n",
        "    print('sayı pozitif')\n",
        "elif num < 0:\n",
        "    print('sayı negatif')\n",
        "else:\n",
        "    print('sayı sıfır')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZXOHwMcCgMnc"
      },
      "source": [
        "### İç içe koşul kullanımı   "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mdp20K_ugNZ_"
      },
      "source": [
        "# iç içe if blokları\n",
        "username = 'bilal'\n",
        "password = '1234'\n",
        "\n",
        "if (username == 'bilal'):\n",
        "    if (password == '12345'):\n",
        "        print('Hoş geldiniz')\n",
        "    else:\n",
        "        print('parola yanlış')        \n",
        "else:\n",
        "    print('username yanlış')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lKNd9H5pgUgY"
      },
      "source": [
        "if (username == 'bilal') and (password == '1234'):\n",
        "        print('Hoş geldiniz')      \n",
        "else:\n",
        "    print('username ya da parola yanlış')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E_XY_Szggcjh"
      },
      "source": [
        "Farklı bir koşul kullanımı"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1hIV2UXkgdnN"
      },
      "source": [
        "[\"a\",\"b\"][5==4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ik8dQB0Mgvxq"
      },
      "source": [
        "⭕ girilen harf notuna göre geçip geçmediğini söyleyen programı yazınız"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zp1Ak8Q1hHjR"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e6JgjkJ9gjy8"
      },
      "source": [
        "## Döngüler"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8gNUdk_9knhu"
      },
      "source": [
        "### While"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b7vq3pD-z-NK"
      },
      "source": [
        "sayi=90\n",
        "while(sayi<101):\n",
        "    print(sayi)\n",
        "    sayi+=1 # sayi = sayi +1\n",
        "\"bitti\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Kpo9Dogz_BU"
      },
      "source": [
        "while 1:\n",
        "    print(\"merhaba\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "54mqRbvU0Iha"
      },
      "source": [
        "i=0\n",
        "while i<100:\n",
        "  print(i)\n",
        "  if i==10:\n",
        "    break\n",
        "  i+=1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9yc46aGRknmt"
      },
      "source": [
        "### For"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QpqIWmzjgn6n"
      },
      "source": [
        "meyveler = [\"apple\", \"banana\", \"cherry\"]\n",
        "for meyve in meyveler:\n",
        "    print(meyve)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vKevy9F-kjxn"
      },
      "source": [
        "meyveler = [\"apple\", \"banana\", \"cherry\"]\n",
        "for meyve in meyveler:\n",
        "    print(meyve)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ds8Ebn900Rm5"
      },
      "source": [
        "#  break\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "    print(x)\n",
        "    if x == \"banana\":\n",
        "        break\n",
        "\"burası çalışacak\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TXXGPOHA0AGD"
      },
      "source": [
        "# continue\n",
        "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
        "for x in fruits:\n",
        "    if x == \"banana\":\n",
        "        continue\n",
        "    print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "20dkCYyQ0aCe"
      },
      "source": [
        "## Örnek Problem "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNkGQlEu0lHL"
      },
      "source": [
        "SORU : 1-100 arasındaki sayıları toplayan program. Aşağıdaki durumlarda sayıyı toplama eklemeyecek\n",
        "\n",
        "Sayı 7'nin katı ise toplama eklenmesin\n",
        "\n",
        "Sayı 11'in katı ise iki defa eklesin\n",
        "\n",
        "eğer her iki koşuluda karşılıyorsa döngü bitsin\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JJaKvEo00iRU"
      },
      "source": [
        "toplam = 0\n",
        "for i in range(1,100):\n",
        "    if i%7==0 and i%11==0:\n",
        "        break\n",
        "    elif i%7==0:\n",
        "        continue\n",
        "    elif i%11==0:\n",
        "        toplam+= i*2\n",
        "    else:\n",
        "        toplam+= i\n",
        "\n",
        "print(toplam)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9j9RtLWH0xYH"
      },
      "source": [
        "sayi = 1\n",
        "toplam = 0\n",
        "while sayi<=100:\n",
        "    if sayi%7==0 and sayi%11==0:\n",
        "        break\n",
        "    elif sayi%7==0:\n",
        "        ...\n",
        "    elif sayi%11==0:\n",
        "        toplam+=sayi*2\n",
        "    else:\n",
        "        toplam+=sayi\n",
        "    sayi+=1\n",
        "print(toplam)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L4-6RGY700Jh"
      },
      "source": [
        "## Fonksiyonlar"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Yazdığımız bir python uygulamasındaki belli bir kod parçasını bir kaç yerde kullanma ihtiyacı duyduğumuzda fonksiyon oluşturmak işlerimizi kolaylaştırır. Böyle durumlarda sürekli kullanacak olduğumuz kod satırlarını fonksiyonlar içine alıp istediğimiz zaman çağırıp çalıştırabiliriz.\n",
        "\n",
        "Örneğin basit bir matematiksel işlem yapacağız ve bir çok yerde bu matematiksel işlemi tekrarlayacağız bu durumda bir fonksiyon oluşturup defalarca kullanabiliriz.\n",
        "\n",
        "Ayrıca işin daha güzel yani Python da hazır bir çok kütüphane var ve bu kütüphaneler içinde önceden oluşturulmuş bir sürü fonksiyon mevcut. Çoğu zaman fonksiyonun içeriğini yazmak yerine hazır olanını kullanabileceğiz. Örneğin gönderdiğimiz bir sayının karakökünü alan sqrt() fonksiyonu."
      ],
      "metadata": {
        "id": "VNevADEckAm1"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-RTieeSj02pP"
      },
      "source": [
        "def hello():\n",
        "    print(\"Merhaba\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "hello()\n",
        "hello()\n",
        "hello()\n",
        "hello()"
      ],
      "metadata": {
        "id": "MNP5ytvmkGCw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def hello(name):\n",
        "    print(\"Hello \"+ name)\n",
        "\n",
        "hello(\"Bilal\")\n",
        "hello(\"Yusuf\")\n",
        "hello(\"Ali\")"
      ],
      "metadata": {
        "id": "wuecF357kHPs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = input(\"sayı: \")"
      ],
      "metadata": {
        "id": "g4WKfqLPkLi0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def hello(name):\n",
        "    return \"Merhaba \"+ name\n",
        "    print(\"çalışmaz\")\n",
        "\n",
        "isim = hello(\"Bilal\")\n",
        "print(isim)"
      ],
      "metadata": {
        "id": "nwoZrNiykO1j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def toplama(a,b):\n",
        "    return a+b\n",
        "\n",
        "sonuc = toplama(10,20)\n",
        "sonuc # 30"
      ],
      "metadata": {
        "id": "w3ieN0KFkQ5e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def yazdir(kelime, adet):\n",
        "    print(kelime * adet)\n",
        "\n",
        "yazdir('Merhaba\\n', 10)"
      ],
      "metadata": {
        "id": "o4nnsFq9kTlG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"a\",\"b\",\"c\",sep=\"-\",end=\"'satır sonu'\")\n",
        "print(\"b\")"
      ],
      "metadata": {
        "id": "fwPT9bY3kWNN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Soru: Gönderilen 2 sayı arasındaki tüm asal sayıları bulan python fonksiyon uygulamasını yapınız."
      ],
      "metadata": {
        "id": "CMKaqNw4kZBD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def asal_mı(sayı):\n",
        "    for i in range(2,sayı):\n",
        "        if sayı%i==0:\n",
        "            return False\n",
        "    return True\n",
        "\n",
        "def asalları_bul(max=100,min = 2):\n",
        "    asallar=[]\n",
        "    for i in range(min,max):\n",
        "        if asal_mı(i):\n",
        "            asallar.append(i)\n",
        "    return asallar\n",
        " "
      ],
      "metadata": {
        "id": "DrDgZ9vHkXlj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(input(\"min: \"))\n",
        "b = int(input(\"max: \"))\n",
        "asallar_listesi = asalları_bul(min=a,max=b)\n",
        "asallar_listesi"
      ],
      "metadata": {
        "id": "9zpRzKAfkiA6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def asal_kontol(a):\n",
        "    for i in range(2,a):\n",
        "        if a%i==0:return False\n",
        "    return True\n",
        "\n",
        "\n",
        "def asal(max,min = 3):\n",
        "    asallar =[]\n",
        "    for i in range(min,max):\n",
        "        if asal_kontol(i):asallar.append(i)\n",
        "    return asallar"
      ],
      "metadata": {
        "id": "RbnjPW89mbPQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(asal(19,min=5))"
      ],
      "metadata": {
        "id": "gAXs9pf-ktAY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "sum([i**2 for i in range(0,47)])"
      ],
      "metadata": {
        "id": "cMlyot7gkvtt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bazen fonksiyonlara gönderdiğimiz parametreler yerine varsayılan değerleri kullanmak isteyebiliriz."
      ],
      "metadata": {
        "id": "uO24-CuDkylQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# varsayılan/default değer atama\n",
        "def my_function(country = \"Turkey\"):\n",
        "  print(\"I am from \" + country)\n",
        "\n",
        "my_function(\"Sweden\")\n",
        "my_function(\"India\")\n",
        "my_function()\n",
        "my_function(\"Brazil\")"
      ],
      "metadata": {
        "id": "SSKLzw2mk6lA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Kendisine gönderilen değişken sayıdaki sayıları toplayan bir fonksiyon yazmak istediğimizde *params anahtar kelimesini kullanabiliriz. *params anahtar kelimesi birden fazla parametrenin yerini tutar."
      ],
      "metadata": {
        "id": "AtsEC84WlA16"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def toplama(a,b):\n",
        "    return a+b\n",
        "\n",
        "def toplama(a,b,c):\n",
        "    return a+b+c\n",
        "..."
      ],
      "metadata": {
        "id": "been3EpJlBay"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def toplama(a,*params): \n",
        "    print(a)\n",
        "    print(type(params))  # <class 'tuple'>\n",
        "    toplam = 0\n",
        "    for n in params:\n",
        "        toplam += n\n",
        "    return toplam\n"
      ],
      "metadata": {
        "id": "pfu4PwQOlFTX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = toplama(10, 20, 50, 2 ,-10)\n",
        "print(f\"a değerimiz {a}\")\n",
        "\n",
        "# print(toplama(10, 20, 30))\n",
        "# print(toplama(10, 20, 30, 50, 60, 10, 20))"
      ],
      "metadata": {
        "id": "oLBQYN9dlIRI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Eğer ki **args şeklinde parametre belirtirsek bu durumda key-value şeklinde istediğimiz sayıda bilgiyi fonksiyona gönderebiliriz."
      ],
      "metadata": {
        "id": "fuczww9plMf7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def displayUser(**args):\n",
        "    for key, value in args.items():\n",
        "        print(f\"key: {key} value: {value}\")"
      ],
      "metadata": {
        "id": "URwthgzOlM8f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "displayUser(name= 'Çınar', age = 2, city = 'istanbul')\n",
        "displayUser(name= 'Ada', age = 12, city = 'kocaeli', phone = '123132')\n",
        "displayUser(name= 'Yiğit', age = 14, city = 'ankara', phone = '123132', email= 'yigit@gmail.com')"
      ],
      "metadata": {
        "id": "1BcYony8lOYs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def myFunc(a, b, c, *args, **kwargs):\n",
        "    print(a)\n",
        "    print(b)\n",
        "    print(c)\n",
        "    print(args)\n",
        "    print(kwargs)\n",
        "\n",
        "myFunc(10, 20, 30, 40, 50, 60, 70, key1 = 'value 1', key2 = 'value 2')"
      ],
      "metadata": {
        "id": "9oXtWbovlPve"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Kapsam"
      ],
      "metadata": {
        "id": "PcqkuinxlSKa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Kapsam(scope) içerde oluşturulan veya değiştirilen değerin dışarı yansımaması durumudur"
      ],
      "metadata": {
        "id": "ifhx4E4RlXVT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# scope\n",
        "a=4\n",
        "\n",
        "def func():\n",
        "    a=7\n",
        "    print(a)\n",
        "    \n",
        "    \n",
        "print(a)\n",
        "func()\n",
        "print(a)\n"
      ],
      "metadata": {
        "id": "Z1RN2v2hlttu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# scope\n",
        "a=4\n",
        "\n",
        "def func():\n",
        "    global a\n",
        "    a=7\n",
        "    print(a)\n",
        "    \n",
        "    \n",
        "print(a)\n",
        "func()\n",
        "print(a)"
      ],
      "metadata": {
        "id": "6g57EWH7lvLC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dizi = [1,2,3,4]\n",
        "def func():\n",
        "    global dizi\n",
        "    dizi[1]=10\n",
        "    \n",
        "dizi"
      ],
      "metadata": {
        "id": "uDd1gzb-lwbG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Fonksiyonun okunabilirliğini arttırmak ve alınacak bazı hatalardan kaçınmak adına fonksiyonun alacağı ve döneceği veri tipini belirmek önemlidir. Veri tipini parametreden hemen sonra “:” koyup tipini yazarak belirtiriz. "
      ],
      "metadata": {
        "id": "mAlf97Wvl2Si"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def topla(a:int,b:int) -> int:\n",
        "    \"\"\"bu fonksiyon iki tane sayı alır\"\"\"\n",
        "    return a+b\n",
        "topla(1,2)"
      ],
      "metadata": {
        "id": "ulYs1sutl1oc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def dizi_topla(a:list,b:list) -> list:\n",
        "    return a + b\n",
        "\n",
        "dizi_topla([1,2,3],[4,5,6])"
      ],
      "metadata": {
        "id": "uwXsrsGcl7nQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def topla(a:int,b:int = 5) -> int:\n",
        "    return a+b"
      ],
      "metadata": {
        "id": "We_Yplsdl9AX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bu örnekte de gördüğümüz gibi dışardan gelen parametrenin int veri tipinde olacağını ve fonksiyonun int veri tipinde bir değer döneceğini belirttik. Bu sayede yanlışlıkla yanlış bir veri tipi göndererek çalışma anında alınan hataların önüne geçmiş olduk. Aynı zamanda büyük bir projede kullanılan fonksiyonların hangi değerde veri alacağını yada döneceğini görmek için bulunduğu sayfaya gitme ihtiyacımız da kalmadı"
      ],
      "metadata": {
        "id": "-qfkYJoYl9Xo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Hatalar"
      ],
      "metadata": {
        "id": "OemCHfKvWejc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Syntax error(sözyazımı hatası)"
      ],
      "metadata": {
        "id": "bxnkmZ1uWtLR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "if 1==1\n",
        "  print(\"eşit\")"
      ],
      "metadata": {
        "id": "I-pksWkQWnXy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. logical error(mantık hatası)"
      ],
      "metadata": {
        "id": "XOfIo2fhW31G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import olmayan_bir_modül"
      ],
      "metadata": {
        "id": "ZqiEWtkEWsNM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exception Handling"
      ],
      "metadata": {
        "id": "fzUPaMbiNgr1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bazı sıradışı durumlarda aldığımız hataları göz ardı etmek yada daha farklı işlemler yapmak isteyebiliriz. İşte Exception Handling bunun için var"
      ],
      "metadata": {
        "id": "yJbHx_zXPbz-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a=int(input())\n",
        "b=int(input())\n",
        "print(a/b)"
      ],
      "metadata": {
        "id": "t-vnyMdiOflj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=int(input())\n",
        "b=int(input())\n",
        "try:\n",
        "  print(a/b)\n",
        "except Exception as e:\n",
        "  print(\"hata:\", e)"
      ],
      "metadata": {
        "id": "Tc3L2kq1Pyu8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=int(input())\n",
        "b=int(input())\n",
        "try:\n",
        "  print(a/b)\n",
        "except ZeroDivisionError:\n",
        "  print(\"0 ile bölme yapamazsın\")"
      ],
      "metadata": {
        "id": "i41BU4VwQDST"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=int(input())\n",
        "b=int(input())\n",
        "try:\n",
        "  print(a/b)\n",
        "except ZeroDivisionError:\n",
        "  print(\"0 ile bölme yapamazsın\")\n",
        "finally:\n",
        "  print(\"hata olsada olmasa da en son ben çalışıcam\")"
      ],
      "metadata": {
        "id": "Bts7P391QT31"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- AssertionError\n",
        "- AttributeError\n",
        "- EOFError\n",
        "- ImportError\n",
        "- IndexError\n",
        "- KeyError\n",
        "- MemoryError\n",
        "- NameError\n",
        "- OSError\n",
        "- RuntimeError\n",
        "- SyntaxError\n",
        "- IndentationError\n",
        "- ZeroDivisionError\n",
        "- TypeError"
      ],
      "metadata": {
        "id": "DhtSsuVeXPnv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "moZ4q3x2XPVJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MKjSytIi04lD"
      },
      "source": [
        "## Sınıflar"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Nesne tabanlı programlama yaklaşımı, özellikle birtakım ortak niteliklere ve davranış şekillerine sahip gruplar tanımlamak gerektiğinde son derece kullanışlıdır. Mesela şöyle bir örnek düşünün: Diyelim ki çalıştığınız işyerinde, işe alınan kişilerin kayıtlarını tutan bir veritabanınız var. Bir kişi işe alındığında, o kişiye dair belli birtakım bilgileri bu veritabanına işliyorsunuz. Mesela işe alınan kişinin adı, soyadı, unvanı, maaşı ve buna benzer başka bilgiler…"
      ],
      "metadata": {
        "id": "7i5nAcVJm8AY"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jmog2hUy06gO"
      },
      "source": [
        "class Çalışan:\n",
        "    ..."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        ""
      ],
      "metadata": {
        "id": "3nvFttQ6m-su"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Yukarıdaki, boş bir sınıf tanımıdır. Hatırlarsanız fonksiyonları tanımlamak için def adlı bir ifadeden yararlanıyorduk. İşte sınıfları tanımlamak için de class adlı bir ifadeden yararlanıyoruz. Bu ifadenin ardından gelen Çalışan kelimesi ise bu sınıfın adıdır.\n",
        "Eğer arzu ederseniz, yukarıdaki sınıfı şu şekilde de tanımlayabilirsiniz:\n"
      ],
      "metadata": {
        "id": "bCQ1wcpInAUW"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WpTWn3nM1CCV"
      },
      "source": [
        "class Çalışan():\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Çalışan():\n",
        "    kabiliyetler = []\n",
        "    unvanı = 'işçi'\n"
      ],
      "metadata": {
        "id": "JOks9Mz6nClN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(Çalışan.kabiliyetler)\n",
        "print(Çalışan.unvanı)"
      ],
      "metadata": {
        "id": "HuZz2V8knCoS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "çalışan1 = Çalışan()\n",
        "çalışan1.unvanı"
      ],
      "metadata": {
        "id": "52Vc41danCrM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Çalışan():\n",
        "    kabiliyetler = []\n",
        "    unvanı = 'işçi'\n",
        "    \n",
        "    def KabiliyetEkle(self,kabiliyet:str):\n",
        "        self.kabiliyetler.append(kabiliyet)\n",
        "\n",
        "çalışan1 = Çalışan()\n",
        "\n",
        "print(çalışan1.kabiliyetler)\n",
        "çalışan1.KabiliyetEkle(\"ingilizce\")\n",
        "print(çalışan1.kabiliyetler)"
      ],
      "metadata": {
        "id": "u3Sq3HTqnHxt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Çalışan():\n",
        "    kabiliyetler = []\n",
        "    unvanı = 'işçi'\n",
        "    \n",
        "    def __init__(self,unvanı=\"işçi\",kabiliyetler=[]):\n",
        "        self.kabiliyetler = kabiliyetler\n",
        "        self.unvanı = unvanı \n",
        "    \n",
        "    def KabiliyetEkle(self,kabiliyet:str):\n",
        "        self.kabiliyetler.append(kabiliyet)\n",
        "\n",
        "#---------------------------------\n",
        "çalışan1 = Çalışan(\"patron\",[\"ingilizce\"])\n",
        "çalışan2 = Çalışan(\"bakkal\")\n",
        "\n",
        "print(çalışan1.kabiliyetler)\n",
        "print(çalışan2.kabiliyetler)"
      ],
      "metadata": {
        "id": "nF7W1BownH3j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Çalışan():\n",
        "    kabiliyetler = []\n",
        "    unvanı = 'işçi'\n",
        "    \n",
        "    @classmethod\n",
        "    def KabiliyetEkle(cls,kabiliyet:str):\n",
        "        cls.kabiliyetler.append(kabiliyet)\n",
        "\n",
        "çalışan = Çalışan()\n",
        "\n",
        "print(çalışan.kabiliyetler)\n",
        "çalışan.KabiliyetEkle(\"ingilizce\")\n",
        "print(çalışan.kabiliyetler)\n",
        "Çalışan.kabiliyetler"
      ],
      "metadata": {
        "id": "m3QANseRnKFu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Çalışan():\n",
        "    kabiliyetler = []\n",
        "    unvanı = 'işçi'\n",
        "    \n",
        "    def __init__(self,isim):\n",
        "        print(f\"{isim} oluşturuldu\")\n",
        "\n",
        "çalışan1 = Çalışan(\"ahmet\")\n",
        "çalışan2 = Çalışan(\"ali\")"
      ],
      "metadata": {
        "id": "ebilOgvGnKKU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# öğrenci otomasyonu\n",
        "class Öğrenci():\n",
        "    öğrenciler = []\n",
        "\n",
        "    def __init__(self,isim:str,soyad:str,sınıf:int,şube:str):\n",
        "        if self.öğrenci_varmı(isim,soyad):\n",
        "            print(\"bu öğrenci zaten var\")\n",
        "            öğrenci = self.öğrenci_bul(isim,soyad)\n",
        "            self.isim = öğrenci.isim\n",
        "            self.soyad = öğrenci.soyad\n",
        "            self.sınıf = öğrenci.sınıf\n",
        "            self.şube = öğrenci.şube\n",
        "        else:\n",
        "            self.öğrenciler.append(self)\n",
        "            self.isim = isim\n",
        "            self.soyad = soyad\n",
        "            self.sınıf = sınıf\n",
        "            self.şube = şube\n",
        "    \n",
        "    def öğrenci_varmı(self,isim:str,soyad:str):\n",
        "        for öğrenci in self.öğrenciler:\n",
        "            if öğrenci.isim == isim and öğrenci.soyad == soyad:\n",
        "                return True\n",
        "        return False\n",
        "    \n",
        "    def öğrenci_bul(self,isim:str,soyad:str):\n",
        "        for öğrenci in self.öğrenciler:\n",
        "            if öğrenci.isim == isim and öğrenci.soyad == soyad:\n",
        "                return öğrenci\n",
        "        \n",
        "        \n",
        "    def tanıt(self):\n",
        "        print(f\"{self.isim} {self.soyad}\")\n"
      ],
      "metadata": {
        "id": "ByLeLg-HnPUZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ahmet = Öğrenci(\"Ahmet\",\"şahin\",8,\"a\")\n",
        "mehmet = Öğrenci(\"Mehmet\",\"şahin\",7,\"b\")\n",
        "ahmet.tanıt()\n",
        "mehmet.tanıt()"
      ],
      "metadata": {
        "id": "N_sHYPfKnQXp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for öğrenci in Öğrenci.öğrenciler:\n",
        "    print(öğrenci.isim)"
      ],
      "metadata": {
        "id": "V28BVhjonQdu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "daSnnIwz0_2r"
      },
      "source": [
        "## Kütüphaneler"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "print(math.sqrt(16))\n",
        "print(math.pi)"
      ],
      "metadata": {
        "id": "mf1AxubKnckB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import datetime \n",
        "\n",
        "datetime.datetime.now().day"
      ],
      "metadata": {
        "id": "ZJoyLaEfncnP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from datetime import datetime as dt\n",
        "dt.now()"
      ],
      "metadata": {
        "id": "yvOF4SS3ncqh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "random.randint(0,100)"
      ],
      "metadata": {
        "id": "p_NcKdobncs7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "os.name"
      ],
      "metadata": {
        "id": "n7gZl4gbncwM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "if os.name != 'nt':\n",
        "    print(\"windows bulunamadı\")\n",
        "else:\n",
        "    print('Hoşgeldin Windows kullanıcısı!')"
      ],
      "metadata": {
        "id": "7mmfYvtWnczO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "np.arange(15).reshape(3, 5)"
      ],
      "metadata": {
        "id": "evrbdIT_nc1-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import requests\n",
        "req = requests.get('https://www.geeksforgeeks.org/classmethod-in-python/')\n",
        "req.text"
      ],
      "metadata": {
        "id": "kcwC4wSYnjJB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W0q8EQ0Y1Gx8"
      },
      "source": [
        "# Python İle Yapabileceklerimiz Ve Yardımcı Kütüphaneler/çerçeveler"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JI13lshC1ZCB"
      },
      "source": [
        "\n",
        "#### Web/api\n",
        "- django\n",
        "- fastapi\n",
        "- starlette\n",
        "- flask\n",
        "- bottle\n",
        "- pyramid\n",
        "- tornado (şuan kullandığımız jupyter notebook editörü bu framework ile yapıldı)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YW6u3GFD155h"
      },
      "source": [
        "#### Masaüstü uygulaması\n",
        "- PyQT\n",
        "- Tkinter\n",
        "- WxPython\n",
        "- PyGui\n",
        "- Pyside\n",
        "- kivy\n",
        "- PySimpleGUI"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y1AN2qlS15-m"
      },
      "source": [
        "#### Mobil uygulama\n",
        "- kivy\n",
        "- beeWare"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENzAbK6H2BUd"
      },
      "source": [
        "#### Oyun geliştirme\n",
        "- pygame\n",
        "- Cocos2d\n",
        "- panda3d\n",
        "- ursina\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O-1aDCH82Fa1"
      },
      "source": [
        "#### Robotik ve gömülü sistemler\n",
        "- gpio\n",
        "- robot framework\n",
        "- pyro\n",
        "- micropython !"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MrsQgNMV2F7k"
      },
      "source": [
        "#### Veri bilimi\n",
        "- Scikit-learn\n",
        "- Matplotlib\n",
        "- SciPy\n",
        "- pandas\n",
        "- numpy\n",
        "- seaborn\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7DtOdlBI2NnY"
      },
      "source": [
        "#### Veri kazıma\n",
        "- requests\n",
        "- lxml\n",
        "- Beautiful Soup\n",
        "- selenium\n",
        "- Scrapy\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8_IZoyi92Nq3"
      },
      "source": [
        "#### Makine öğrenmesi ve derin öğrenme\n",
        "- TensorFlow\n",
        "- Keras\n",
        "- PyTorch\n",
        "- coffee\n",
        "- openCV\n",
        "- NLTK\n",
        "- Numpy\n",
        "- Pandas\n",
        "- Scipy\n",
        "- Scikit-learn\n",
        "- Theano\n",
        "- Matplotlib\n",
        "- Seaborn\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ehLEmlue2N6D"
      },
      "source": [
        "#### ve fazlası\n",
        "- pydantic\n",
        "- icecream\n",
        "- pytest\n",
        "- pillow\n",
        "- SQLalchemy\n",
        "- Tortoise Orm\n",
        "- qiskit\n",
        "- typer\n",
        "- strawberry\n",
        "- numba\n",
        "- brython\n",
        "- pygrpc\n",
        "\n",
        "\n",
        "\n",
        "- micropython\n",
        "- cpython (cython)\n",
        "- jython\n",
        "- IronPython"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "0wRK2YUPZzVZ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}