3. Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Konular\n",
    "- Dosya Islemleri\n",
    "    - open(), okuma-yazma\n",
    "- Kosul\n",
    "    - If - Elif - Else\n",
    "    - Ternary Operator\n",
    "- Donguler\n",
    "    - for\n",
    "    - range() Fonksiyonu\n",
    "    - break, continue, pass\n",
    "    - while\n",
    "- Ozel Veri Yapilari\n",
    "    - Tuple\n",
    "    - Dictionary\n",
    "    - Set\n",
    "    - Nested Structure\n",
    "- Fonksiyonlar\n",
    "    - Build-in Fonksiyonlar\n",
    "    - math Kutuphanesi\n",
    "    - random Kutuphanesi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dosya Islemleri\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is Great!\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(\"Python is Great!\", sep = \" \", end = \"\\n\", file = sys.stdout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## open()\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "dosya = open(\"deneme.txt\") # Bulundugumuz klasordeki dosyaya erisim\n",
    "dosya.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dosya2 = open(\"C:/Windows/Users/Enes/Documents/README.txt\") # Dosya konumu tamami da yazilabilir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "dosya3 = open(\"deneme.txt\", mode = 'r', encoding = 'utf-8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "<b>Mod \tAcilimi     Anlami</b>\n",
    "'r' \t'read'      Dosyayi oku. (default)\n",
    "'w' \t'write'     Dosyaya yaz. Dosya yoksa olustur, varsa sifirla.\n",
    "'a' \t'append'    Dosyaya ekle. Dosya yoksa olustur, varsa sifirmaladan devamina ekle.\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dosya = open(\"deneme.txt\", \"w\") # Yazma amaciyla dosyayi actik (icindekiler silindi)\n",
    "dosya.write(\"Python is Great!\") # Dosyaya yazdik\n",
    "dosya.close() # Yazdiktan sonra kapatyi unutmamaliyiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dosya = open(\"deneme.txt\", \"r\") # Read-only\n",
    "dosya.read() # Dosyayi komple okur\n",
    "dosya.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dosya = open(\"deneme.txt\", \"a\") # Append Mod\n",
    "dosya.write(\"Java isn't so great.\")\n",
    "dosya.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(\"deneme.txt\")\n",
    "file.read()\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"deneme.txt\") as my_file: # with ile kullanirsak close() yapmaya gerek kalmayacaktir.\n",
    "    pass\n",
    "    # Dosya islemleri"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"deneme.txt\", \"w\")\n",
    "f.write(\"ITU\\n\")\n",
    "f.write(\"YTU\\n\")\n",
    "f.write(\"ODTU\\n\")\n",
    "f.write(\"BOUN\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce at aliquet orci. Interdum et malesuada fames ac ante ipsum primis in faucibus. Donec elementum laoreet leo sed auctor. Integer magna orci, sollicitudin ac diam ac, varius tempor dolor. Nam a ipsum quis diam hendrerit feugiat vitae sit amet ante.\"\n",
    "\n",
    "with open(\"deneme.txt\", \"w\") as dosya:\n",
    "    dosya.write(my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lorem ipsum dol'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dosya = open(\"deneme.txt\")\n",
    "dosya.read(15) # 15 Karakter oku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'or sit amet,'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dosya.read(12) # Kaldigi yerden devam ederek 12 karakter oku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lorem ipsum dolor sit a'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dosya.seek(0) # Imleci 0 indexine gotur\n",
    "dosya.read(23)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dosya.tell() # Imlec suan nerede?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_string = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit.\\nFusce at aliquet orci.\\nInterdum et malesuada fames ac ante ipsum primis in faucibus.\\nDonec elementum laoreet leo sed auctor.\\nInteger magna orci, sollicitudin ac diam ac, varius tempor dolor.\\nNam a ipsum quis diam hendrerit feugiat vitae sit amet ante.\\n\"\n",
    "\n",
    "with open(\"deneme.txt\", \"w\") as dosya:\n",
    "    dosya.write(my_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lorem ipsum dolor sit amet, consectetur adipiscing elit.\\n'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dosya = open(\"deneme.txt\")\n",
    "dosya.readline() # '\\n' karakterine kadar oku"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fusce at aliquet orci.\\n'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dosya.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Interdum et malesuada fames ac ante ipsum primis in faucibus.\\n',\n",
       " 'Donec elementum laoreet leo sed auctor.\\n',\n",
       " 'Integer magna orci, sollicitudin ac diam ac, varius tempor dolor.\\n',\n",
       " 'Nam a ipsum quis diam hendrerit feugiat vitae sit amet ante.\\n']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dosya.readlines() # Tum satirlari bir listeye ekle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "listem = ['1\\n', '2\\n', '3\\n', '4\\n', '5\\n']\n",
    "with open(\"deneme.txt\", \"a\") as dosya:\n",
    "    dosya.writelines(listem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n",
      "\n",
      "Fusce at aliquet orci.\n",
      "\n",
      "Interdum et malesuada fames ac ante ipsum primis in faucibus.\n",
      "\n",
      "Donec elementum laoreet leo sed auctor.\n",
      "\n",
      "Integer magna orci, sollicitudin ac diam ac, varius tempor dolor.\n",
      "\n",
      "Nam a ipsum quis diam hendrerit feugiat vitae sit amet ante.\n",
      "\n",
      "1\n",
      "\n",
      "2\n",
      "\n",
      "3\n",
      "\n",
      "4\n",
      "\n",
      "5\n",
      "\n"
     ]
    }
   ],
   "source": [
    "dosya = open(\"deneme.txt\")\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())\n",
    "print(dosya.readline())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Kosul (If-Else)\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "yas = input(\"Enter your age:\")\n",
    "\n",
    "if(yas < 18):\n",
    "    print(\"Erisim engellendi!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(yas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "0-100 arasi sonucunuzu giriniz: 45\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kaldin\n"
     ]
    }
   ],
   "source": [
    "puan = input(\"0-100 arasi sonucunuzu giriniz:\")\n",
    "puan = int(puan)\n",
    "\n",
    "if(puan >= 50 and puan <= 100):\n",
    "    print(\"Gectin\")\n",
    "elif(puan >= 0 and puan < 50):\n",
    "    print(\"Kaldin\")\n",
    "else:\n",
    "    print(\"Hatali giris\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ternary Operator\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kaldin\n"
     ]
    }
   ],
   "source": [
    "puan = 46\n",
    "\n",
    "durum = \"Gectin\" if puan >= 50 else \"Kaldin\"\n",
    "\n",
    "print(durum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b a'dan buyuktur\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 9\n",
    "\n",
    "print(\"a b'den buyuktur\" if a > b else \"b a'dan buyuktur\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Donguler\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# for item in iterable:\n",
    "\n",
    "my_list = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "for number in my_list:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "another_list = []\n",
    "for number in my_list:\n",
    "    another_list.append(number ** 2)\n",
    "    \n",
    "print(my_list)\n",
    "print(another_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## range()\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = range(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = range(5,45,7) # range(start, stop, step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "12\n",
      "19\n",
      "26\n",
      "33\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "for x in b:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## break, continue, pass\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1000000):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "for i in range(25):\n",
    "    if(i == 18):\n",
    "        break\n",
    "    elif(i <= 6):\n",
    "        continue\n",
    "    else:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "60\n",
      "70\n",
      "80\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "# while(condition)\n",
    "\n",
    "count = 1\n",
    "while(count < 10):\n",
    "    print(count * 10)\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ozel Veri Yapilari\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuple\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List ile tek farki editlenemez. eleman ekle-sil mumkun degildir.\n",
    "\n",
    "a = (1, 2, 3)\n",
    "\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup1 = () # Bos tuple\n",
    "list1 = [] # Bos list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "tup1 = (1,2,3)\n",
    "tup2 = (9,8,7)\n",
    "\n",
    "tup3 = tup1 + tup2\n",
    "print(tup3[-2])\n",
    "\n",
    "# Geri kalan seyler list ile ayni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ('string',10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'N'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[0][4].upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.count(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.index(\"string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3]\n",
    "t = (1,2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 0, 3]\n"
     ]
    }
   ],
   "source": [
    "l[1] = 0 # Mutable\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t(1) = 0 # Hata verecektir (Immutable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionary\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {\"key1\" : \"value1\", \"key2\" : \"value2\", \"key3\" : \"value3\"} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dd = {\"Bir\":1, \"Iki\":2, \"Uc\":3, \"Dort\":4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd[\"Iki\"] # Key ile Value erisimi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name: \n",
      "Enter your age: \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " \n"
     ]
    }
   ],
   "source": [
    "name = input(\"Enter your name:\")\n",
    "age = input(\"Enter your age:\")\n",
    "\n",
    "account = {\"Name\" : name, \"Age\" : age}\n",
    "\n",
    "print(account[\"Name\"], account[\"Age\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['Bir', 'Iki', 'Uc', 'Dort'])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3, 4])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('Bir', 1), ('Iki', 2), ('Uc', 3), ('Dort', 4)])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dd.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'itu': 5000, 'ytu': 10000, 'boun': 1000, 'ktu': 50000}\n"
     ]
    }
   ],
   "source": [
    "ranking = {\"itu\":5000, \"ytu\":10000}\n",
    "# Yeni eleman ekleme\n",
    "ranking[\"boun\"] = 1000\n",
    "ranking[\"ktu\"] = 50000\n",
    "\n",
    "print(ranking)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'itu': 5000, 'ytu': 10000, 'boun': 1000}\n"
     ]
    }
   ],
   "source": [
    "del ranking[\"ktu\"]\n",
    "print(ranking)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "ranking.clear() # Dictionary icindeki herseyi siler\n",
    "del ranking # Komple dictionary'i siler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'key1': 1, 'key2': 2, 'key3': 3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in d.keys():\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in d.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in d: # d.keys() ile ayni\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for pair in d.items():\n",
    "    print(pair[0], pair[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## set\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8}\n",
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "a_kumesi = {1,2,3,4,5,6,7,8,7,5,4,5,6}\n",
    "l = [1,2,3,4,2,4,5,2] \n",
    "b_kumesi = set(l)\n",
    "# index ve siralama yoktur, ayni elemandan birden fazla icermez\n",
    "\n",
    "print(a_kumesi)\n",
    "print(b_kumesi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a_kumesi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "kume1 = set()\n",
    "kume2 = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(kume1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(kume2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "kume1.add(0)\n",
    "kume1.add(1)\n",
    "kume1.add(2)\n",
    "kume1.add(3)\n",
    "kume1.add(4)\n",
    "kume1.add(1)\n",
    "\n",
    "print(kume1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "kume1.update([5,6,7,7,6,5,4])\n",
    "print(kume1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3, 4, 5, 6, 7, '2', '0', '1'}\n"
     ]
    }
   ],
   "source": [
    "my_list = [\"0\", \"1\", \"2\"]\n",
    "kume1.update(my_list)\n",
    "\n",
    "print(kume1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "kume1.remove(0) # Elemani sil (yoksa hata verir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "kume1.discard(1) # Elemani sil (yoksa taha vermez)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "kume1.discard(\"x\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "kume1.remove(\"y\") # Hata verecektir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {0,1,2,3,4,5,6,7}\n",
    "b = {4,6,7,8,9}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 6, 7}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.intersection(b) # A kumesinin B kumesi ile kesisimi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.union(b) # A kumesinin B kumesi ile birlesimi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 5}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.difference(b) # A kumesinin B kumesinden farki"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 5, 8, 9}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.symmetric_difference(b) # A kumesinin B kumesi ile kesisiminin degili"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4, 6, 7}\n",
      "{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\n",
      "{0, 1, 2, 3, 5}\n",
      "{0, 1, 2, 3, 5, 8, 9}\n"
     ]
    }
   ],
   "source": [
    "print(a & b)\n",
    "print(a | b)\n",
    "print(a - b)\n",
    "print(a ^ b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World"
     ]
    }
   ],
   "source": [
    "str1 = \"Hello World\"\n",
    "\n",
    "for char in list(str1):\n",
    "    print(char, end=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "oWl eHrd"
     ]
    }
   ],
   "source": [
    "for char in set(str1):\n",
    "    print(char, end=\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested Structure\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, [[8, 7, 6], 0, -1, -2], 9] # Nested List\n",
    "t = ('a', 'b', ('c', 'd'), 'e') # Nested Tuple\n",
    "d = {'k1':{'k1':{'k1':{'k1':'Hello!'}}}} # Nested Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k1']['k1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k1']['k1']['k1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['k1']['k1']['k1']['k1']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fonksiyonlar\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func():\n",
    "    print(\"Merhaba Python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Merhaba Python\n"
     ]
    }
   ],
   "source": [
    "func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dogru():\n",
    "    print(\"Tebrikler\")\n",
    "    \n",
    "def yanlis():\n",
    "    print(\"Hata\")\n",
    "    \n",
    "parola = \"123456\"\n",
    "\n",
    "giris = input(\"Parolayı giriniz:\")\n",
    "\n",
    "if(parola == giris):\n",
    "    dogru()\n",
    "else:\n",
    "    yanlis()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def karekokAl(sayi):\n",
    "    return pow(sayi, 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = karekokAl(25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,4,9,16,25,36,49,64,81]\n",
    "new_list = []\n",
    "\n",
    "for num in my_list:\n",
    "    new_list.append(karekokAl(num))\n",
    "    \n",
    "print(my_list)\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "def kokAl(sayi, derece):\n",
    "    return pow(sayi,(1 / derece))\n",
    "\n",
    "print(kokAl(27,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build-in Fonksiyonlar\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<pre>\n",
    "abs()      Mutlak degeri dondur\n",
    "set()      Set veri tipine donustur\n",
    "dict()     Dictionary veri tipine donustur\n",
    "min()      Minimum degeri dondur\n",
    "max()      Maximum degeri dondur\n",
    "round()    Yuvarla\n",
    "hex()      Hexadecimal tabana cevir\n",
    "bin()      Binary tabana cevir\n",
    "oct()      Octal tabana cevir\n",
    "input()    Kullanicidan input al\n",
    "bool()     Boolean veri tipine donustur\n",
    "eval()     Hesapla\n",
    "int()      Integer'a donustur\n",
    "open()     Dosyayi ac\n",
    "str()      String'e donustur \n",
    "sum()      Listenin tum elemanlarini topla\n",
    "pow()      Kuvvet\n",
    "float()    Float'a donustur\n",
    "print()    Ekrana yazdir\n",
    "tuple()    Tuple veri tipine donustur\n",
    "len()      Eleman sayisi, Uzunlugu\n",
    "type()     Veri tipi\n",
    "list()     List veri tipine donustur\n",
    "range()    Range objesi olustur\n",
    "map()      Icine bir fonksiyon ve bir iterable alir, her bir elemana bu fonksiyonu uygular\n",
    "filter()   Icine bir fonksiyon ve bir iterable alir, fonksiyonun dondugu boolean'a gore iterable'i filtreler\n",
    "zip()      Iterablelari eslestirerek tuplelar elde eder\n",
    "</pre>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x7fb409c95438>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# map(fonksiyon, iterable) --> iterable: liste, string, range, set, tuple, dictionary\n",
    "\n",
    "def kare(sayi):\n",
    "    return sayi ** 2\n",
    "\n",
    "numbers = range(1,11)\n",
    "\n",
    "map(kare, numbers) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<filter at 0x7fb409cb5278>"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# filter(fonksiyon, iterable)\n",
    "\n",
    "def tekSayi(sayi):\n",
    "    return sayi % 2 == 1\n",
    "\n",
    "numbers = range(1,11)\n",
    "\n",
    "filter(tekSayi, numbers) # [1, 3, 5, 7, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x7fb40a04af48>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# zip(iterable1, iterable2...)\n",
    "\n",
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6]\n",
    "zip(x, y, z) # [(1, 4), (2, 5), (3, 6)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## math Kutuphanesi\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 25 ** 0.5\n",
    "b = pow(25, 0.5)\n",
    "c = math.sqrt(25)\n",
    "\n",
    "a == b == c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(math.pi / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 4\n"
     ]
    }
   ],
   "source": [
    "a = round(3.45)\n",
    "b = round(3.55)\n",
    "\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(3.45)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.floor(3.55) # int(3.55) ile ayni"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.exp(0) # e^0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(math.e) # log fonksiyonu ln'dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## random Kutuphanesi\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.33029266728868645"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.random() # 0 ile 1 arasinda bir float verir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randint(0,10) # 0 ile 10 arasinda random bir integer verir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 1, 0, 8, 3, 7, 5, 9, 6]\n"
     ]
    }
   ],
   "source": [
    "l = [0,1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "random.shuffle(l) # Karistir\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tesekkurler..."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}