1-python_temeller.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Dilinin Temelleri\n",
    "\n",
    "![Python](data/python.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "Python birçok programlama dilinden biridir. Açık ve anlaşılır dili ile popülerdir. Bilimsel rekabetin hemen hemen her alanında açık kaynaklı Python araçları müthiş bir ekosisteme sahiptir. Basitçe açıklamak gerekirse, Python diğer dillerin öğle yemeğini yemektedir. \n",
    "\n",
    "Python ‘un tarihi bilgilerini araştırmak isterseniz, Wikidipedia güzel bir kaynak. Burada tarihi bilgileri tüm detayları ile anlatmayacağız fakat Pythonun ne olduğunu ve Python kültürünün önemli kısımlarını yüksek seviyede anlamanızı istiyoruz. Program dilini öğrenmenin bir parçası da tarihi ve kültürü hakkında bir parça bilgi sahibi olmaktır. \n",
    "\n",
    "Hollandalı programcı Guido Van Rossum, 1980 lerin sonunda özgün olarak Pythonu tasarladı. 1.0 versiyonunu 1994 yılında çıkardı. Sizin de tahmin edebileceğiniz gibi bir programlama dili için, Python topluluğu gereksiz formaliteye çok büyük önem atfeder. Örneğin Zen of Python, Python’un geliştirici prensiplerine rehberlik eden bir şiir, Python yorumlayıcısı (interpreter) içinde bulunmakta:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bu şiir PEP20’den gelmektedir. PEP Python kodlarının gelişerek nasıl devam edeceğini gösterir. Meraklıysanız PEP 1’den başlayarak okuyabilirsiniz. Bilmeniz gereken diğer önemli bir PEP ise PEP8'dir ki Python kodlarını yazmak için standartlaştırılmış stile rehberlik eder. Topluluk tarafından kabul edilmiş teamülleri tanımlar. \n",
    "\n",
    "Her bir Pep Pyton dokümanları ile birlikte Python.org de yer almaktadır. Son birkaç yıldır Python geliştirme topluluğu Python 2 den Python 3’e geçmektedir. Bu kursta da Python 3 kullanacağız. Fakat üretimde hala birçok Python2 kodları var ve bu yüzden Python 2’nin etrafımızda olduğunu bilmeliyiz. İnternette rastgele kod örneklerine bakarken eski Python 2 kodlarını yanlışlıkla araştırmadığınızdan emin olmanız sizin için iyi olur. \n",
    "\n",
    "Python kodlarını yazmak için, bir metin editörü isteyeceksiniz ve Python çalıştırmak için Python çerçevesine ihtiyaç duyacaksınız. Burada sevdiğiniz herhangi bir kodu düzenleyebilir ve çalıştırabilirsiniz. Şimdi aşağıda küçük bir deneme yapalım:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world, I'm the DJL\n"
     ]
    }
   ],
   "source": [
    "# Edit the line below to add your first name between the \"\"\n",
    "# characters.\n",
    "my_name = \"DJL\"\n",
    "\n",
    "greeting = \"Hello, world, I'm the \"\n",
    "\n",
    "def say_hello(name):\n",
    "    if name == \"\":\n",
    "        print(\"You can't introduce yourself if you don't add your name!\")\n",
    "    else:\n",
    "        print(greeting + name)\n",
    "    \n",
    "# Click the \"play\" button to execute this code.\n",
    "say_hello(my_name)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Değişkenlerle Çalışmak\n",
    "\n",
    "Değişken bir değere verilen addır. Bir programda herhangi bir yerde tanımlanan değerleri adlandırabiliriz. Böylelikle sonrasında bu değeri kodumuzla her seferinde tanımı yeniden yazmadan geçebiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The data science community is a vibrant place to be involved in.\n",
      "\n",
      "\n",
      "www.datajarlabs.com/education.html\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "base_url = \"www.datajarlabs.com\"\n",
    "\n",
    "# We're going to use newlines (\"\\n\") to format things nicely.\n",
    "empty_line = \"\\n\"\n",
    "\n",
    "print(\"The data science community is a vibrant place to be involved in.\")\n",
    "print(empty_line)\n",
    "\n",
    "# Now we're going to start using our `base_url` variable multiple\n",
    "# times.\n",
    "print(base_url + \"/education.html\")\n",
    "print(empty_line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Değişkenler programın durumunu takip etmek ve düzenlemek için bize bir yol gösterir. Bu kulağa çok soyut gelebilir, bir örneğe bakalım. Duvarın üzerinde kaç fincan kahve olduğunu soran aşağıdaki kodu bir inceleyelim:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How many cups of coffee are on the wall?12\n",
      "There are 12 cups of cofee on the wall.\n",
      "Would you like to take any down?yes\n",
      "Ok, how many?10\n",
      "There are now 2 cups on the wall\n"
     ]
    }
   ],
   "source": [
    "# Ask the user for input and store the result in a variable.\n",
    "cup_count = int(input(\"How many cups of coffee are on the wall?\"))\n",
    "\n",
    "print(\"There are {} cups of cofee on the wall.\".format(cup_count))\n",
    "\n",
    "if input(\"Would you like to take any down?\") == \"yes\":\n",
    "    removed_cups = int(input(\"Ok, how many?\"))\n",
    "    cup_count = cup_count - removed_cups\n",
    "    print(\"There are now {} cups on the wall\".format(cup_count))\n",
    "else:\n",
    "    print(\"Ok, there are still {} cups on the wall.\".format(cup_count))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Pythonda değişkenler\n",
    "\n",
    "\n",
    "Pythonda değişkenlerle çalışırken değişkene bir değeri vermek ve bir değişkenden değeri geri almak isteriz. Bir değişkene bir değeri vermek için takip eden syntax ile = operatörünü kullanırız.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "my_name = \"Guido van Rossum\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Burada my_name değişkeninin değerini ‘’Guido Van Rossum’’ olarak belirledik. my_name değerini diğer işlemler ile güncelleyebiliriz (örneğin my_name=’Ahmet Mehmet’ olabilir).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Not: = operatörü bir değişkene bir değer atar, iki farklı değerin birbirine eşit olduğu anlamına gelmez. Matematik ifadelerinde = bir eşitlik işaretidir ve eşitliğin her iki tarafının eşit olduğu anlamına gelir. Örneği 2+2=4 makul bir ifadedir. Fakat Python'da bu anlama gelmez. Python'da = karakteri sağdaki bir değeri soldaki bir değişkene atar. Pythonda 2+2=4 kodunu yazarsanız size hata verecektir. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world, my name is Ahmet.\n"
     ]
    }
   ],
   "source": [
    "my_name = \"Guido van Rossum\"\n",
    "\n",
    "# Edit and uncomment the line below if you want to reassign the\n",
    "# value of the `my_name variable.\n",
    "\n",
    "my_name = \"Ahmet\"\n",
    "\n",
    "print(\"Hello world, my name is \" + my_name + \".\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Değişkenleri Adlandırma\n",
    "\n",
    "Değişkenler için seçeceğiniz isimler çok önemli.\n",
    "\n",
    "Diğer taraftan, Python yorumcusunun ilk etapta kodun bir değişken hakkında bahsettiğinin farkına varması için değişken isimlerinin nasıl olması gerektiği hakkında bazı kurallar bulunmaktadır. Diğer taraftan da değişkenlerimizi nasıl isimlendirmemiz gerektiği hakkında biçimsel düzenlemeler var.\n",
    "\n",
    "Pythondaki isimlendirmeler için istenen kurallar gayet kolaydır:\n",
    "\n",
    "\n",
    "1. Değişkenler bir harf ya da _ alt çizgi ile başlamalı,\n",
    "2. Değişken ismindeki hatırlatma harfler, sayılar, alt çizgi içerebilir, ve\n",
    "3. Değişken isimleri özel isim olamaz.\n",
    "\n",
    "Aşağıdakilerin hepsi geçerli değişken isimleridir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "name = \"Ahmet\"\n",
    "favorite_painter = \"Da Vinci\"\n",
    "__password__ = \"1234\"\n",
    "job1 = \"Data Scientist\"\n",
    "job2 = \"Sufferer\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Aşağıdakiler ise geçersiz değişken isimleridir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-0a2f7e1765c0>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-11-0a2f7e1765c0>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    1st_name = \"Ahmet\"\u001b[0m\n\u001b[0m           ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Variable name doesn't start with a letter or underscore:\n",
    "1st_name = \"Ahmet\"\n",
    "\n",
    "# Variable name includes a disallowed character: `-`:\n",
    "my-password = \"1234\"\n",
    "\n",
    "# Variable names can't be keywords like `else`:\n",
    "else = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Programlama dilinde değişken ismi olarak \"reserved word\" kullanılmasına izin verilmez. Mesela ; pytonda True ismini ve def kelimesinin yeni bir değişkene atayamazsınız. 33 \"reserved word\" listesi için dokümanlara bakabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Bad:\n",
    "p = 0\n",
    "n = \"Guido van Rossum\"\n",
    "b_btls = 99\n",
    "\n",
    "# Good:\n",
    "position = 0\n",
    "name = \"Guido van Rossum\"\n",
    "beer_bottles = 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Veri Tipleri\n",
    "\n",
    "Değişkenler, farklı değer tiplerini temsil edilebilir. Örneğin kelimeler ve sayılar verilerin farklı tiplerindendir. Bir değişken 42 sayısına refere edebilir, ya da kırk iki kelimesine refere edebilir. Birincisi ile matematik yapabilirsiniz, fakat kırk iki den 5’i çıkarmaya çalışmak işe yaramayacaktır. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String\n",
    "Stringler, tırnak içinde verilen metinsel verilerdir. Tek tırnak ya da çift tırnak olabilir, fakat başlangıç tırnak işareti ve bitiş tırnak işareti aynı olmalı. Yani tek ise tek, çift ise çift tırnak işareti ile bitmeli. Mesela food=’pizza’ ya da food=’’pizza’’ ikisi de geçerlidir. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "The first letter is h\n",
      "The second letter is a\n",
      "3\n",
      "I like ham and eggs\n",
      "Bring me 3 shrubberies, Guido!\n"
     ]
    }
   ],
   "source": [
    "# Start by assigning a string to our variable.\n",
    "food = \"ham\"\n",
    "\n",
    "# Let's see what the built-in `type()`function does.\n",
    "type_of_food = type(food)\n",
    "print(type_of_food)\n",
    "\n",
    "# We can access the characters of a string by index with bracket\n",
    "# notation, starting at index zero.\n",
    "first_letter = food[0]\n",
    "second_letter = food[1]\n",
    "print(\"The first letter is \" + first_letter)\n",
    "print(\"The second letter is \" + second_letter)\n",
    "\n",
    "# We can use the built-in `len()` function to get a string's\n",
    "# \"length\", or the number of characters it contains.\n",
    "print(len(food))\n",
    "\n",
    "# We can concatenate two strings together into one string with\n",
    "# the `+` operator.\n",
    "superfood = food + \" and eggs\"\n",
    "print(\"I like \" + superfood)\n",
    "\n",
    "# We can fill in strings using the `.format()` string method.\n",
    "name = \"Guido\"\n",
    "cost = 3\n",
    "demand = \"Bring me {} shrubberies, {}!\"\n",
    "print(demand.format(cost, name))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sayılar: Integer ve Float Sayılar\n",
    "Sayıların pythonda iki tipi vardır: tam sayılar(integer) ve ondalıklı sayılar(float).\n",
    "\n",
    "Tam sayılar: tam sayılar bir kesir halinde ya da ondalıklı sayı halinde yazılmaz. Maksimum tam sayı büyüklüğü yoktur. Python 3 isteğe göre çok büyük sayıları yazabilir. \n",
    "\n",
    "Ondalıklı sayılar: ondalık değer içeren sayılardır. Bilgisayar biliminde ondalıklı sayılar eğlenceli konulardır. Bilgisayarlar her şeyi ikili sistemde gösterdiği için, bir çok ondalık sayı halindeki kesirleri ikili sistemde kesin olarak göstermek imkansızdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6000000000000001"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> .2 + .4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "5\n",
      "30\n",
      "1.5\n",
      "1\n",
      "9.42\n",
      "0.6000000000000001\n",
      "False\n",
      "Bring me 3 shrubberies!\n"
     ]
    }
   ],
   "source": [
    "# Start by assigning some numbers to our variables.\n",
    "count = 3\n",
    "pi = 3.14\n",
    "\n",
    "# Let's see what the built-in `type()`function does.\n",
    "type_of_count = type(count)\n",
    "type_of_pi = type(pi)\n",
    "print(type_of_count)\n",
    "print(type_of_pi)\n",
    "\n",
    "# We can do math with numbers. The `%` operator is modulo.\n",
    "print(count + 2)\n",
    "print(count * 10 )\n",
    "print(count / 2)\n",
    "print(1337 % 2)\n",
    "\n",
    "# Putting an int and a float together will give you a float.\n",
    "print(count * pi)\n",
    "\n",
    "# Be careful with floating point math.\n",
    "print(.2 + .4)\n",
    "\n",
    "# Numbers are *not* strings, even if they look similar.\n",
    "print(10 == \"10\")\n",
    "\n",
    "# Thankfully it's easy to convert numbers to strings when you\n",
    "# need to:\n",
    "\n",
    "print(\"Bring me \" + str(count) + \" shrubberies!\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean\n",
    "\n",
    "Boolean doğruluk ve yanlışlığı gösterir. Bir boolean sadece iki olası değere sahiptir: True ve False. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome Guido, loading launch codes.\n"
     ]
    }
   ],
   "source": [
    "# Here we're assigning the boolean `True` to the variable\n",
    "# `logged_in`. Try running this code, then changing True to False\n",
    "# to see how that changes the program. (Note the capital \"F\" and\n",
    "# lack of quotation marks.)\n",
    "# What happens if you change the value of `logged_in` to a number\n",
    "# or string instead of a boolean True or False?\n",
    "logged_in = True\n",
    "\n",
    "username = \"Guido\"\n",
    "\n",
    "# These are conditional statements. We'll cover these later, but\n",
    "# you might be able to make out how they're working here.\n",
    "if logged_in == True:\n",
    "    print(\"Welcome \" + username + \", loading launch codes.\")\n",
    "elif logged_in == False:\n",
    "    print(\"Sorry, I can't load the launch codes unless you log in.\")\n",
    "else:\n",
    "    print(\"Hey pal, no trying to hack the mainframe login.\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## None\n",
    "\n",
    "Stringler, sayılar ve boolean geçerli şeyleri göstermek için kullanışlı ancak bazen hiçbir şeyi de göstermek isteriz. Bu da herhangi bir değerin varlığını göstermek isteyeceğimiz anlamına gelir. Burada Python bize None (hiçbir şeyi) verir. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name?ahmet\n",
      "Fantastic, thanks ahmet\n",
      "ahmet, you are a Human who needs a profession\n",
      "Your strength is 4 and magic is 5,\n",
      "and your favorite color is Octarine\n",
      "What profession would you like?data scientist\n",
      "Welcome, ahmet. You are a Human data scientist.\n"
     ]
    }
   ],
   "source": [
    "# Let's assign some variables to start with, including `None`\n",
    "# in a couple places.\n",
    " \n",
    "name = None\n",
    "species = \"Human\"\n",
    "strength = 4\n",
    "magic = 5\n",
    "favorite_color = \"Octarine\"\n",
    "profession = None\n",
    "\n",
    "# Hm, maybe we haven't assigned a name yet...\n",
    "if name is None:\n",
    "    name = input(\"What is your name?\")\n",
    "    print(\"Fantastic, thanks {}\".format(name))\n",
    "\n",
    "# Every adventurer needs a profession.\n",
    "if profession is None:\n",
    "    print(\"{}, you are a {} who needs a profession\".format(name, species))\n",
    "    print(\"Your strength is {} and magic is {},\".format(strength, magic))\n",
    "    print(\"and your favorite color is {}\".format(favorite_color))\n",
    "    profession = input(\"What profession would you like?\")\n",
    "\n",
    "print(\"Welcome, {}. You are a {} {}.\".format(name, species, profession))\n",
    "\n",
    "# Once you've run the program go back and tweak your starting\n",
    "# variables. Does that change the program's behavior?\n",
    "\n",
    "# As a stretch goal, try setting `favorite_color` to None and\n",
    "# getting user input by copying the logic for `name` and\n",
    "# `profession`.\n",
    "\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "False (yanlış) ın ya da 0’ın ya da boş string ‘’ ‘’ ya da birçoğunun yerine ne zaman NONE kullanmanın uygun olduğu ile ilgili derin tartışmalara, düşüncelere girebilirsiniz. Bu tartışmayı şimdi burada yapmayacağız. Sadece şunu bilin ki; bir değerin eksikliğini, yokluğunu ifade etmek istediğimizde NONE kullanılır. \n",
    "\n",
    "## Veri Tiplerini Dönüştürme \n",
    "\n",
    "Bir tipin verilerini başka bir tipe dönüştürme düşüncesinin farkında olmanızı istiyoruz. Python'da string üzerinde matematiksel bir işlem yapmaya çalıştığınızda hata verir. Örneğin ‘’10’’ stringini 42 sayısından çıkarmak isterseniz hata alırsınız. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-89f1e243d532>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m42\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;34m\"10\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    ">>> 42 - \"10\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bu hata string olarak kullanmaya çalıştığınız verilerin istediğimiz işlemi desteklemediğini ifade eder. Stringi built-in int() ile tamsayıya dönüştürerek ya da built-in float() ile float sayılara dönüştürerek bu durumu düzeltebilirsiniz. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40.5"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> 42 - int(\"10\")\n",
    ">>> 42 - float(\"1.5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Benzer şekilde + operatörünü de bir string ve sayı ile kullanamayız: \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-96e6941e1278>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"Number of magic beans: \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m42\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    ">>> \"Number of magic beans: \" + 42"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bu hata yapmaya çalıştığımız işlemin tamsayı verisinde işlemi desteklemediğini anlatıyor. Tekrardan built-in str() fonksiyonu ile sayıyı string’e dönüştürerek bu hatayı düzeltebiliriz. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Number of magic beans: 42'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> \"Number of magic beans: \" + str(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Fonksiyonlar\n",
    "\n",
    "Fonksiyonlar programdaki en önemli kavramlardan biridir. Bir fonksiyon tekrar edilebilir işlem ya da davranışı tanımlar. İlk önce davranışı tanımlayın ve işlemlerinizi ne zaman olursa olsun çalıştırabilirsiniz ve tekrar baştan başlatıp çalıştırabilirsiniz. \n",
    "\n",
    "Bir örneği inceleyelim: pythondaki built-in print() fonksiyonu. Şimdiye kadar etkileşimli örneklerde birçok kez bu fonksiyonu gördünüz. Aşağıdaki yeni örneği inceleyelim. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "# Let's start by printing a classic message.\n",
    "print(\"Hello, world\")\n",
    "\n",
    "# Your turn. Edit the argument passed  in to to `print()` above\n",
    "# to see how the function output changes when you change the input\n",
    "# you give it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Yukarıdaki print() fonksiyonunda, fonksiyonun içinde geçen bir konu veya değer vardır: ‘merhaba, dünya’ dizisi fonksiyon bağlamında bir konu (veya parametre) fonksiyonun içerisinde geçen ve fonksiyonun içindeki komutla erişen bir değerdir. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Fonksiyonları Tanımlama ve Çalıştırma\n",
    "\n",
    "\n",
    "### Fonksiyon tanımları\n",
    "\n",
    "Bir fonksiyon tanımına göz atalım:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def times_two(num):\n",
    "    return num * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Def anahtar kelimesi tanımlanan fonksiyonu belirtir. Daha sonra fonksiyonun adı gelir. Bu ad bize daha sonra fonksiyona geri dönüş sağlar. \n",
    "\n",
    "Sırada fonksiyonun parametre listesi var. Bu parametreler fonksiyon çalıştığı zaman fonksiyonun ana gövdesi içine geçmesi beklenen parametrelerdir. Parametre listesi boştur veya () karakteri içindeki parametrelerden oluşur. Örneğimizde tek bir parametre var: num\n",
    "\n",
    "Son olarak fonksiyon gövdesi dönüş işlemi içerir. Hangi değerlerin çıktı olmasını ya da programın hangi parçası son olarak fonksiyonu çalıştıracak bunu anlatır. \n",
    "\n",
    "Dönüş komutları fonksiyonumuza işlemin yapılmasını ve fonksiyon kısımlarındaki talimatların çalışmasını sonlandıracağını anlatır. Bunun anlamı sizin fonksiyon içindeki dönüş komutunuzdan sonra gelen kodlar çalışmayacaktır. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "**Not**: Python'da satırbaşı yapmak (indent) çok önemlidir. İndentasyona dikkat etmezseniz kodunuz hata verecektir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Semantik bir gösterim ile satırbaşı yapma size tuhaf gelebilir, özellikle farklı bir programlama dili ile çalışıyorsanız. Örneğin aşağıdaki javascript fonksiyonunun her ikiside aynı ve geçerlidir. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "function times_two(num) {\n",
    "    return num * 2;\n",
    "}\n",
    "\n",
    "function times_two(num) {\n",
    "return num * 2;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting to execute the function body.\n",
      "Starting to execute the function body.\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "# Here we define a function and include code in the function body\n",
    "# *after* the return statement. That code won't be executed when\n",
    "# the function is called.\n",
    "\n",
    "def triple(num):\n",
    "    print(\"Starting to execute the function body.\")\n",
    "    return num * 3\n",
    "    print(\"Is this line executed?\")\n",
    "    \n",
    "# Once we've defined a function we can go ahead and execute it.\n",
    "triple(5)\n",
    "\n",
    "# What happens if you swap lines 7 and 8 above?\n",
    "\n",
    "# Line 11 above doesn't actually *do* anything with the function's\n",
    "# return value. Let's actually put our function to good use by\n",
    "# storing its return value in a variable.\n",
    "meaning_of_life = triple(14)\n",
    "\n",
    "print(meaning_of_life)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Fonksiyonları çağırma\n",
    "\n",
    "Bir fonksiyon tanımladığınızda, fonksiyonu ismi ile çağırdığınızda bir blok kodu çalıştırmış olursunuz. Fonksiyonu çağırmak için (   ) içinde olmasını istediğiniz değişkenleri de içeren fonksiyonun ismini tam olarak yazın. Yukarıdaki örnekte triple() fonksiyonunu 11. Satırda triple(5) ile çağırmıştık, daha önce 6. satırda tanımlanmıştı. Daha ayrıntılı bir örneği inceleyelim. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Here's a function that calculates and returns the variance of\n",
    "# a list of numbers. There's a lot going on here. Don't sweat the\n",
    "# details.\n",
    "\n",
    "def variance(numbers):\n",
    "    length = len(numbers)\n",
    "    mean = sum(numbers) / length\n",
    "    square_differences_from_mean = []\n",
    "    for number in numbers:\n",
    "        square_differences_from_mean.append((number - mean) ** 2)\n",
    "    sum_of_square_differences = sum(square_differences_from_mean)\n",
    "    variance = sum_of_square_differences / length\n",
    "    return variance\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "1300\n",
      "26\n"
     ]
    }
   ],
   "source": [
    "# Here is an example of a determinate function. It takes an input\n",
    "# and maps it onto a single return value. Every time you call this\n",
    "# function with the same input you'll get the same output.\n",
    "\n",
    "def double(num):\n",
    "    return num * 2\n",
    "    \n",
    "print(double(6))\n",
    "\n",
    "# Here is an example of a function that isn't  determinate. It\n",
    "# looks at data beyond the argument passed in and outputs a\n",
    "# different value depending on what's happening' with an unrelated\n",
    "# variable. \n",
    "secret_number = 100\n",
    "def multiply_by_secret(num):\n",
    "    return num * secret_number\n",
    "\n",
    "# Here we'll call and print `multiply_by_secret`.\n",
    "print(multiply_by_secret(13))\n",
    "\n",
    "# Here we'll call it again but first change the value of\n",
    "# `secret_number`. Note how line 19 and line 25 are identical but\n",
    "# produce different output.\n",
    "secret_number = 2\n",
    "print(multiply_by_secret(13))\n",
    "\n",
    "# Functions like this that can return a different value when\n",
    "# called with the same argument are not \"determinate\" functions.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Fonksiyonlarla İlgili Bazı İpuçları\n",
    "\n",
    "print() ismi çok iyi seçilmiştir. Sadece fonksiyonun adını bilmek bile bu fonksiyonun ne olduğu ile ilgili yararlı bilgiler verir. Değişkenler gibi, iyi isimlendirilmiş bir fonksiyonun ne yapmaya çalıştığını isminden anlayabiliriz.\n",
    "\n",
    "print() gibi iyi hazırlanmış fonksiyonlar tek bir sorumluluğa sahiptir. Bunun anlamı bir fonksiyon tek bir şey yapmak için yani bunu en iyi yapmak için tasarlanmış. print() in yegâne sorumluluğu kullanıcıya bilgiyi görüntülemektir. \n",
    "Fonksiyonları yazarken her birinin basit (anlaşılır) olması için çabalayın ve mümkün olduğunca buna odaklanın. Birçok farklı işlemi yapan büyük bir fonksiyona sahipseniz birkaç küçük fonksiyona ayırmanız iyi olacaktır. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stringlerle Çalışmak\n",
    "### String nedir?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "string_example = 'This is a string!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "String bir sıra karakterdir. Python'da string değerlerini çift tırnak veya tek tırnak ile değişkenlere atayabiliriz. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "spam = \"Spam!\"\n",
    "eggs = 'Eggs!'\n",
    "print(spam)\n",
    "print(eggs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Çift veya tek tırnak kullanabilirsiniz. Hatta 3 tırnak bile kullanabilirsiniz daha büyük stringler yapmak için.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "book_of_armaments = '''\n",
    "And the Lord spake, saying, \"First shalt thou take out the Holy Pin.\n",
    "Then shalt thou count to three, no more, no less.\n",
    "Three shall be the number thou shalt count, and the number of the counting shall be three.\n",
    "Four shalt thou not count, neither count thou two, excepting that thou then proceed to three.\n",
    "Five is right out.\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Stringler metni temsil ederler. Python 3'te Unicode her karakteri stringlere verebilirsiniz. Yani \"passé\", \"schöne\" ve \"ねこ\", hepsi stringlerde tutulabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Beautiful is better than ugly.\n",
      "    Explicit is better than implicit.\n",
      "    Simple is better than complex.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "# Either single or dobule quotes are fine.\n",
    "spam = \"Spam!\"\n",
    "eggs = 'Eggs!'\n",
    "\n",
    "# Python 3 has good Unicode support.\n",
    "pet = 'ねこ'\n",
    "\n",
    "# You can use strings for all sorts of textual data.\n",
    "url = 'http://www.datajarlabs.com'\n",
    "greeting = 'Hello. My name is Ahmet Ahmetoğlu...'\n",
    "\n",
    "zen = '''\n",
    "    Beautiful is better than ugly.\n",
    "    Explicit is better than implicit.\n",
    "    Simple is better than complex.\n",
    "    '''\n",
    "\n",
    "print(zen)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Özel karakterler\n",
    "\n",
    "Stringlerde özel karakterlerden önce \\ backslash karakterini kullanmak gerekir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'He said, \"Sure, let\\'s go!\"'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line = \"He said, \\\"Sure, let's go!\\\"\";\n",
    "line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Yeni satıra geçmek için (\\n), bir tab ilerlemek için (\\t) karakterlerini kullanırız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "He said, \"Sure, let's rock!\"\n",
      "FIRST\tLAST\n",
      "ahmet\tahmetoğlu\n",
      "ayşe\tayşekızı\n"
     ]
    }
   ],
   "source": [
    "# Internal quotation marks can really mess up your strings if you\n",
    "# don't escape them with a backslash.\n",
    "\n",
    "line = \"He said, \\\"Sure, let's rock!\\\"\";\n",
    "print(line)\n",
    "\n",
    "# You can also escape special characters like \\n for newline\n",
    "# and \\t for tab.\n",
    "employees = 'FIRST\\tLAST\\nahmet\\tahmetoğlu\\nayşe\\tayşekızı'\n",
    "print(employees)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stringleri birleştirme ve tekrar ettirme\n",
    "Stringler + operatörü ile birleştirilebilir. Stringi tekrar ettirmek içinse * operatörünü kullanırız.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The quick brown fox jumps over the lazy dog.\n",
      "NaNaNaNaNaNaNaNaNaNaNaNaNaNaNaNa Batman!\n",
      "123\n",
      "100100\n"
     ]
    }
   ],
   "source": [
    "# Use the `+` operator to concatenate.\n",
    "beginning = 'The quick brown fox '\n",
    "end = 'jumps over the lazy dog.'\n",
    "full_sentence = beginning + end\n",
    "print(full_sentence)\n",
    "\n",
    "# Use the `*` operator to repeat.\n",
    "print('Na' * 16 + \" Batman!\")\n",
    "\n",
    "# Remember that strings aren't numbers, even when they may look like\n",
    "# numbers, so trying to do math with them won't work the way you\n",
    "# expect.\n",
    "print(\"12\" + \"3\")\n",
    "print(\"100\" * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Endeksler ve dilimleme (slicing)\n",
    "Stringin her karakteri 0'dan başlayarak endekslenir. [] ile string içindeki karakterlere ulaşılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'o'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Hello'[0]\n",
    "'Hello'[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`:` ile ayırarak aralık olarak vereceğiniz endeksleri de döndürebilirsiniz. Baştaki karakter döndürülürken, sondaki karakter döndürülmez."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Py'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Monty Python'[0:5]\n",
    "'Monty Python'[6:8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Eğer dilimleme yaparken baştaki ya da sondaki endeksi boş bırakırsak, baştan itibaren ya da sona kadar manası taşır:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Monty Python'[:5]\n",
    "'Monty Python'[6:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Negatif sayılar da endeks olarak verilebilir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Monty Python'[-1]\n",
    "'Monty Python'[-3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Stringleri karşılaştırma\n",
    "Stringlerin `==` operatorünü kullanarak aynı olup olmadığını karşılaştırabiliriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "food = 'eggs';\n",
    "breakfast = 'eggs';\n",
    "lunch = 'spam';\n",
    "food == breakfast\n",
    "breakfast == lunch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## String metodları\n",
    "Python birçok built-in string metodları sunar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'My favorite drink is cofee without sugar and milk.'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a new string with a capitalized first character.\n",
    "'hello'.capitalize()\n",
    "\n",
    "# As you read through these make a guess about what the result\n",
    "# will be, then check your guess by `print()`ing each statement\n",
    "# and running the code.\n",
    "print('hello'.capitalize())\n",
    "\n",
    "# Return a new string where all characters are lower case\n",
    "'Hello'.lower()\n",
    "'WORLD'.lower()\n",
    "\n",
    "# Check whether all characters are numeric.\n",
    "'1337'.isdecimal()\n",
    "'p2p'.isdecimal()\n",
    "\n",
    "# Check whether all characters are alpha.\n",
    "'hello'.isalpha()\n",
    "'p2p'.isalpha()\n",
    "\n",
    "# Find the index of the first occurance of a substring. \n",
    "'hello'.find('l')\n",
    "'world'.find('l')\n",
    "\n",
    "# Check the end of a string.\n",
    "'hello'.endswith('o')\n",
    "'world'.endswith('o')\n",
    "'world'.endswith('rld')\n",
    "\n",
    "# Split a string into a list of strings at each instance of a\n",
    "# substring.\n",
    "'The-quick-brown-fox'.split('-')\n",
    "\n",
    "# Join a list of strings into one single string. Try passing a\n",
    "# different string into this method.\n",
    "'_'.join(['The', 'quick', 'brown', 'fox'])\n",
    "\n",
    "# \"Format\" a string by replacing `{}` with the arguments you\n",
    "# supply to the function.\n",
    "'Player {} has {} hit points remaining'.format(1, 42)\n",
    "'My favorite drink is {} without {} and {}.'.format('cofee', \"sugar\", \"milk\")\n",
    "\n",
    "# Use the space below to play around with these methods and print\n",
    "#different things out.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "x = 8\n",
    "x - 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sayılarla çalışmak\n",
    "\n",
    "Python'da temel olarak iki tip sayı tipi vardır: tam sayı(integer) ve ondalıklı sayı(float).\n",
    "\n",
    "Python 3'te istediğiniz büyüklükte tam sayıyı tutabilirsiniz. Fakat ondalıklı sayılar en fazla 52 bit'lik bir kesinlik sağlar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.2 + 0.4 == 0.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# We can use Python as a calculator to do arithmetic. Let's do\n",
    "# some simple math with numbers and assign the results to\n",
    "# variables.\n",
    "four_plus_two = 4 + 2\n",
    "nine_minus_three = 9 - 3\n",
    "three_times_four = 3 * 4\n",
    "\n",
    "# You have two types of division: \"true division\" and\n",
    "# \"floor division\"\n",
    "true_division = 5 / 2\n",
    "floor_division = 5 // 2\n",
    "\n",
    "# The modulo operator `%` in action to get a remainder.\n",
    "remainder = 5 % 2\n",
    "\n",
    "# One way to do exponentiation is with the `**` operator.\n",
    "five_squared = 5 ** 2\n",
    "twenty_seven = 3 ** 3\n",
    "\n",
    "# You can use the built-in `type()` function to see what kind of\n",
    "# data you're dealing with. This is useful when you aren't sure\n",
    "# whether you have an int or a float.\n",
    "answer = 40 + 2\n",
    "print(type(answer))\n",
    "\n",
    "score = 6 / 2\n",
    "print(type(score))\n",
    "\n",
    "# Take a few minutes to add print statements throughout to see\n",
    "# what values are being assigned to the variables above, then\n",
    "# tinker with the numbers to see what happens.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Aritmetik operatörler\n",
    "\n",
    "1. \\+ toplama\n",
    "2. \\- çıkarma\n",
    "3. \\* çarpma\n",
    "4. / \"gerçek\" bölme\n",
    "5. // \"taban\" bölme\n",
    "6. % kalan (\"modulo\" ya da \"modulus\" olarak da bilinir)\n",
    "7. ** üstel sayı\n",
    "\n",
    "Operations can be grouped, as in Algebra, with parentheses. Python handles order of operations, or operator precedence, via PEMDAS: parentheses, exponents, multiplication/division, addition/subtraction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.0\n"
     ]
    }
   ],
   "source": [
    "print(6 / 2 * (1 + 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Atama operatörleri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "assignments_completed = 9\n",
    "assignments_completed = assignments_completed + 1\n",
    "print(assignments_completed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "1. += topla ve ata\n",
    "2. -= çıkar ve ata\n",
    "3. *= çarp ve ata\n",
    "4. /= \"gerçek\" böl ve ata\n",
    "5. //= \"taban\" böl ve ata\n",
    "6.%= kalanını al ve ata\n",
    "7. **= üstünü al ve ata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Let's demo different ways to work with numbers and assign the\n",
    "# results back to a variable. here are some numbers to start with.\n",
    "score = 99\n",
    "hit_points = 99\n",
    "level = 2\n",
    "\n",
    "# These two methods are equivalent. They both increase the value\n",
    "# assigned to the variable by one.\n",
    "score = score + 1\n",
    "hit_points += 1\n",
    "\n",
    "# Jackpot! Triple our score.\n",
    "score *= 3\n",
    "\n",
    "# Oof, got hit for twenty damage.\n",
    "hit_points -= 20\n",
    "\n",
    "# Advance a level.\n",
    "level += 1\n",
    "\n",
    "# Think about what the values assigned above should be and insert\n",
    "# print statements at different parts of the program to confirm\n",
    "# your guesses.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Not:__ Birçok proglama dilinin aksine Python'da ++ ve -- operatörleri yoktur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sayıları karşılaştırma\n",
    "\n",
    "1. < küçüktür\n",
    "2. <= küçük eşittir\n",
    "3. \\> büyüktür\n",
    "4. \\>= büyük eşittir\n",
    "5. == eşittir\n",
    "6. != eşit değildir\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Using comparson operators with numbers.\n",
    "print(1 < 2)\n",
    "print(1 <= 2)\n",
    "print(2 <= 2)\n",
    "print(3 <= 2)\n",
    "print(1 == 1)\n",
    "print(1 == 2)\n",
    "print(1 != 2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Kıyaslamanın sonucu booleandır: True ya da False.\n",
    "\n",
    "#### Built-in matematik metodları\n",
    "Burada üzerinden geçmeyeceğiz fakat Python'da **math** modülünün içinde birçok built-in matematik metodu bulunur. Örn: math.floor(), math.sqrt(), math.pi ve math.e gibi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mantıksal ifadeler\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python'da \"gerçek\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Basics.\n",
    "print(bool(True))\n",
    "print(bool(False))\n",
    "\n",
    "# Numbers and strings evaluate to True.\n",
    "print(bool(1))\n",
    "print(bool(2))\n",
    "print(bool(-1))\n",
    "print(bool('Hello'))\n",
    "print(bool('    '))\n",
    "\n",
    "# Except for 0 and empty string ''.\n",
    "print(bool(0))\n",
    "print(bool(''))\n",
    "\n",
    "# Collections evaluate to True.\n",
    "print(bool([1, 2, 3]))\n",
    "print(bool({'arms': 2, 'legs': 2, 'sword': None}))\n",
    "\n",
    "# Except for empty collections.\n",
    "print(bool([]))\n",
    "print(bool({}))\n",
    "\n",
    "# `None` acts as you might expect.\n",
    "print(bool(None))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Herhangi birşeyi temsil eden herşey True'dur. Hiçbirşeyi temsil eden herşey False'tur:\n",
    "\n",
    "1. False\n",
    "2. None\n",
    "3. 0\n",
    "4. empty string ''\n",
    "5. empty list []\n",
    "6. empty dictionary {}\n",
    "Yukarıdakiler dışında birşeyle çalışıyorsanız bilin ki o True'dur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mantıksal operatörler\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and True\n",
    "True and False\n",
    "False and True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "0\n",
      "None\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "# Basics.\n",
    "print(False and False)\n",
    "print(False and True)\n",
    "print(True and False)\n",
    "\n",
    "# When an `and` expression evaluates to False, what are we\n",
    "# actually returning?\n",
    "print(True and 0)\n",
    "print(None and True)\n",
    "print({} and '')\n",
    "\n",
    "# Can you guess what these values will be before you print them?\n",
    "collection = [] and {}\n",
    "number = 1 and (0 and 2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Aslında olan şu:\n",
    "x and y ifadesi ilk olarak x'e bakar. Eğer 'x' False ise, x döndürülür. Değilse, y'ye bakar ve y döndürülür.\n",
    "\n",
    "Mantıksal `or` operatörü ise şöyledir: Eğer x True ise, x döndürülür. Değilse, y'ye bakılır ve ye döndürülür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ">>> True or False\n",
    "True\n",
    ">>> False or True\n",
    "True\n",
    ">>> True or True\n",
    "True\n",
    ">>> False or False\n",
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "Chocolate\n",
      "Phew!\n",
      "3\n",
      "Hello\n",
      "0\n",
      "[]\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "# `or` expressions only need one side to be `True`, so if the\n",
    "# first expression is true that's what is returned.\n",
    "print(1 or 2)\n",
    "print(1 or False)\n",
    "print('Chocolate' or 'Vanilla')\n",
    "\n",
    "# If the first expression evaluates to `False` then an `or`\n",
    "# expression moves to the second expression and returns that,\n",
    "# no matter whether the second value evaluates to `True` or\n",
    "# 'False'.\n",
    "print(False or \"Phew!\")\n",
    "print(0 or 3)\n",
    "print([] or \"Hello\")\n",
    "\n",
    "print('' or 0)\n",
    "print(0 or [])\n",
    "print(None or {})\n",
    "\n",
    "# Can you guess what's going on here before printing?\n",
    "example = False or (\"Hmm...\" or None)\n",
    "name = '' or {} or []\n",
    "logged_in = name or 'Guido'\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "\n",
    "Son olarak mantıksal `not` operatorü vardır:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Here we use `not` to evaulate and return the boolean opposite of\n",
    "# some expressions.\n",
    "print(not True)\n",
    "print(not False)\n",
    "print(not \"Hello!\")\n",
    "print(not 0)\n",
    "print(not 1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Kontrol akışı ve şart ifadeleri\n",
    "Kontrol akışı programın farklı direktifleri koşul ifadelerine göre nasıl işlediğini ifade eder. Biz burada, kısaca if, elif, else ve try, except ifadelerine bakacağız.\n",
    "\n",
    "### Şartlı ifadeler: if, elif, else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def greet_admin(user):\n",
    "    if user == \"Ahmet\":\n",
    "        return \"Welcome, Ahmet.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "İlk koşulu if ifadesinden sonra yazarız. Daha sonra istediğimiz kadar elif ifadesini koşullarıyla beraber yazabiliriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def greet_admin(user):\n",
    "    if user == \"Ahmet\":\n",
    "        return \"Welcome, Ahmet.\"\n",
    "    elif user == \"Ayşe\":\n",
    "        return \"Welcome, Ayşe.\"\n",
    "    elif user == \"Hagi\":\n",
    "        return \"Welcome, Hagi.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sonda kullanacağımız else ifadesi üssteki hiçbir koşulun sağlanmaması durumunda çalıştırılacak kod bloğunu ifade eder:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Welcome, Ahmet.\n",
      "Welcome, Ayşe.\n",
      "Alex! You are not authorized.\n"
     ]
    }
   ],
   "source": [
    "# Here is the full if, elif, else conditional statement.\n",
    "def greet_admin(user):\n",
    "    if user == \"Ahmet\":\n",
    "        return \"Welcome, Ahmet.\"\n",
    "    elif user == \"Ayşe\":\n",
    "        return \"Welcome, Ayşe.\"\n",
    "    elif user == \"Hagi\":\n",
    "        return \"Welcome, Hagi.\"\n",
    "    else:\n",
    "        return user + \"! You are not authorized.\"\n",
    "\n",
    "print(greet_admin(\"Ahmet\"))\n",
    "print(greet_admin(\"Ayşe\"))\n",
    "print(greet_admin(\"Alex\"))\n",
    "\n",
    "# Try inserting additional elif statements and changing the\n",
    "# conditions that are being checked and printing the results."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## try ve except\n",
    "\n",
    "İstinsa (exception) durumlarında çalıştırılması gereken kodları try ve except ifadeleriyle ifade ederiz. try ifadesinin içerine yazdığımız kod bloğu eğer istisna oluşturursa, yazdığımız except bloğu ile programa ne yapması gerektiğini dikte ederiz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 IS EVEN\n",
      "3.414 IS NOT AN INTEGER!\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "not all arguments converted during string formatting",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-64-071b79758c66>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0;31m# Uh oh. Someone passed in a string <_<\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 18\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0meven_or_odd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Chaos Monkey\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-64-071b79758c66>\u001b[0m in \u001b[0;36meven_or_odd\u001b[0;34m(num)\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# or odd.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0meven_or_odd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0;32mif\u001b[0m \u001b[0mnum\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;34m\"{} IS EVEN\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mnum\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: not all arguments converted during string formatting"
     ]
    }
   ],
   "source": [
    "# Here we define a function to check whether an integer is even\n",
    "# or odd.\n",
    "def even_or_odd(num):\n",
    "    if num % 2 == 0:\n",
    "        return \"{} IS EVEN\".format(num)\n",
    "    elif num % 2 == 1:\n",
    "        return \"{} IS ODD\".format(num)\n",
    "    else:\n",
    "        return \"{} IS NOT AN INTEGER!\".format(num)\n",
    "\n",
    "# Everything works fine when you pass an integer in as expected.\n",
    "print(even_or_odd(42))\n",
    "\n",
    "# Floats are fine too.\n",
    "print(even_or_odd(3.414))\n",
    "\n",
    "# Uh oh. Someone passed in a string <_<\n",
    "print(even_or_odd(\"Chaos Monkey\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42 modulo 5 is 2\n",
      "3.414 modulo 5 is 3.414\n",
      "Chaos Monkey isn't even a number!\n"
     ]
    }
   ],
   "source": [
    "# Here's another function that expects a number. Let's use a\n",
    "# try / except statement to handle situations where we get\n",
    "# something weird.\n",
    "def modulo_five(num):\n",
    "    try:\n",
    "        result = num % 5\n",
    "        return \"{} modulo 5 is {}\".format(num, result)\n",
    "    except TypeError:\n",
    "        return \"{} isn't even a number!\".format(num)\n",
    "    \n",
    "\n",
    "# Everything works fine when you pass an integer in as expected.\n",
    "print(modulo_five(42))\n",
    "\n",
    "# Floats are fine too.\n",
    "print(modulo_five(3.414))\n",
    "\n",
    "# Yay, we're properly handling exceptions and using themto\n",
    "# control which code is executed.\n",
    "print(modulo_five(\"Chaos Monkey\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Not:__Try / except ifadeleri programda oluşan istisna durumlarında programınızın çalışmasını sağlarlar. Aksi halde, programınız istisna alırsa durur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listeler: List\n",
    "Python'da veri koleksiyonunu tutmak için `list` yapılarını sunar:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello', 42, 3.414, True, None]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['Hello', 42, 3.414, True, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "List, her tipten değişkenleri tutabilir. Hatta, bir list'in içine birden fazla tip veri de koyabilirsiniz. Listeler, başka listeleri de tutabilir. Bu durumda, çok boyutlu bir matris oluşturmuş oluruz.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['X', 'O', 'X'], ['O', 'X', '0'], ['X', 'O', 'X']]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[['X', 'O', 'X'], ['O', 'X', '0'], ['X', 'O', 'X']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Liste oluşturma\n",
    "Boş bir liste oluşturmak için [] ifadesini kullanırırz. Eğer köşeli parantezlerin içine virgül (,) ile ayrılmış değerler koyarsak listeyi doldurmuş oluruz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "empty_list = []\n",
    "letters = ['a', 'b', 'c', 'd']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Liste oluşturmak için değerlerini dönebildiğiniz (stringler gibi) nesneleri list()'e argüman olarak verebiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(\"Hello\")\n",
    "list(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List elemanlarına ulaşma ve güncelleme\n",
    "Köşeli parantez [] kullanıp endeks numaraları ile listenin elemanlarına ulaşabiliriz. Unutulmamalı ki ilk elemanın endeksi her zaman 0'dır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first thing is 'cats'.\n"
     ]
    }
   ],
   "source": [
    "all_the_things = ['cats', 'dogs', 42, ['pizza', 'beer'], True]\n",
    "first_item = all_the_things[0]\n",
    "print(\"The first thing is '{}'.\".format(first_item))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Benzer söz dizimini listenin elemanlarını güncellerken de kullanırız. Aşağıdaki örneği inceleyelim:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bears\n"
     ]
    }
   ],
   "source": [
    "all_the_things = ['cats', 'dogs', 42, ['pizza', 'beer'], True]\n",
    "all_the_things[0] = 'bears'\n",
    "print(all_the_things[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Listeleri dilimleme\n",
    "Stringlerde gördüğümüz gibi bir listenin elemanlarını köşeli parantez içine `:` ile ayrılmış endeksler vererek dilimleyebiliriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Monty'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Monty Python'[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "[42, 43]\n",
      "[43, 44, 45]\n",
      "[42, 43]\n",
      "[45, 46]\n"
     ]
    }
   ],
   "source": [
    "# Here we create a list with square brackets.\n",
    "id_numbers = [ 42, 43, 44, 45, 46]\n",
    "\n",
    "# We can access one item in a list at a time using bracket\n",
    "# notation and zero-indexing.\n",
    "print(id_numbers[0])\n",
    "\n",
    "# To access multiple items in a list at a time we create a slice\n",
    "# of the list using bracket notation and two indices.\n",
    "first_two = id_numbers[0:2]\n",
    "middle_three = id_numbers[1:4]\n",
    "\n",
    "print(first_two)\n",
    "print(middle_three)\n",
    "\n",
    "# Just like with string slicing, you can omit one of the index\n",
    "# numbers (or both, if you like to live on the edge) when slicing\n",
    "# and Python will provide reasonable defaults from the beginning\n",
    "# or end of the list.\n",
    "also_first_two = id_numbers[:2]\n",
    "fourth_to_end = id_numbers[3:]\n",
    "\n",
    "print(also_first_two)\n",
    "print(fourth_to_end)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Dikkat edilmesi gereken bir nokta, dilimleme orjinal listeyi modifiye etmez. Bunun yerine yeni bir liste döndürür!\n",
    "\n",
    "## Built-in len() fonksiyonu\n",
    "Bir listenin kaç elemanı olduğunu Python'ın built-in len() fonksiyonu ile öğrenebiliriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c', 'd']\n",
    "print(len(letters))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Bilinmesi gereken liste metodları\n",
    "Aşağıda bilinmesi gerektiğini düşündüğümüz önemli liste metodlarından bazılarını ele alalım:\n",
    "### .append()\n",
    "Bu metod, listeye yeni bir değer eklemek için kullanılır.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e']\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c', 'd']\n",
    "letters.append('e')\n",
    "print(letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### .insert()\n",
    "Bu metod ise, listenin herhangi bir pozisyonuna yeni bir değer eklemek için kullanılır. İki argüman ile çağrılır: değeri eklemek istediğiniz endeks ve değer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['one', 'two', 'three', 'four']\n"
     ]
    }
   ],
   "source": [
    "numbers = ['one', 'two', 'four']\n",
    "numbers.insert(2, 'three')\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### .pop()\n",
    "Bu metod .append() metodunun tersidir. Yani listenin sonundaki elemanı listeden çıkarır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Change light bulb\n",
      "['Conquer world', 'Install Linux']\n"
     ]
    }
   ],
   "source": [
    "to_do = [\"Conquer world\", \"Install Linux\", \"Change light bulb\"]\n",
    "current_task = to_do.pop()\n",
    "print(current_task)\n",
    "print(to_do)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### .index()\n",
    "Bu metod, argüman olarak verilen elemanın listede karşılaşılan ilk endeksini verir. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fowl = ['duck', 'duck', 'goose', 'duck']\n",
    "fowl.index('duck')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### .sort()\n",
    "Bu metod, listeyi sıralamak için kullanılır. Bu metod bir liste üzerinde çağrılırsa, orjinal liste modifiye edilmiş olur:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['apple', 'banana', 'boat', 'car']\n"
     ]
    }
   ],
   "source": [
    "words = ['car', 'boat', 'apple', 'banana']\n",
    "words.sort()\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Döngüler\n",
    "\n",
    "Döngü, bir direktif kümesini tekrarlamak için kullanılan yapılara denilir.\n",
    "\n",
    "## for döngüsü\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Ahmet\n",
      "Hello Ayşe\n",
      "Hello Hagi\n"
     ]
    }
   ],
   "source": [
    "names = [\"Ahmet\", \"Ayşe\", \"Hagi\"]\n",
    "for name in names:\n",
    "    greeting = \"Hello \" + name\n",
    "    print(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There's no place like home.\n",
      "There's no place like home.\n",
      "There's no place like home.\n"
     ]
    }
   ],
   "source": [
    "names = [\"Ahmet\", \"Ayşe\", \"Hagi\"]\n",
    "for name in names:\n",
    "    print(\"There's no place like home.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Listelerin yanında, for döngüsü stringler ve range'ler ile de çalışır:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Z\n",
      "ü\n",
      "c\n",
      "c\n",
      "a\n",
      "c\n",
      "i\n",
      "y\n",
      "e\n",
      "n is: 0\n",
      "n is: 1\n",
      "n is: 2\n",
      "n is: 3\n",
      "n is: 4\n",
      "n is: 5\n",
      "n is: 6\n",
      "n is: 7\n",
      "n is: 8\n",
      "n is: 9\n",
      "name\n",
      "role\n",
      "age\n",
      "[0, 2, 4, 6, 8]\n",
      "[1, 9, 25, 49, 81]\n"
     ]
    }
   ],
   "source": [
    "# Let's try for loops with other sequences and collections. Some\n",
    "# of these may be new to you.\n",
    "\n",
    "# Strings.\n",
    "for character in \"Züccaciye\":\n",
    "    print(character)\n",
    "    \n",
    "# Ranges.\n",
    "for n in range(10):\n",
    "    print(\"n is: {}\".format(n))\n",
    "    \n",
    "# Dictionaries (more on these later).\n",
    "user = {\n",
    "    \"name\": \"Ahmet\",\n",
    "    \"role\": \"kodaman\",\n",
    "    \"age\": 35\n",
    "}\n",
    "\n",
    "for property in user:\n",
    "    print(property)\n",
    "    \n",
    "# We can also do more than just print things.\n",
    "even_numbers = []\n",
    "odd_squares = []\n",
    "\n",
    "for n in range(10):\n",
    "    if n % 2 == 0:\n",
    "        even_numbers.append(n)\n",
    "    else:\n",
    "        odd_squares.append(n ** 2)\n",
    "\n",
    "print(even_numbers)\n",
    "print(odd_squares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "`Not`: Eğer C benzeri bir programlama arkaplanından geliyorsanız, for döngüsünün içinde endeks olmaması size şaşırtıcı gelmiş olabilir. Eğer o sırada hangi endekste çalıştığınızı görmek isterseniz built-in enumarate() metodunu kullanabilirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## while döngüsü\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "12\n",
      "6\n",
      "After removing factors of two, the number is 3\n",
      "what is the password12\n",
      "what is the password12\n",
      "what is the passwordbreak\n",
      "Yup.\n"
     ]
    }
   ],
   "source": [
    "# Here we'll see a while loop in action.\n",
    "n = 24\n",
    "while n % 2 == 0:\n",
    "    print(n)\n",
    "    n = n // 2\n",
    "\n",
    "# Now that our loop is done, let's see the result.\n",
    "message = \"After removing factors of two, the number is {}\"\n",
    "print(message.format(n))\n",
    "\n",
    "while True:\n",
    "    password = input(\"what is the password\")\n",
    "    if password == 'break':\n",
    "        print(\"Yup.\")\n",
    "        break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your age?35\n",
      "Fantastic, thank you!\n"
     ]
    }
   ],
   "source": [
    "# We'll use the built-in input() function to get input from a\n",
    "# user, repeating until we get a valid integer as input.\n",
    "\n",
    "age = None\n",
    "while not isinstance(age, int):\n",
    "    try:\n",
    "        age = int(input(\"What is your age?\"))\n",
    "    except ValueError:\n",
    "        print(\"Sorry, we were expecting an integer. Try again.\")\n",
    "    \n",
    "print(\"Fantastic, thank you!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`break` anahtar kelimesi bir döngüyü sonlandırır (for ya da while döngüsü için de geçerli):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "64\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while True:\n",
    "    n = n * 2\n",
    "    if n > 32:\n",
    "        break\n",
    "print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sözlükler (Dictionary)\n",
    "\n",
    "Sözlükler anahtar:değer eşleşmesi şeklinde veri tutan yapılardır. Eğer json formatına aşinaysanız, json'ın Python'daki veri yapısı karşılığı gibi düşünebilirsiniz.\n",
    "\n",
    "Bir sözlük oluşturmak için { } sembolleri kullanılır:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "greetings = {\n",
    "    \"english\": \"hello\",\n",
    "    \"japanese\": \"こんにちは\",\n",
    "    \"german\": \"hallo\",\n",
    "    \"hindi\": \"नमस्ते\",\n",
    "    \"leet\": \"h3ll0\",\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bir anahtar: değer ikilisine item denilir. Sözlük içindeki herbir item virgül ile birbirinden ayrılır.\n",
    "\n",
    "Sözlükteki değerlere de [] sembolleri ile ulaşılır. Fakat listelerden farklı olarak endeks yerine anahtar değerini veririz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'こんにちは'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greetings[\"japanese\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Veriyi güncellemek de benzer şekilde olur:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stock = {\"apples\": 5, \"oranges\": 2}\n",
    "stock[\"apples\"] = 20\n",
    "stock[\"oranges\"] += 1\n",
    "stock[\"apples\"]\n",
    "stock[\"oranges\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Yeni bir item oluşturmak da benzerdir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stock[\"pears\"] = 10\n",
    "stock[\"pears\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Sözlükten __del__ anahtar kelimesi ile item silebilirsiniz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'pears'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-99-4ca2a8382bef>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mstock\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"pears\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mstock\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"pears\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'pears'"
     ]
    }
   ],
   "source": [
    "del stock[\"pears\"]\n",
    "stock[\"pears\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Boolean operasyonlar\n",
    "\n",
    "`in`ve `not` operatörlerini kullanarak bir anahtarın sözlük içinde olup olmadığını kontrol edebiliriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greetings = {\n",
    "    \"english\": \"hello\",\n",
    "    \"japanese\": \"こんにちは\",\n",
    "    \"german\": \"hallo\",\n",
    "    \"hindi\": \"नमस्ते\",\n",
    "    \"leet\": \"h3ll0\",\n",
    "}\n",
    "\n",
    "\"english\" in greetings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Aşağıda sözlükler ile ilgili küçük bir egzersizi bulabilirsiniz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# As you read through the code below think about how the\n",
    "# value of dictionary items might be changing, then check\n",
    "# your understanding by printing the values out.\n",
    "\n",
    "# Populate an initial dictionary.\n",
    "stock = {\n",
    "  \"apples\": 5,\n",
    "  \"oranges\": 2,\n",
    "  \"pears\": 10,\n",
    "}\n",
    "\n",
    "# Sell some apples.\n",
    "stock[\"apples\"] -= 2\n",
    "\n",
    "# Use statements like print(stock[\"apples\"]) to check\n",
    "# the value of dictionary items along the way.\n",
    "\n",
    "# Recieve a new shipment topping up your oranges.\n",
    "stock[\"oranges\"] = 20\n",
    "\n",
    "# Begin carrying kale.\n",
    "stock[\"kale\"] = 20\n",
    "\n",
    "# Stop carrying pears.\n",
    "del stock[\"pears\"]\n",
    "\n",
    "# Check to see whether you carry pizzas\n",
    "\"pizza\" in stock\n",
    "\n",
    "# Spend a few minutes modifying the `stock` dictionary\n",
    "# and printing out the results below.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Sözlük metodları \n",
    "\n",
    "`.keys()` sözlükteki tüm anahtarları döndürür.\n",
    "\n",
    "`.values()` sözlükteki tüm değerleri döndürür.\n",
    "\n",
    "`.items()` ise sözlüktek iitemları döndürür.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['english', 'japanese', 'german', 'hindi', 'leet'])\n",
      "dict_values(['hello', 'こんにちは', 'hallo', 'नमस्ते', 'h3ll0'])\n",
      "dict_items([('english', 'hello'), ('japanese', 'こんにちは'), ('german', 'hallo'), ('hindi', 'नमस्ते'), ('leet', 'h3ll0')])\n"
     ]
    }
   ],
   "source": [
    "# Create an intial dictionary.\n",
    "greetings = {\n",
    "    \"english\": \"hello\",\n",
    "    \"japanese\": \"こんにちは\",\n",
    "    \"german\": \"hallo\",\n",
    "    \"hindi\": \"नमस्ते\",\n",
    "    \"leet\": \"h3ll0\",\n",
    "}\n",
    "\n",
    "# Use the `.keys()` method to create a list of each key.\n",
    "languages = greetings.keys()\n",
    "print(languages)\n",
    "\n",
    "# Use the `.values()` method to create a list of each value.\n",
    "translations = greetings.values()\n",
    "print(translations)\n",
    "\n",
    "# Use the `.items()` method to create a list of each key: value pair.\n",
    "pairs = greetings.items()\n",
    "print(pairs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Yukarıdaki 3 metod da listeye benzer bir obje döndürür. Ama aslında tam olarak liste değil birer view objesidir. Eğer bir liste olarak almak isterseniz built-in `list()` fonksiyonu ile bunu yapabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apples', 'oranges']"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stock = {\"apples\": 5, \"oranges\": 2}\n",
    "list(stock.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Bu view objeleri dinamik bir durum arzederler. Yani eğer sözlüğü bir şekilde modifiye ederseniz, otomatik olarak bu view objelerine de yansır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['apples', 'oranges', 'pears'])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stock = {\"apples\": 5, \"oranges\": 2}\n",
    "items_for_sale = stock.keys()\n",
    "stock[\"pears\"] = 10\n",
    "items_for_sale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Söylemekte fayda var ki sözlükler anahtar ve değerleri sıralı olarak tutmazlar. Yani hiçbir item aslında başka birisinden önce ya da sonra gelmez. Bir sözlük içindeki item, anahtar ya da değerleri print etmek isterseniz, başka başka sıralamayla karşılaşmanız olasıdır. Dolayısıyla hiçbir zaman sözlüklerdeki sıralamaya güvenmemek gerekir. Fakat sıralı bir liste elde etmek isterseniz built-in `sorted()` fonksiyonunu kullanarak bunu elde edebilirsiniz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apples', 'bananas', 'oranges']"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stock = {\"apples\": 5, \"oranges\": 2, \"bananas\": 4}\n",
    "list(sorted(stock.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Nesneler\n",
    "Python nesne tabanlı bir dildir. Dolayısıyla Python'da herşey bir nesnedir. Her nesnenin özellikleri (attributes) vardır ve bu özelliklerin değerleri bulunur. Ek olarak herbir nesnenin bir id'si ve tipi vardır. Bunlara `id()` ve `type()` fonksiyonlarıyla erişebilirsiniz. Bir nesnenin içindeki tüm özelliklerin ismine nesneyi built-in `dir()` fonksiyonuna argüman olarak geçerek ulaşabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']\n"
     ]
    }
   ],
   "source": [
    "# Let's peer beneath the surface of integers with `dir()`.\n",
    "print(dir(1))\n",
    "\n",
    "# Try swapping out the integer above with a string, boolean, list, function, or any\n",
    "# other object to see what attributes it has. Then try printing the results in\n",
    "# an easier to read format by using a for loop to print each one out at a time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "### Özellikleri kullanma\n",
    "Nesneden sonra nokta (.) koyduktan sonra özellik ismini yazarsanız o özelliğe ulaşmış olursunuz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function str.upper>"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\".upper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Nesneler içindeki metodlara da aynı şekilde ulaşılır fakat bu sefer sonuna parantezleri koymak gerekir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"hello\".upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Şu ana kadar metod ve fonksiyon kavramlarını çok kullandık, farklarını merak etmiş olabilirsiniz. Aslında __\"metod\" bir nesneye bağlanmış fonksiyonlara verilen bir addan başka birşey değildir__.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The imaginary component of 1 is 0.\n",
      "The real component of 1 is 1.\n"
     ]
    }
   ],
   "source": [
    "# We'll store 1 in a variable so we can use dot notation.\n",
    "one = 1\n",
    "\n",
    "# See if 1 has an imaginary component.\n",
    "\n",
    "print(\"The imaginary component of 1 is {}.\".format(one.imag))\n",
    "\n",
    "# Nope. Now check the real component.\n",
    "print(\"The real component of 1 is {}.\".format(one.real))\n",
    "\n",
    "# Yup, there it is.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Kendi nesnelerinizi oluşturma\n",
    "\n",
    "Python'da kendi tanımlamak istediğiniz nesneleri aşağıdaki şekilde oluşturabilirsiniz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class Quark(object):\n",
    "\n",
    "    def __init__(self, color, flavor):\n",
    "        self.color = color\n",
    "        self.flavor = flavor\n",
    "\n",
    "    baryon_number = 1 / 3\n",
    "\n",
    "    def interact(self, other_quark):\n",
    "        self.color, other_quark.color = other_quark.color, self.color\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"{} {} quark\".format(self.color, self.flavor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "q1 is a red up quark\n",
      "q2 is a blue down quark\n",
      "Now q1 is a blue up quark\n",
      "Now q2 is a red down quark\n",
      "q1 is a <class '__main__.Quark'> object\n"
     ]
    }
   ],
   "source": [
    "class Quark(object):\n",
    "\n",
    "    # This method is automatically called whenever we create a new quark.\n",
    "    # It sets the color and flavor attributes when we create an instance.\n",
    "    def __init__(self, color, flavor):\n",
    "        self.color = color\n",
    "        self.flavor = flavor\n",
    "\n",
    "    # Every quark has the same baryon number, so we set this outside the\n",
    "    # init function.\n",
    "    baryon_number = 1 / 3\n",
    "\n",
    "    # This method models the way quarks interact with one another by\n",
    "    # exchanging color.\n",
    "    def interact(self, other_quark):\n",
    "        self.color, other_quark.color = other_quark.color, self.color\n",
    "\n",
    "    # The repr method controls how the object is represented by the\n",
    "    # print() function and other representations of the object.\n",
    "    def __repr__(self):\n",
    "        return \"{} {} quark\".format(self.color, self.flavor)\n",
    "\n",
    "# Now that we have the class set up, let's call Quark() to create two\n",
    "# actual instances of quark objects.\n",
    "q1 = Quark(\"red\", \"up\")\n",
    "q2 = Quark(\"blue\", \"down\")\n",
    "\n",
    "# Print each object to see what they look like.\n",
    "print(\"q1 is a {}\".format(q1))\n",
    "print(\"q2 is a {}\".format(q2))\n",
    "\n",
    "# Test our interact() method by having q1 and q2 interact.\n",
    "q1.interact(q2)\n",
    "\n",
    "# Print them out again to see how they changed.\n",
    "print(\"Now q1 is a {}\".format(q1))\n",
    "print(\"Now q2 is a {}\".format(q2))\n",
    "\n",
    "# Test how our object deals with the built-in type() function.\n",
    "print(\"q1 is a {} object\".format(type(q1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Modüller\n",
    "Python'ın standard kütüphanesinde bir yığın özellik bulunur ve zaten bunların bir kısmını görmüş olduk. Fakat, Python dünyası oldukça geniştir. Python'la kod yazarken başkalarının yazdığı fakat standard kütüphanede olmayan modülleri kullanmak isteyeceksiniz. Örneğin, Pandas, Numpy, Matplotlib bunlardan sadece birkaçı. Python Package Index ya da kısaca \"PyPI\"dır. `pip install` ile yüklediğiniz modüller aslında buradan yüklenir.\n",
    "\n",
    "### Modülleri kod içinde kullanmak\n",
    "Standard kütüphanede olmayan modülleri kodunuzda kullanmak isterseniz import ifadesini kullanmanız gerekir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.283185307179586\n",
      "5\n",
      "San Francisco\n"
     ]
    }
   ],
   "source": [
    "# Let's import the math and the random modules.\n",
    "import math\n",
    "import random\n",
    "\n",
    "# Module attributes are accessed like any other object attribute.\n",
    "circumference = math.pi * 2\n",
    "print(circumference)\n",
    "\n",
    "# Module methods are functions and called like any other function.\n",
    "secret_number = random.choice([1, 2, 3, 4, 5])\n",
    "print(secret_number)\n",
    "\n",
    "destination = random.choice([\"Seattle\", \"New York\", \"Leipzig\", \"San Francisco\"])\n",
    "print(destination)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "### Kendi modülünüzü yazmak\n",
    "Python'da kendi modülünüzü yazmak aslında oldukça kolaydır. Sonu `.py` ile biten her dosya bir modül olarak kabul edilir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Script çalıştırmak\n",
    "Bazen yazdığınız bir modülü command line ile hızlıca çalıştırmak istersiniz. Bunun için aşağıdaki `if` ifadesini modülünüzün sonuna yazarak içinde kullanmak istediğiniz metodlarınızı vs. çağırmanız gerekir. command line'dan `python modül_ismi.py` ile çağırdığınız zaman aşağıdaki `if` ifadesi içindeki tüm kodu çalıştırmış olursunuz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "if __name__ == \"__main__\":\n",
    "    # Call functions here that you define above.\n",
    "    pass"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}