Python-Egitimi.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programlama Nedir ?\n",
    "\n",
    "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",
    " \n",
    "## Programlama Nasıl Yapılır ?\n",
    "\n",
    "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": {},
   "source": [
    "## PYTHON NEDİR VE NELER YAPILABİLİR?\n",
    "\n",
    "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",
    "## Python Programlama Dilinin Avantajları\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",
    "\n",
    "## Makine Öğreniminde Python’un Yeri ve Veri Bilimi\n",
    "\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.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Çalışma Ortamının kurulması\n",
    "\n",
    "Anaconda resmi sitesine (https://www.anaconda.com/products/individual) giderek işletim sistemimize uygun olan versiyonu indiriyoruz. Kurulum esnasında bütün değerleri varsayılanda bırakarak geçebiliriz . Daha sonrasında Anaconda Navigator programını açtığımızda conda ortamında kullanabileceğimiz birkaç farklı editör karşımıza çıkıyor. Biz bu eğitim için Jupyter Notebook programını indiriyoruz. Daha sonrasında yine Anaconda Navigator üzerinden açabileceğimiz gibi terminale/komut satırına “jupyter notebook” yazarak da editörümüzü açabileceğiz. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Standart Veri Tipleri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
    "    \n",
    "    Float\n",
    "    \n",
    "\tString\n",
    "    \n",
    "\tList\n",
    "    \n",
    "\tTupple\n",
    "    \n",
    "    Dictionary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Değişkenler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(tamSayi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print fonksiyonu\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"merhaba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"merhaba\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3+5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "9/5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "11//3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "11%3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2**5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "-5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = 2\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = \"merhaba\"\n",
    "d = \"ali\"\n",
    "c + \" \" + d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"merhaba\"*\"iyi günler\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"merhaba \"*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c + d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = a * b\n",
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = e * a + b\n",
    "g = e * (a + b)\n",
    "f, g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Değişken İsimlendirme Kuralları"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Değişken isimleri hem harf hem sayı içerebilir. Fakat mutlaka harfle başlamalıdır"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "17fatih = \"algoritma\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fatih17 = \"algoritma\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Değişkenlerin içinde alt çizgi karakteri (“_”) kullanabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "demet = 0,3256,1,2\n",
    "demet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "virgullu_sayi = 0.3256\n",
    "virgullu_sayi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=5\n",
    "A=4\n",
    "a,A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "'”`;,<>/?|\\/()!@#$%^&*~-+  gibi karakterler değişken isimlerinde bulunamazlar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s@yı = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kişi.com = \"ahmet\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Değişkenlere isim verirken anahtar kelimeler kullanamazsınız"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "and = \"and adında degişken\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python'da kullanılan tüm anahtar kelimeler:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword\n",
    "keyword.kwlist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OPERATORLER "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Atama / işlemli atam operatoru (=)\n",
    "sayi=5\n",
    "sayi=7\n",
    "sayi = sayi+2\n",
    "sayi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Karşılaştırma Operatörleri"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "== ,> ,<=  karşılaştırma operatörlerinden bazılarıdır"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1==1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isim0=\"Ali\"\n",
    "isim1=\"Veli\"\n",
    "isim2=\"ali\"\n",
    "\n",
    "bool5= isim0==isim1\n",
    "bool6= isim0==isim2\n",
    "bool5,bool6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi3=\"5\"\n",
    "sayi4=5\n",
    "bool7= sayi3==sayi4\n",
    "bool7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mantıksal Operatörler\n",
    "### AND\n",
    "\n",
    "00=0\n",
    "\n",
    "01=0\n",
    "\n",
    "10=0\n",
    "\n",
    "11=1\n",
    "\n",
    "\n",
    "### OR\n",
    "\n",
    "00=0\n",
    "\n",
    "01=1\n",
    "\n",
    "10=1\n",
    "\n",
    "11=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 and 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 and 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 or 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=5\n",
    "a>0 and a<10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=5\n",
    "a>0 and a%2==0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=5\n",
    "a>0 or a%2==0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VERİ GİRİŞİ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isim = input(\"İsminiz nedir? \")\n",
    "print(\"merhaba\", isim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi = input(\"sayı giriniz? \")\n",
    "type(sayi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi = input(\"sayı giriniz? \")\n",
    "sayi2 = input(\"2. sayıyı giriniz? \")\n",
    "sayi + sayi2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TİP-DÖNÜŞÜMLERi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi = \"5\"\n",
    "print(type(sayi))\n",
    "print(type( int(sayi) ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(\"5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi1 = input(\"1. sayıyı giriniz? \")\n",
    "sayi2 = input(\"2. sayıyı giriniz? \")\n",
    "sayi1 + sayi2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi1 = int(input(\"1. sayıyı giriniz? \"))\n",
    "sayi2 = input(\"2. sayıyı giriniz? \")\n",
    "sayi1 + int(sayi2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diziler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boş liste değişkeni \n",
    "liste =  []\n",
    "print(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dizi/liste(array) oluşturmanın farklı bir tarzı\n",
    "liste =  list()\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sadece int değerler tutan dizi/liste\n",
    "liste =  [1,2,3,4,5,6,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string tutan array\n",
    "liste =  list([\"İstanbul\",\"Ankara\",\"İzmir\"])\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string parçalayarak dizi/liste oluşturma\n",
    "isim = \"İstanbul\"\n",
    "liste =  list(isim)\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# array indexleme /basit dizi\n",
    "liste = [\"Elma\",\"Armut\",\"Kivi\",\"Muz\",[\"armut\",2]]\n",
    "liste[2],liste[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# liste2[2] = yeniliste[1][2]\n",
    "yeniliste[1][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Listenin sonuncu elemanını gösterme\n",
    "liste = [3,4,5,6,7,8,9]\n",
    "len(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uzunluk = len(liste)\n",
    "liste[-uzunluk+1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Baştan 4. indekse kadar (dahil değil)\n",
    "liste = [3,4,5,6,7,8,9]\n",
    "liste[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. ve 4. arasını alma\n",
    "liste = [3,4,5,6,7,8,9]\n",
    "liste[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. indexten sonuna kadar alma\n",
    "liste = [3,4,5,6,7,8,9]\n",
    "liste[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Listeleri birleştirme\n",
    "liste1 =  [1,2,3,4,5]\n",
    "liste2 =  [6,7,8,9,10]\n",
    "liste3 = liste1 + liste2\n",
    "liste3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Diziye eleman dahil etme\n",
    "liste =  [\"Manisa\",\"Düzce\",\"Bolu\"]\n",
    "liste += [\"Çankırı\"]\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Listedeki elemanı değiştirme /Yöntem1\n",
    "liste =  [1,2,3,4,5]\n",
    "liste[2]=\"Merhaba\"\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste =  [1,2,3,4,5]\n",
    "liste[:3]=[10,20]\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dizi çarpma işlemi ile tekrarlama\n",
    "liste =  [1,2,3,4,5]\n",
    "liste *= 2\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Liste eleman sayısı\n",
    "liste = [3,4,5,6,6,7,8,9,0,0,0]\n",
    "len(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste =  [1,2,3,4,5]\n",
    "liste.append([1,2])\n",
    "liste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Koşullu ifadeler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "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\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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ş\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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ış')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (username == 'bilal') and (password == '1234'):\n",
    "        print('Hoş geldiniz')      \n",
    "else:\n",
    "    print('username ya da parola yanlış')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "input(\"sayı giriniz:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[\"a\",\"b\"][5==4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Döngüler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi=90\n",
    "while(sayi<101):\n",
    "    print(sayi)\n",
    "    sayi+=1 # sayi = sayi +1\n",
    "\"bitti\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while 1:\n",
    "    print(\"merhaba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "meyveler = [\"apple\", \"banana\", \"cherry\"]\n",
    "for meyve in meyveler:\n",
    "    print(meyve)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# continue\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for x in fruits:\n",
    "    if x == \"banana\":\n",
    "        continue\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sayi = 1\n",
    "toplam=0\n",
    "while sayi<101:\n",
    "  if sayi % 7 ==0 and sayi % 11 == 0:\n",
    "    break\n",
    "  elif sayi % 7 == 0:\n",
    "    sayi+=1\n",
    "  elif sayi % 11 == 0:\n",
    "    toplam += sayi*2\n",
    "    sayi+=1\n",
    "  else:\n",
    "    toplam += sayi\n",
    "    sayi+=1\n",
    "  \n",
    "print(toplam)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fonksiyonlar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello():\n",
    "    print(\"Merhaba\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hello()\n",
    "hello()\n",
    "hello()\n",
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    print(\"Hello \"+ name)\n",
    "\n",
    "hello(\"Bilal\")\n",
    "hello(\"Yusuf\")\n",
    "hello(\"Ali\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = input(\"sayı: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    return \"Merhaba \"+ name\n",
    "    print(\"çalışmaz\")\n",
    "\n",
    "isim = hello(\"Bilal\")\n",
    "print(isim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def toplama(a,b):\n",
    "    return a+b\n",
    "\n",
    "sonuc = toplama(10,20)\n",
    "sonuc # 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def yazdir(kelime, adet):\n",
    "    print(kelime * adet)\n",
    "\n",
    "yazdir('Merhaba\\n', 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"a\",\"b\",\"c\",sep=\"-\",end=\"'satır sonu'\")\n",
    "print(\"b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Soru: Gönderilen 2 sayı arasındaki tüm asal sayıları bulan python fonksiyon uygulamasını yapınız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = int(input(\"min: \"))\n",
    "b = int(input(\"max: \"))\n",
    "asallar_listesi = asalları_bul(min=a,max=b)\n",
    "asallar_listesi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(asal(19,min=5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum([i**2 for i in range(0,47)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bazen fonksiyonlara gönderdiğimiz parametreler yerine varsayılan değerleri kullanmak isteyebiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def toplama(a,b):\n",
    "    return a+b\n",
    "\n",
    "def toplama(a,b,c):\n",
    "    return a+b+c\n",
    "..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eğer ki **args şeklinde parametre belirtirsek bu durumda key-value şeklinde istediğimiz sayıda bilgiyi fonksiyona gönderebiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def displayUser(**args):\n",
    "    for key, value in args.items():\n",
    "        print(f\"key: {key} value: {value}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dizi = [1,2,3,4]\n",
    "def func():\n",
    "    global dizi\n",
    "    dizi[1]=10\n",
    "    \n",
    "dizi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def topla(a:int,b:int) -> int:\n",
    "    \"\"\"bu fonksiyon iki tane sayı alır\"\"\"\n",
    "    return a+b\n",
    "topla(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dizi_topla(a:list,b:list) -> list:\n",
    "    return a + b\n",
    "\n",
    "dizi_topla([1,2,3],[4,5,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def topla(a:int,b:int = 5) -> int:\n",
    "    return a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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ı"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sınıflar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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…"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Çalışan:\n",
    "    ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Çalışan():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Çalışan():\n",
    "    kabiliyetler = []\n",
    "    unvanı = 'işçi'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Çalışan.kabiliyetler)\n",
    "print(Çalışan.unvanı)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "çalışan1 = Çalışan()\n",
    "çalışan1.unvanı"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ahmet = Öğrenci(\"Ahmet\",\"şahin\",8,\"a\")\n",
    "mehmet = Öğrenci(\"Mehmet\",\"şahin\",7,\"b\")\n",
    "ahmet.tanıt()\n",
    "mehmet.tanıt()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for öğrenci in Öğrenci.öğrenciler:\n",
    "    print(öğrenci.isim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dekoratörler ve İç İçe Fonksiyonlar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dekoratörler, temelde alınan parametreyi iç fonksiyona (wrapper) gönderen ve geriye de bu fonksiyonu döndüren fonksiyonlardır. İç fonksiyonları dekoratör yazmadığınız durumlarda da kullanabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "def my_call_function(func, *args):\n",
    "    return func(*args)\n",
    "\n",
    "my_call_function(add, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Kapsülleme (Encapsulation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n: int):\n",
    "    assert type(n) == int\n",
    "    assert n >= 0\n",
    "\n",
    "    def fact(n):\n",
    "        if n <= 1:\n",
    "            return 1\n",
    "        return n * fact(n - 1)\n",
    "\n",
    "    return fact(n)\n",
    "\n",
    "print(factorial(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dekoratör"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Yöntem 1:\n",
    "@decorator\n",
    "def func():\n",
    "    pass\n",
    "\n",
    "# Yöntem 2:\n",
    "def func():\n",
    "    pass\n",
    "    \n",
    "func = decorator(func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decorator(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        print('Fonksiyon çalışacak...')\n",
    "        func()\n",
    "        print(\"fonksiyon bitti\")\n",
    "    return wrapper\n",
    "\n",
    "\n",
    "@decorator\n",
    "def myfunc():\n",
    "    print('Fonksiyon çalıştı.')\n",
    "\n",
    "\n",
    "myfunc()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "\n",
    "def time_it(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        time_start = time()\n",
    "        result = func()\n",
    "        time_finish = time()\n",
    "\n",
    "        time_delta = time_finish - time_start\n",
    "        print(f'fonksiyonumuz {round(time_delta, 5)} saniye sürdü.')\n",
    "\n",
    "        return result\n",
    "\n",
    "    return wrapper\n",
    "\n",
    "@time_it\n",
    "def myfunc():\n",
    "    for i in range(100000000):pass\n",
    "    print(\"çalıştı\")\n",
    "\n",
    "myfunc()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class sleep:\n",
    "    def __init__(self, secs):\n",
    "        self.secs = secs\n",
    "\n",
    "    def __call__(self, func):\n",
    "        from functools import wraps\n",
    "\n",
    "        @wraps(func)\n",
    "        def wrapper(*args, **kwargs):\n",
    "            from time import sleep\n",
    "\n",
    "            sleep(self.secs)\n",
    "            return func(*args, **kwargs)\n",
    "\n",
    "        return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@sleep(3)\n",
    "def hello(name):\n",
    "    print(f'Hello {name}')\n",
    "\n",
    "\n",
    "hello('World')\n",
    "hello('Bilal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@sleep(3)\n",
    "class User(object):\n",
    "    def __init__(self, name):\n",
    "        print(f\"{name} adlı kullanıcı oluşturuldu\")\n",
    "\n",
    "user = User('Ahmet')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kalıtım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class İnsan():\n",
    "    def __init__(self,ad,soyad,yaş):\n",
    "        self.ad= ad\n",
    "        self.soyad= soyad\n",
    "        self.yaş= yaş\n",
    "        \n",
    "    def bilgiVer(self):\n",
    "        print(self.ad + \" \" + self.soyad+ \" \"+ str(self.yaş))\n",
    "        \n",
    "Ahmet = İnsan(\"Ahmet\", \"şahin\", 20)\n",
    "\n",
    "Ahmet.bilgiVer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ögrenci(İnsan):\n",
    "    def öğrenci(self):\n",
    "        print(\"ben öğrenciyim\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ahmet = İnsan(\"Ahmet\", \"şahin\", 20)\n",
    "Ahmet.bilgiVer()\n",
    "# Ahmet.öğrenci()\n",
    "\n",
    "Bilal = Ögrenci(\"Bilal\",\"Alpaslan\", 80)\n",
    "Bilal.bilgiVer()\n",
    "Bilal.öğrenci()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ogrenci(İnsan):\n",
    "    sınıf = \"8\"\n",
    "        \n",
    "    def statüKontrol(self):\n",
    "        return self.sınıf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bilal = Ogrenci(\"Bilal\",\"Alpaslan\", 80)\n",
    "Bilal.bilgiVer()\n",
    "Bilal.statüKontrol()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Override"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ogrenci(İnsan):\n",
    "    statü = \"öğrenci\"\n",
    "    \n",
    "    def bilgiVer(self):\n",
    "        print(\"Merhaba, ben \" + self.ad + \" \" + self.soyad)\n",
    "        \n",
    "    def statüKontrol(self):\n",
    "        return self.statü"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Ahmet = İnsan(\"Ahmet\", \"şahin\", 20)\n",
    "Ahmet.bilgiVer()\n",
    "\n",
    "Bilal = Ogrenci(\"Bilal\",\"Alpaslan\", 80)\n",
    "Bilal.bilgiVer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Override edilen fonksiyonu çağırma ve super() metodu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ogrenci(İnsan):\n",
    "    statü = \"öğrenci\"\n",
    "    \n",
    "    def bilgiVer(self):\n",
    "        İnsan.bilgiVer(self)\n",
    "        print(\"Merhaba, ben \" + self.ad + \" \" + self.soyad)\n",
    "        \n",
    "    def statüKontrol(self):\n",
    "        return self.statü"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bilal = Ogrenci(\"Bilal\",\"Alpaslan\", 80)\n",
    "Bilal.bilgiVer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Ogrenci(İnsan):\n",
    "    statü = \"öğrenci\"\n",
    "    \n",
    "    def bilgiVer(self):\n",
    "        super().bilgiVer()\n",
    "        print(\"Merhaba, ben \" + self.ad + \" \" + self.soyad)\n",
    "        \n",
    "    def statüKontrol(self):\n",
    "        return self.statü"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bilal = Ogrenci(\"Bilal\",\"Alpaslan\", 80)\n",
    "Bilal.bilgiVer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Öğrenci():\n",
    "    \"\"\"\n",
    "    bu sınıf bir öğrenci sınıfını yönetmenizi sağlar\n",
    "    \n",
    "    \"\"\"\n",
    "    öğrenciler=[]\n",
    "    \n",
    "    def __init__(self,isim,soyad,sınıf,şube,no):\n",
    "        self.isim = isim\n",
    "        self.soyad = soyad\n",
    "        self.sınıf = sınıf\n",
    "        self.şube = şube\n",
    "        self.no = no\n",
    "        self.öğrenciler.append(self)\n",
    "    \n",
    "    def delete(cls,no:int):\n",
    "        for index,öğrenci in enumerate(cls.öğrenciler):\n",
    "            if öğrenci.no==no:\n",
    "                cls.öğrenciler.pop(index)\n",
    "    \n",
    "    def __str__(self):\n",
    "        return self.no\n",
    "    \n",
    "    def öğrencileriGetir(cls):\n",
    "        data = []\n",
    "        for öğrenci in cls.öğrenciler:\n",
    "            data.append(öğrenci.no)\n",
    "        return data\n",
    "        \n",
    "    \n",
    "\n",
    "ahmet = Öğrenci(\"Ahmet\",\"Şahin\",5,\"b\",1)\n",
    "ali = Öğrenci(\"Ali\",\"Şahin\",7,\"c\",2)\n",
    "ali = Öğrenci(\"Ayşe\",\"Şahin\",8,\"c\",3)\n",
    "ali = Öğrenci(\"Fatma\",\"Şahin\",1,\"c\",4)\n",
    "# print(Öğrenci.öğrenciler)\n",
    "\n",
    "print(ali.öğrencileriGetir())\n",
    "ali.delete(2)\n",
    "ali.delete(4)\n",
    "print(ali.öğrencileriGetir())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assert ve Try catch ile hata yakalama "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 1 == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert 1 == 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "raise Exception(\"hata\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1+\"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(0/0)\n",
    "except TypeError:\n",
    "    print(\"bu bir tip hatası\")\n",
    "# except:\n",
    "#     print(\"başka bir hata\")\n",
    "finally:\n",
    "    print(\"bitiş\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TabError,SystemError,TypeError,IndexError,RuntimeError,ValueError,ZeroDivisionError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Properties"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(Öğrenci)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Öğrenci.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter notebook magic command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "for i in range(10000000):pass #10M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%dirs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kütüphaneler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(math.sqrt(16))\n",
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime \n",
    "\n",
    "datetime.datetime.now().day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime as dt\n",
    "dt.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "random.randint(0,100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.name != 'nt':\n",
    "    print(\"windows bulunamadı\")\n",
    "else:\n",
    "    print('Hoşgeldin Windows kullanıcısı!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.arange(15).reshape(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "req = requests.get('https://www.geeksforgeeks.org/classmethod-in-python/')\n",
    "req.text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python ile yapabileceklerimiz ve yardımcı kütüphaneler/frameworkler\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ı)\n",
    "\n",
    "#### Masaüstü uygulaması\n",
    "- PyQT\n",
    "- Tkinter\n",
    "- WxPython\n",
    "- PyGui\n",
    "- Pyside\n",
    "- kivy\n",
    "- PySimpleGUI\n",
    "\n",
    "#### Mobil uygulama\n",
    "- kivy\n",
    "- beeWare\n",
    "\n",
    "#### Oyun geliştirme\n",
    "- pygame\n",
    "- Cocos2d\n",
    "- panda3d\n",
    "- ursina\n",
    "\n",
    "#### Robotik ve gömülü sistemler\n",
    "- gpio\n",
    "- robot framework\n",
    "- pyro\n",
    "- micropython !\n",
    "\n",
    "#### Veri bilimi\n",
    "- Scikit-learn\n",
    "- Matplotlib\n",
    "- SciPy\n",
    "- pandas\n",
    "- numpy\n",
    "- seaborn\n",
    "\n",
    "#### Veri kazıma\n",
    "- requests\n",
    "- lxml\n",
    "- Beautiful Soup\n",
    "- selenium\n",
    "- Scrapy\n",
    "\n",
    "#### 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",
    "\n",
    "#### 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",
    "- micropython\n",
    "- cpython (cython)\n",
    "- jython\n",
    "- IronPython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}