20_02_2024.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "a = print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(print())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculator_1(num1,opr,num2):\n",
    "\n",
    "    if opr == \"+\":\n",
    "        print(num1 + num2)\n",
    "    elif opr == \"-\":\n",
    "        print(num1 - num2)\n",
    "    elif opr == \"x\":\n",
    "        print(num1 * num2)\n",
    "    elif opr == \"/\":\n",
    "        print(num1 / num2)\n",
    "    else:\n",
    "        print(\"Hatalı operatör girişi.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "calculator_1(5,\"+\",8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "b = calculator_1(5,\"+\",8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculator_2(num1,opr,num2):\n",
    "\n",
    "    if opr == \"+\":\n",
    "        return num1 + num2\n",
    "    elif opr == \"-\":\n",
    "        return num1 - num2\n",
    "    elif opr == \"x\":\n",
    "        return num1 * num2\n",
    "    elif opr == \"/\":\n",
    "        return num1 / num2\n",
    "    else:\n",
    "        return \"Hatalı operatör girişi.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calculator_2(5,\"+\",8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = calculator_2(5,\"+\",8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_len_1(x):\n",
    "\n",
    "    \"\"\"len fonksiyonunu beğenmediğim için kendi fonksiyonumu yazıyorum. Bu fonksiyon bir iterable ın uzunluğunu verir\"\"\"\n",
    "\n",
    "    sayaç = 0\n",
    "\n",
    "    for i in x:\n",
    "        sayaç += 1\n",
    "\n",
    "    print(sayaç)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "liste_1 = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "my_len_1(liste_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "d = my_len_1(liste_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'NoneType' object cannot be interpreted as an integer",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[13], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mlist\u001b[39m(\u001b[38;5;28;43mrange\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43md\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[1;31mTypeError\u001b[0m: 'NoneType' object cannot be interpreted as an integer"
     ]
    }
   ],
   "source": [
    "list(range(0, d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_len_2(x):\n",
    "\n",
    "    \"\"\"len fonksiyonunu beğenmediğim için kendi fonksiyonumu yazıyorum. Bu fonksiyon bir iterable ın uzunluğunu verir\"\"\"\n",
    "\n",
    "    sayaç = 0\n",
    "\n",
    "    for i in x:\n",
    "        sayaç += 1\n",
    "\n",
    "    return sayaç"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "e = my_len_2(liste_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0, e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# bir fonksiyondan gelen sonucu başka bir yerde kullanmak istiyorsak return kullanmak zorundayız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iki kenar bilgisi bilinen dik üçgenin hipotenüünü bulan fonk yazın. Daha sonra üçgenin çevresini hesaplayın."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hypo1(x, y):\n",
    "    print((x ** 2 + y ** 2) ** 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "hypo1(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'NoneType'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[19], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m çevre \u001b[38;5;241m=\u001b[39m \u001b[38;5;241;43m4\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mhypo1\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m4\u001b[39;49m\u001b[43m)\u001b[49m  \u001b[38;5;66;03m#hata verdi çünkü fonsiyonu print ile yaptık.\u001b[39;00m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'"
     ]
    }
   ],
   "source": [
    "çevre = 4 + 4 + hypo1(3,4)  #hata verdi çünkü fonsiyonu print ile yaptık."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hypo2(x, y):\n",
    "    return ((x ** 2 + y ** 2) ** 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hypo2(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "çevre = 3 + 4 + hypo2(3,4)\n",
    "çevre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 15, 5, 89, 45, 71, 45, 95, 61]\n",
      "[2, 36, 62, 52, 30, 56, 48]\n"
     ]
    }
   ],
   "source": [
    "sayılar_listesi = [1,15,2,36,5,89,45,62,52,71,30,56,45,95,61,48]\n",
    "\n",
    "odds = []\n",
    "evens = []\n",
    "\n",
    "for i in sayılar_listesi:\n",
    "\n",
    "    if i % 2 == 0:\n",
    "        evens.append(i)\n",
    "    else:\n",
    "        odds.append(i)\n",
    "print(odds)\n",
    "print(evens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "expected 'else' after 'if' expression (430138490.py, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[24], line 6\u001b[1;36m\u001b[0m\n\u001b[1;33m    (i if i % 2 == 0 for i in sayılar_listesi)\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m expected 'else' after 'if' expression\n"
     ]
    }
   ],
   "source": [
    "sayılar_listesi = [1,15,2,36,5,89,45,62,52,71,30,56,45,95,61,48]\n",
    "\n",
    "odds = []\n",
    "\n",
    "\n",
    "(i if i % 2 == 0 for i in sayılar_listesi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tek_çift_ayırıcı(liste, istek):\n",
    "\n",
    "    \"\"\"Bu fonksiyon bir listenin elemanlarını sizin isteğinize göre tekler ve ya çiftler olarak ayırır.\"\"\"\n",
    "\n",
    "    odds = []\n",
    "    evens = []\n",
    "\n",
    "    for i in liste:\n",
    "\n",
    "        if i % 2 == 0:\n",
    "            evens.append(i)\n",
    "        else:\n",
    "            odds.append(i)\n",
    "\n",
    "    if istek == \"tek\":\n",
    "        return odds\n",
    "    elif istek == \"çift\":\n",
    "        return evens\n",
    "    else:\n",
    "        print(\"hatalı istek\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 15, 5, 89, 45, 71, 45, 95, 61]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tek_çift_ayırıcı(sayılar_listesi, \"tek\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 36, 62, 52, 30, 56, 48]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tek_çift_ayırıcı(sayılar_listesi, \"çift\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hatalı istek\n"
     ]
    }
   ],
   "source": [
    "tek_çift_ayırıcı(sayılar_listesi, \"farketmez\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adın_kadar_kazan(isim):\n",
    "\n",
    "    \"\"\"Bu fonksiyon ismin içindeki sesli harfleri bulur\"\"\"\n",
    "\n",
    "    counter = 0\n",
    "\n",
    "    for i in isim.lower():\n",
    "\n",
    "        if i in \"aeiıuüoö\":\n",
    "            counter += 1\n",
    "\n",
    "    print(counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for *: 'NoneType' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[56], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43madın_kadar_kazan\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mserhan\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1000\u001b[39;49m\n",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'NoneType' and 'int'"
     ]
    }
   ],
   "source": [
    "adın_kadar_kazan(\"serhan\") * 1000   #yukarıda print ile yazıldığı için işlem yapamıyoruz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adın_kadar_kazan2(isim):\n",
    "\n",
    "    \"\"\"Bu fonksiyon ismin içindeki sesli harfleri bulur\"\"\"\n",
    "\n",
    "    counter = 0\n",
    "\n",
    "    for i in isim.lower():\n",
    "\n",
    "        if i in \"aeiıuüoö\":\n",
    "            counter += 1\n",
    "\n",
    "    return (counter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adın_kadar_kazan2(\"zehra\") * 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ödev: Kullanıcıdan aldığınız bir sayının Armstrong number olup olmadığını kontrol eden algoritmayı oluşturun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sayı' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[81], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28msum\u001b[39m([\u001b[38;5;28mint\u001b[39m(i) \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m uzunluk \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[43msayı\u001b[49m])\n",
      "\u001b[1;31mNameError\u001b[0m: name 'sayı' is not defined"
     ]
    }
   ],
   "source": [
    "sum([int(i) ** uzunluk for i in sayı])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def armstrong1(sayı):\n",
    "    sayı = int(input(\"bir sayı giriniz\"))\n",
    "    counter = 0\n",
    "\n",
    "    for i in str(sayı):\n",
    "        counter += int(i) ** len(str(sayı))\n",
    "    if counter == sayı:\n",
    "        return (f\"{sayı} armstrong bir sayıdır\")\n",
    "\n",
    "    else:\n",
    "        return (f\"{sayı} armstrong bir sayı değildir\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'153 armstrong bir sayıdır'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "armstrong1(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_armstrong(x):\n",
    "    \n",
    "    x = str(x)\n",
    "\n",
    "    uzunluk = len(x)                            #HOCANIN CEVAP\n",
    "\n",
    "    if int(x) == sum([int(i) ** uzunluk for i in x]):\n",
    "        print(f\"{x} sayısı armstrong bir sayıdır\")\n",
    "    else:\n",
    "        print(f\"{x} sayısı armstrong sayı değildir\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "153 sayısı armstrong bir sayıdır\n"
     ]
    }
   ],
   "source": [
    "find_armstrong(153)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_armstrong2(sayı):\n",
    "    counter = 0\n",
    "    for i in str(sayı):\n",
    "        counter += int(i) ** len(str(sayı))\n",
    "    if counter == sayı:\n",
    "        return (f\"{sayı} armstrong bir sayıdır\")\n",
    "\n",
    "    else:\n",
    "        return (f\"{sayı} armstrong bir sayı değildir\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'407 armstrong bir sayıdır'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_armstrong2(407)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_armstrong3(x):\n",
    "    \n",
    "    x = str(x)\n",
    "\n",
    "    uzunluk = len(x)                            #HOCANIN CEVAP\n",
    "\n",
    "    if int(x) == sum([int(i) ** uzunluk for i in x]):\n",
    "        return int(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "93084"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_armstrong3(93084)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634, 8208, 9474]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for i in range (1, 10001) if find_armstrong3(i) != None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 4,\n",
       " 5,\n",
       " 6,\n",
       " 7,\n",
       " 8,\n",
       " 9,\n",
       " 153,\n",
       " 370,\n",
       " 371,\n",
       " 407,\n",
       " 1634,\n",
       " 8208,\n",
       " 9474,\n",
       " 54748,\n",
       " 92727,\n",
       " 93084,\n",
       " 548834,\n",
       " 1741725,\n",
       " 4210818,\n",
       " 9800817,\n",
       " 9926315]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = []\n",
    "\n",
    "for i in range (1, 10000001):\n",
    "    if find_armstrong3(i) != None:\n",
    "        result.append(i)\n",
    "\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_armstrong4(x):\n",
    "    \n",
    "    x = str(x)\n",
    "\n",
    "    uzunluk = len(x)                            #HOCANIN CEVAP\n",
    "\n",
    "    if int(x) == sum([int(i) ** uzunluk for i in x]):\n",
    "        return int(x)\n",
    "    else:\n",
    "        return (f\"{x} armstrong bir sayı değildir\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'103 armstrong bir sayı değildir'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_armstrong4(103)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prime number (asal sayılar) find prime number\n",
    "# 1 ile 1000 arasındaki asal sayılar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8, asal bir sayı değildir.\n"
     ]
    }
   ],
   "source": [
    "sayı = int(input(\"Bir sayı giriniz\"))\n",
    "\n",
    "if sayı <= 1:\n",
    "    print(f\"{sayı}, asal bir sayı değildir.\")\n",
    "\n",
    "else:\n",
    "    for i in range(2, sayı):\n",
    "        if sayı % i == 0:\n",
    "            print(f\"{sayı}, asal bir sayı değildir.\")\n",
    "            break\n",
    "    else:\n",
    "        print(f\"{sayı}, asal bir sayıdır.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prime(x):\n",
    "    \n",
    "    if x <= 1:\n",
    "        print(f\"{x}, prime number değildir.\")\n",
    "\n",
    "    else:\n",
    "        for i in range(2, x):\n",
    "            if x % i == 0:\n",
    "                return (f\"{x}, prime number değildir.\")\n",
    "            else:\n",
    "                return (f\"{x}, prime number.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'8, prime number değildir.'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prime(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 sayısı asal sayı değildir\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Bir sayı giriniz.\"))\n",
    "\n",
    "if x > 1:\n",
    "    count = 0\n",
    "    for i in range(2, x):              # HOCANIN CEVAP\n",
    "        if x % i == 0:\n",
    "            count += 1\n",
    "\n",
    "    if count == 0:\n",
    "        print(f\"{x} sayısı asal sayıdır\")\n",
    "    else:\n",
    "        print(f\"{x} sayısı asal sayı değildir\")\n",
    "\n",
    "else:\n",
    "    print(\"Girilen değer 1 den büyük olmalıdır\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_prime_number(x):\n",
    "\n",
    "    \"\"\"Bu fonksiyon sayının asal sayı olup olmadığınız tespit eder\"\"\"\n",
    "    \n",
    "    if x > 1:\n",
    "\n",
    "        for i in range(2, x):\n",
    "\n",
    "            if x % i == 0:\n",
    "                print(\"sayı asal sayı değildir\")\n",
    "                break\n",
    "            else:\n",
    "                return f\"{x} sayısı asal sayıdır\"\n",
    "            \n",
    "    else:\n",
    "        return f\"girdiğini sayı {x} 1 den büyük olmalıdır.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'9 sayısı asal sayıdır'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_prime_number(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_prime_number1(x):\n",
    "    \"\"\"Bu fonksiyon sayının asal sayı olup olmadığını tespit eder\"\"\"\n",
    "    \n",
    "    if x > 1:\n",
    "        for i in range(2, x):\n",
    "            if x % i == 0:\n",
    "                print(f\"{x} sayısı asal sayı değildir\")   #HOCANIN CEVAP\n",
    "                break\n",
    "        else:\n",
    "            return f\"{x} sayısı asal sayıdır\"\n",
    "    else:\n",
    "        return f\"girilen sayı {x} 1'den büyük olmalıdır.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 sayısı asal sayı değildir\n"
     ]
    }
   ],
   "source": [
    "find_prime_number1(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_prime_number_2(x):\n",
    "\n",
    "    \"\"\"Bu fonsiyon sayının asalsayı olup olmadığını tespit eder.\"\"\"\n",
    "\n",
    "    if x > 1:\n",
    "\n",
    "        for i in range(2, x):                #HOCANIN CEVAP\n",
    "\n",
    "            if x % i == 0:\n",
    "                break\n",
    "        \n",
    "        else:    \n",
    "            return x\n",
    "            \n",
    "    else:\n",
    "        return f\"girdiğiniz sayı {x}. 1 den bütük olmalıdır\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_prime_number_2(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "find_prime_number_2(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 2,\n",
       " 3,\n",
       " 5,\n",
       " 7,\n",
       " 11,\n",
       " 13,\n",
       " 17,\n",
       " 19,\n",
       " 23,\n",
       " 29,\n",
       " 31,\n",
       " 37,\n",
       " 41,\n",
       " 43,\n",
       " 47,\n",
       " 53,\n",
       " 59,\n",
       " 61,\n",
       " 67,\n",
       " 71,\n",
       " 73,\n",
       " 79,\n",
       " 83,\n",
       " 89,\n",
       " 97]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = []\n",
    "\n",
    "for i in range(1,101):\n",
    "    if find_prime_number_2(i) != None:\n",
    "        result.append(i)\n",
    "\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}