FirstPhyton.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "FirstPhyton.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "ceP8EppMmSfW"
      ],
      "authorship_tag": "ABX9TyPwU4uxV/8L9U+YvmzOaHmU",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MineGumus/Python/blob/main/FirstPhyton.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "products = [\"Pride and Prejudice\", \"To Kill a Mockingbird\", \"The Great Gatsby\", \n",
        "\"One Hundred Years of Solitude\", \"Pride and Prejudice\", \"In Cold Blood\", \"Wide Sargasso Sea\",\n",
        "\"One Hundred Years of Solitude\", \"Brave New World\",  \"The Great Gatsby\", \"Brave New World\",\n",
        "\"I Capture The Castle\", \"Brave New World\", \"The Great Gatsby\", \"The Great Gatsby\",\n",
        "\"One Hundred Years of Solitude\", \"Pride and Prejudice\"]\n",
        "books = {}\n",
        "for i in products:\n",
        "  if i in books:\n",
        "    books[i]= books[i] + 1\n",
        "  else:\n",
        "    books[i]= 1\n",
        "for i in books:\n",
        "  if books[i] == 1:\n",
        "    print(i)\n",
        "  \n",
        "  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_iyxEtXuO6Ef",
        "outputId": "dbd1683f-10a2-4e13-8de0-97558a25696a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "To Kill a Mockingbird\n",
            "In Cold Blood\n",
            "Wide Sargasso Sea\n",
            "I Capture The Castle\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "string = input(\"Please, enter a string: \").lower()\n",
        "vowel = 0\n",
        "for i in string:\n",
        "  if i == \"a\" or i == \"e\" or i == \"i\" or i == \"o\" or i == \"u\":\n",
        "    vowel = vowel+1\n",
        "  else: \n",
        "    vowel = 0\n",
        "  if vowel == 2:\n",
        "    break\n",
        "if vowel == 0:\n",
        "  print(\"Negative\")\n",
        "else:\n",
        "  print(\"Positive\")\n",
        "   "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "v39r7NHSE4yD",
        "outputId": "83015fa1-3bd4-4e39-9695-6ab09500382b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please, enter a string: loops\n",
            "Positive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import string\n",
        "full_name = input(\"Please, enter your full name without space: \").lower()\n",
        "num = string.digits\n",
        "num2 = random.sample(num,4)\n",
        "letters = random.sample(full_name,3)\n",
        "all = letters + num2\n",
        "password = ''.join(all)\n",
        "print(password)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vECmRBVaRgQH",
        "outputId": "6404fe70-cc29-4cee-e3e5-93629ebf8e31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please, enter your full name without space: MarcSteve\n",
            "crs2714\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "[1,2,3]*3"
      ],
      "metadata": {
        "id": "P7Ss5PywYnOS",
        "outputId": "7e8a8303-f056-4be5-e03f-b11e3b8e98c4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 1, 2, 3, 1, 2, 3]"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num = list(reversed(range(10,0,-1)))\n",
        "print(num)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0bV6DjZP8DCv",
        "outputId": "e5654e84-5b7a-4730-9716-995c028dae56"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num1 = int(input(\"Please, enter the first number: \"))\n",
        "num2 = int(input(\"Please, enter the second number: \"))\n",
        "num3 = int(input(\"Please, enter the third number: \"))\n",
        "num4 = int(input(\"Please, enter the forth number: \"))\n",
        "num5 = int(input(\"Please, enter the fifth number: \"))\n",
        "all_num = [num1, num2, num3, num4, num5]\n",
        "num_max = num1\n",
        "for i in all_num:\n",
        "  if i > num_max:\n",
        "    num_max = i\n",
        "print(num_max)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fcAZ9sEn-cp_",
        "outputId": "5b49f4e5-fb4d-44d7-899d-fa1b43657192"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please, enter the first number: 34\n",
            "Please, enter the second number: 89\n",
            "Please, enter the third number: 123\n",
            "Please, enter the forth number: 456\n",
            "Please, enter the fifth number: 23\n",
            "456\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# calculating user input (5 inputs) without using max()function\n",
        "count = 0\n",
        "all_num = []\n",
        "while count < 5:\n",
        "  num = int(input(\"Please, enter the number: \"))\n",
        "  all_num.append(num)\n",
        "  count = count +1\n",
        "num_max = 0\n",
        "for i in all_num:\n",
        "  if i > num_max:\n",
        "    num_max = i\n",
        "print(num_max)\n",
        "\n",
        "    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L4-cmKxnE-YI",
        "outputId": "495ea1f7-e687-495c-a0af-1b0e42146492"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please, enter the number: 25\n",
            "Please, enter the number: 30\n",
            "Please, enter the number: 2\n",
            "Please, enter the number: 1\n",
            "Please, enter the number: 100\n",
            "100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "count=0\n",
        "array=[]\n",
        "while count < 5:\n",
        "  number= int(input('Please enter the number: '))\n",
        "  array.append(number)\n",
        "  count = count +1\n",
        "def findLargestNum(nums):\n",
        "  largest = nums[0]\n",
        "  for i in nums:\n",
        "    if i > largest:\n",
        "      largest = i\n",
        "  return largest\n",
        "print(findLargestNum(array))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RzAIPxdKE_LD",
        "outputId": "7200231e-be4b-4ba7-c3ca-53030fe64084"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter the number: 3\n",
            "Please enter the number: 6\n",
            "Please enter the number: 67\n",
            "Please enter the number: 34\n",
            "Please enter the number: 23\n",
            "67\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def my_min(*var):\n",
        "  \n",
        "  print(my_min(3,8,-9,0,12,1.2))\n"
      ],
      "metadata": {
        "id": "X1hRZD9YULf2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import csv\n",
        "with open(\"fruits.csv\",'r', newline = '', encoding = \"utf-8\") as file:\n",
        "    csv_rows = csv.reader(file, delimiter = \",\")\n",
        "    \n",
        "    for row in csv_rows:\n",
        "        print(row)"
      ],
      "metadata": {
        "id": "ej78IaaWKmYb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"fishes.py\", \"r\")\n",
        "ls1 = [\"Dolphin\", \"Whale\",\"Sharks\", \"Rays\",\"Tuna\", \"Squid\", \"Crabs\", \"Shrimps\"]\n",
        "for line in f:\n",
        "  for i in ls1:\n",
        "    if i in line:\n",
        "      print(i, \"is in!\")\n",
        "# else:\n",
        "   #   print(i, \"is not in!\")\n",
        "     \n",
        "f.close()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rgbNbBxrEROs",
        "outputId": "34e78919-297a-430e-881d-7c5abe46a464"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Dolphin is in!\n",
            "Whale is in!\n",
            "Sharks is in!\n",
            "Rays is in!\n",
            "Tuna is in!\n",
            "Squid is in!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = ['Banana', 'Orange', 'Apple', 'Strawberry', 'Cherry']\n",
        "with open(\"fruits.txt\",\"w\") as new_file:\n",
        "  for i in fruits:\n",
        "    new_file.write(i + \"\\n\")\n",
        "with open(\"fruits.txt\",\"r\") as new_file:\n",
        "    print(new_file.read())\n",
        "with open(\"fruits.txt\",\"r\") as new_file:\n",
        "  fruits2 = new_file.readlines()\n",
        "fruits\n",
        "with open(\"fruits2.txt\", \"w\", encoding = \"utf-8\") as ff :\n",
        "  ff.writelines(fruits2)\n",
        "with open(\"fruits2.txt\", \"r\", encoding = \"utf-8\") as ff :\n",
        "  print(ff.read())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "98z3baF45s9v",
        "outputId": "32e1ef45-8dd5-46c3-b253-eb5be5c90140"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Banana\n",
            "Orange\n",
            "Apple\n",
            "Strawberry\n",
            "Cherry\n",
            "\n",
            "Banana\n",
            "Orange\n",
            "Apple\n",
            "Strawberry\n",
            "Cherry\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"mine2.txt\", \"w\") as file:\n",
        "  file.write(\"This is my first file.\")\n",
        "with open(\"mine2.txt\", \"r\") as file:\n",
        "  print(file.read())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bacjT1Nc3NG9",
        "outputId": "74d08960-20de-4170-d323-b644baddd5fe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is my first file.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pwd"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7PVuwl35gc80",
        "outputId": "91f3ebb9-22b8-4345-96f9-8cea208c6889"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rumi = open(\"fishes.py\", \"r\")\n",
        "print(rumi.readline())\n",
        "print(rumi.readlines())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vGDBnNUICRiH",
        "outputId": "e6507477-31d7-41d4-a775-ff95257ce79b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Orca is a kind of Dolphin.\n",
            "\n",
            "['Blue Whale is the largest animal known on earth.\\n', 'Sharks are the sister group to the Rays (batoids).\\n', 'The Tuna Fish can weigh up to 260 kg.\\n', 'Squid and Octopus are in the same class.']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rumi = open(\"fishes.py\", \"r\")\n",
        "print(rumi.readlines()[2])\n",
        "rumi.seek(0)\n",
        "print(rumi.read())\n",
        "rumi.seek(0)\n",
        "print(rumi.readlines()[1])\n",
        "rumi.close()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nOU1gpP0v4gf",
        "outputId": "b1abf42a-b58f-4ac5-9650-d20b083f55e4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sharks are the sister group to the Rays (batoids).\n",
            "\n",
            "Orca is a kind of Dolphin.\n",
            "Blue Whale is the largest animal known on earth.\n",
            "Sharks are the sister group to the Rays (batoids).\n",
            "The Tuna Fish can weigh up to 260 kg.\n",
            "Squid and Octopus are in the same class.\n",
            "Blue Whale is the largest animal known on earth.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rumi = \"Orca is a kind of Dolphin. Blue Whale is the largest animal known on earth. Sharks are the sister group to the Rays (batoids). The Tuna Fish can weigh up to 260 kg. Squid and Octopus are in the same class.\"\n",
        "print(len(rumi))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tltWIM_w17vI",
        "outputId": "45895223-60ec-4f51-ad51-0a9c6a57c73c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "205\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "file = open('mine.txt', 'r')\n",
        "print(file.read(35))\n",
        "print(file.read(13))\n",
        "print(file.tell())\n",
        "file.seek(15)\n",
        "print(file.read(21))\n",
        "file.close()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EHB_9kTTfKHL",
        "outputId": "43deaffa-73a3-4764-fcc8-70bb72165ac7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I want to sing\n",
            "Like the birds sing,\n",
            "\n",
            "Not worrying\n",
            "48\n",
            "Like the birds sing,\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f=lambda x:bool(x%2)\n",
        "print(f(20), f(21))"
      ],
      "metadata": {
        "id": "p-zpZr8QSdde",
        "outputId": "21e8619e-0530-462d-d7db-31a0b71d9426",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "num = 2013\n",
        "reversed_num = 0\n",
        "while num != 0:\n",
        " digit = num % 10\n",
        " reversed_num = reversed_num * 10 + digit\n",
        " num //= 10\n",
        "print(reversed_num)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tCczjKHmQ5oa",
        "outputId": "8270214c-29e6-438f-b5da-f5edc1e5dbb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3102\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "count = 0\n",
        "my_string = \"Clarusway\"\n",
        "my_char = \"a\"\n",
        "for i in my_string:\n",
        " if i == my_char:\n",
        "  count += 1\n",
        "print(count)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KUIzEQsaQUo6",
        "outputId": "8678a061-5c50-4626-c31d-3381f3e2ce40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def foo(fname, val):\n",
        " print(fname(val))\n",
        "foo(max, [1, 2, 3])\n",
        "foo(min, [1, 2, 3])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EP8pN2kqP4dO",
        "outputId": "7ff23473-10e0-4006-a91a-ed014ef83142"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def san(x):\n",
        " print(x+1)\n",
        "x=-2\n",
        "x=4\n",
        "san(12)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WplZ7iHbPnMv",
        "outputId": "371b60cd-5e86-4d96-ef66-8e0c07401220"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rumi = open('/content/sample_data/rumi.txt', 'r')\n",
        "print(rumi.read(36))\n",
        "# rumi.seek(0)\n",
        "rumi.tell()\n",
        "rumi.close()\n",
        "# rumi.read() # acik ollp olmadigini anlamak icin kullaniyoruz."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1hVmUsa50rUd",
        "outputId": "8956c084-ec59-447b-9cb4-bbd7b233c720"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I want to sing\n",
            "Like the birds sing,\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f = open('/content/sample_data/text.py', 'r')\n",
        "fr = f.read(25)\n",
        "# print(type(f))\n",
        "print(fr)\n",
        "print(\"*********\")\n",
        "print(f.seek(0)) # kurserin ilk okumayi yaptiktan sonra tekrar nereye donmesi gerektigini gosteriyor.\n",
        "print(f.tell())\n",
        "f.close()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mkadhVjahwr_",
        "outputId": "dd90cc83-3404-4286-ec08-7b8bf03fe4f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Orca is a kind of Dolphin\n",
            "*********\n",
            "0\n",
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pwd"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "65ISrILgZADL",
        "outputId": "98097123-b62d-4ad1-96d3-0350d3862419"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'/content'"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def front_back(word):\n",
        "  if word > word[0]:\n",
        "    word = word[-1] + word[1:-1] + word[0]\n",
        "    return word\n",
        "  else:\n",
        "    return word\n",
        "print(front_back(\"ayhan\"))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i6eaYV21Hsvp",
        "outputId": "139504ef-f444-4dcd-d6ae-13b3536be5ee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nyhaa\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "veri = [\"a\", \"b\", True, (False, 1), {\"1\" : 2}, [1,2], {\"2\" : \"two\"}, {2, \"3\"}, \"c\", 23, 0]\n",
        "dict1 = {}\n",
        "for i in veri:\n",
        "  if type(i).__name__ in dict1:\n",
        "    dict1[type(i).__name__] += 1\n",
        "  else:\n",
        "    dict1[type(i).__name__] = 1\n",
        "print(dict1)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ppdlvEjiecho",
        "outputId": "354d0b64-a192-4d63-be32-366082790e32"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'str': 3, 'bool': 1, 'tuple': 1, 'dict': 2, 'list': 1, 'set': 1, 'int': 2}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = [\"banana\", \"mango\", \"pear\", \"apple\", \"kiwi\", \"grape\"]\n",
        "right = 3\n",
        "while right > 0 :\n",
        "  print(f\"You have {right} rights.\")\n",
        "  try :\n",
        "    sen = int(input(\"write a index number: \"))\n",
        "    print(\"My favorite fruit is {}\".format(fruits[sen]))\n",
        "  except IndexError :\n",
        "    right -= 1\n",
        "    print(\"Please, enter valid index number.\")\n",
        "    # print(\"You have \", right,\"rights left.\")\n",
        "  except ValueError:\n",
        "    right -= 1\n",
        "    print(\"Please, enter valid value type.\")\n",
        "    # print(\"You have \", right,\"rights left.\")\n",
        "  else:\n",
        "    print(\"Congratulations, you have entered valid number.\")\n",
        "    break\n",
        "  finally:\n",
        "    print(\"My fruits are always fresh.\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i59ZC6I-OrO4",
        "outputId": "4fe28515-1b6c-4a1c-f7af-5fe97a4f4a82"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "You have 3 rights.\n",
            "write a index number: 5\n",
            "My favorite fruit is grape\n",
            "Congratulations, you have entered valid number.\n",
            "My fruits are always fresh.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sen = input(\"Write a sentence: \")\n",
        "dic = {}\n",
        "for i in sen:\n",
        "  if i in dic:\n",
        "    dic[i] = dic[i] + 1\n",
        "  else:\n",
        "    dic[i] = 1\n",
        "print(dic)\n",
        "print\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gUPZ_-T2JNiQ",
        "outputId": "07268146-80b9-4486-a672-dfc964b6b5ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write a sentence: hhhggytvvccxz ./''\n",
            "{'h': 3, 'g': 2, 'y': 1, 't': 1, 'v': 2, 'c': 2, 'x': 1, 'z': 1, ' ': 1, '.': 1, '/': 1, \"'\": 2}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def function1(var1=5, var2=7):\n",
        " var2=9\n",
        " var1=3\n",
        " print (var1, \" \", var2)\n",
        "function1(10,12)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VUlADA_MWDRd",
        "outputId": "0c2dfeec-2f95-4d08-a72a-63892b6c38af"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3   9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 50\n",
        "def func(x):\n",
        "  print('x is', x)\n",
        "  x = 2\n",
        "  print('Changed local x to', x)\n",
        "func(x)\n",
        "print('x is now', x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CebGe-bc_44g",
        "outputId": "8642f6af-fc00-4590-9b4c-718282dd879f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x is 50\n",
            "Changed local x to 2\n",
            "x is now 50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def printMax(a, b):\n",
        " if a > b:\n",
        "  print(a, 'is maximum')\n",
        " elif a == b:\n",
        "  print(a, 'is equal to', b)\n",
        " else:\n",
        "  print(b, 'is maximum')\n",
        "printMax(3, 4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Am1Q5lQ0_hVz",
        "outputId": "bc5394fe-e563-477d-84e5-687a403cbdc2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4 is maximum\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "calculator = {\"+\": (lambda x, y: x + y),\n",
        "              \"-\": (lambda x, y: x - y),\n",
        "              \"*\": (lambda x, y: x * y),\n",
        "              \"/\": (lambda x, y: x / y),\n",
        "             }\n",
        "calculator[\"+\"](2, 3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FcxHAzBXtSoj",
        "outputId": "6fb94703-8396-4e23-e9f5-207dff5dfaa5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "calculator[\"+\"](2, 3)"
      ],
      "metadata": {
        "id": "NgGJrEOhtyVP",
        "outputId": "d2de67f4-506d-4e76-cfc2-802a68904987",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "for num in range(101):\n",
        "  if num % 3 == 0 and num % 5 == 0:\n",
        "    print(\"FizzBuzz\")\n",
        "  elif num % 3 == 0:\n",
        "    print(\"Fizz\")\n",
        "  elif num % 5 == 0:\n",
        "    print(\"Buzz\")\n",
        "  else:\n",
        "    print(num)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XpQVbYzCcLEt",
        "outputId": "65484e21-dd36-412f-ff24-7340e746b20d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "FizzBuzz\n",
            "1\n",
            "2\n",
            "Fizz\n",
            "4\n",
            "Buzz\n",
            "Fizz\n",
            "7\n",
            "8\n",
            "Fizz\n",
            "Buzz\n",
            "11\n",
            "Fizz\n",
            "13\n",
            "14\n",
            "FizzBuzz\n",
            "16\n",
            "17\n",
            "Fizz\n",
            "19\n",
            "Buzz\n",
            "Fizz\n",
            "22\n",
            "23\n",
            "Fizz\n",
            "Buzz\n",
            "26\n",
            "Fizz\n",
            "28\n",
            "29\n",
            "FizzBuzz\n",
            "31\n",
            "32\n",
            "Fizz\n",
            "34\n",
            "Buzz\n",
            "Fizz\n",
            "37\n",
            "38\n",
            "Fizz\n",
            "Buzz\n",
            "41\n",
            "Fizz\n",
            "43\n",
            "44\n",
            "FizzBuzz\n",
            "46\n",
            "47\n",
            "Fizz\n",
            "49\n",
            "Buzz\n",
            "Fizz\n",
            "52\n",
            "53\n",
            "Fizz\n",
            "Buzz\n",
            "56\n",
            "Fizz\n",
            "58\n",
            "59\n",
            "FizzBuzz\n",
            "61\n",
            "62\n",
            "Fizz\n",
            "64\n",
            "Buzz\n",
            "Fizz\n",
            "67\n",
            "68\n",
            "Fizz\n",
            "Buzz\n",
            "71\n",
            "Fizz\n",
            "73\n",
            "74\n",
            "FizzBuzz\n",
            "76\n",
            "77\n",
            "Fizz\n",
            "79\n",
            "Buzz\n",
            "Fizz\n",
            "82\n",
            "83\n",
            "Fizz\n",
            "Buzz\n",
            "86\n",
            "Fizz\n",
            "88\n",
            "89\n",
            "FizzBuzz\n",
            "91\n",
            "92\n",
            "Fizz\n",
            "94\n",
            "Buzz\n",
            "Fizz\n",
            "97\n",
            "98\n",
            "Fizz\n",
            "Buzz\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def palindrome(x) :\n",
        "  y = x\n",
        "  punc = '''!\"#$%&'()*+, -./:;<=>?@[\\]^_`{|}~'''\n",
        "  for i in punc:\n",
        "    x = x.replace(i, \"\")\n",
        "  if x == x[::-1]:\n",
        "    print(\"{} is a palindrome.\".format(y))\n",
        "  else:\n",
        "    print(\"{} is NOT a palindrome.\".format(y))\n",
        "var = input(\"Write a sentence: \")\n",
        "palindrome(var)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lTTIlDn1cH_W",
        "outputId": "496f18f0-4b0b-461c-b2cb-2e0d8be2cf50"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write a sentence: ey edip adana'da, pide ye!\n",
            "ey edip adana'da, pide ye!\n",
            "eyedipadanadapideye\n",
            "ey edip adana'da, pide ye! is a palindrome.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6Ck5d3z2VOms",
        "outputId": "c5f855e9-9508-43b3-f447-adbb31770969"
      },
      "source": [
        "!pip3 --version"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pip 21.1.3 from /usr/local/lib/python3.7/dist-packages/pip (python 3.7)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vovXpmISQxVt",
        "outputId": "cce097ef-6e0d-40da-b5c5-650b20a1394e"
      },
      "source": [
        "!python3-V"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/bin/bash: python3-V: command not found\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ivVZsjqpOYuw",
        "outputId": "89e1f22b-6ac4-438f-ffa9-7bd8646f14fc"
      },
      "source": [
        "while True:\n",
        "    try: \n",
        "      no_one = int(input(\"The first number please : \"))\n",
        "      no_two = int(input(\"The second number please : \"))\n",
        "      division = no_one / no_two\n",
        "      print(\"The result of the division is : \", division)\n",
        "      break\n",
        "    except:\n",
        "      print(\"try again\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The first number please : 5\n",
            "The second number please : 1.2\n",
            "try again\n",
            "The first number please : 4\n",
            "The second number please : 3\n",
            "The result of the division is :  1.3333333333333333\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G6UdnGNsLpdu",
        "outputId": "1cdbe737-1fc7-474c-9cca-7a156645e9b3"
      },
      "source": [
        "num = 5\n",
        "print(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TwQslVTRLaIZ",
        "outputId": "c6fa1853-c0ab-40d8-8245-b08a84397e22"
      },
      "source": [
        "print(num)\n",
        "num = [1,2,3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V9-J0e2iEIVv",
        "outputId": "e5a9990d-863c-4b69-8be0-415b3112d3e5"
      },
      "source": [
        "def recur_factorial(n):  \n",
        "   if n == 1:  \n",
        "       return n  \n",
        "   else:  \n",
        "       return n*recur_factorial(n-1)  \n",
        "# take input from the user  \n",
        "num = int(input(\"Enter a number: \"))  \n",
        "# check is the number is negative  \n",
        "if num < 0:  \n",
        "   print(\"Sorry, factorial does not exist for negative numbers\")  \n",
        "elif num == 0:  \n",
        "   print(\"The factorial of 0 is 1\")  \n",
        "else:  \n",
        "   print(\"The factorial of\",num,\"is\",recur_factorial(num))  "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 4\n",
            "The factorial of 4 is 24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 184
        },
        "id": "skVeBSu7CI-R",
        "outputId": "156f4e80-31fc-4440-a86e-7f47115177a8"
      },
      "source": [
        "import math\n",
        "math.factorial(-3)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-35-f7fc51bea495>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfactorial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: factorial() not defined for negative values"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EKePSiBAgL2V"
      },
      "source": [
        "while True:\n",
        "    no_one = int(input(\"The first number please : \"))\n",
        "    no_two = int(input(\"The second number please : \"))\n",
        "    try:\n",
        "        division = no_one / no_two\n",
        "        print(\"The result of the division is : \", division)\n",
        "        break\n",
        "    except Exception as e:\n",
        "        print(\"Something went wrong...Try again.\")\n",
        "        print(\"Probably it is because of '{}' error\".format(e))\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EFRLv1nBextp"
      },
      "source": [
        "while True:\n",
        "    no_one = int(input(\"The first number please : \"))\n",
        "    no_two = int(input(\"The second number please : \"))\n",
        "    try:\n",
        "        division = no_one / no_two  # normal part of the program\n",
        "    except ZeroDivisionError:\n",
        "        print(\"You can't divide by zero! Try again.\")  # executes when division by zero\n",
        "    else:\n",
        "        print(\"The result of the division is : \", division)  # executes if there is no exception\n",
        "    finally:\n",
        "        print(\"Thanks for using our mini divison calculator! Come again!\")\n",
        "        break  # exits the while loop"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YS5NmWSOvxHp",
        "outputId": "7e2925c8-8a9c-443c-d276-7b389173b788"
      },
      "source": [
        "def missing_char(word,n):\n",
        "  output = \"\"\n",
        "  for i in range(0, len(word)):\n",
        "    if i != n:\n",
        "      output += word[i]\n",
        "  return output\n",
        "print(missing_char(\"kitchen\", 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "kichen\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63C_sirfsW0T",
        "outputId": "2667a3ce-1740-4359-f82e-617bce477eb0"
      },
      "source": [
        "def not_string(word):\n",
        "  if word.strip()[0:4] == \"not \":\n",
        "    return word\n",
        "  else:\n",
        "    return \"not \" + word\n",
        "print(not_string(\"not x\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "not x\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KrO7B8k5ip3s",
        "outputId": "f9086f19-67e5-4b3a-af94-d4e604baf73e"
      },
      "source": [
        "iterable = [1, 2, 3, 4, 5]\n",
        "map(lambda x:x**2, iterable)\n",
        "result = map(lambda x:x**2, iterable)\n",
        "print(type(result))  # it's a map type\n",
        "\n",
        "print(list(result))  # we've converted it to list type to print\n",
        "\n",
        "print(map(lambda x:x**2, iterable))  # you can print directly"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'map'>\n",
            "[1, 4, 9, 16, 25]\n",
            "<map object at 0x7f695bdc24d0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mctEQBg5hyD4",
        "outputId": "d54179bd-30e7-4ca0-a520-fa7011916fe3"
      },
      "source": [
        "k = [1, 2, 3 ,4]\n",
        "print(list(reversed(k)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gLQSFQNzgywM",
        "outputId": "db6b3010-1632-49bb-d6fc-8dd6054356c4"
      },
      "source": [
        "x = 'abcd'\n",
        "for i in range(len(x)):\n",
        " x[i].upper()\n",
        "print (x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "abcd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5y6id9MJ4vpu",
        "outputId": "9e8cbe83-124d-4238-b46a-f8f829cfc6af"
      },
      "source": [
        "i = 5\n",
        "while True:\n",
        "  if i%0xe == 0:\n",
        "    break\n",
        "  print(i)\n",
        "  i += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "11\n",
            "12\n",
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yjDhBN0_2kIF",
        "outputId": "0df7a9b2-c72c-4d78-bccb-90da665393bf"
      },
      "source": [
        "fruits = {'Apples': 5, 'Oranges': 3, 'Bananas': 4}\n",
        "fruit_names = [x for x in fruits.keys()]\n",
        "print(fruit_names)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Apples', 'Oranges', 'Bananas']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "slOsuHNSIBPS"
      },
      "source": [
        "!pip list # libraries at colab"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "px4VEc8preR0",
        "outputId": "7e34a805-e9c8-4917-e997-1ffdc33eda4b"
      },
      "source": [
        "pip install numpy"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (1.19.5)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DS-zqhUHq5n2",
        "outputId": "3006b678-4d8d-4db4-ad7e-2130ec5ca141"
      },
      "source": [
        "pip --version"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "pip 21.1.3 from /usr/local/lib/python3.7/dist-packages/pip (python 3.7)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6FYDYc14qZxa",
        "outputId": "a681aeb5-428a-4de1-d603-9835d7b35b80"
      },
      "source": [
        "from random import choice\n",
        "paths = [\"data science\", \"AWS/DevOps\", \"Full stack\", \"Cyber Security\"]\n",
        "print(choice(paths))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AWS/DevOps\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CN-MTg-8oZPI",
        "outputId": "53d6ef3a-14e5-4032-cdfb-75698e397793"
      },
      "source": [
        "from random import choice\n",
        "city = [\"stockholm\", \"istanbul\", \"seul\", \"cape town\"]\n",
        "print(choice(city))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "seul\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T1Ipg4M9mvL9",
        "outputId": "850b7d3b-c8f9-4f02-c41a-d69c1adfb439"
      },
      "source": [
        "print((632 - 571) * 365 + 15)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "22280\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y3ncs841mOEs",
        "outputId": "5627ad73-4203-42f0-d383-b4912308c65b"
      },
      "source": [
        "import datetime\n",
        "print(datetime.datetime.now())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2021-12-02 19:22:59.743183\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BCRpeYP0k7Jj",
        "outputId": "cdf8049c-cbbb-4bd4-a936-a48a87d9f6a7"
      },
      "source": [
        "import datetime\n",
        "print(datetime.date.today())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2021-12-02\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "4imLhgL4jaAB",
        "outputId": "e2c61178-7c0f-48a7-990e-6a2581d3deaa"
      },
      "source": [
        "from string import punctuation, digits\n",
        "punctuation\n",
        "digits"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'0123456789'"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DHOt5b0yWrpl",
        "outputId": "048a8a55-183b-4301-820c-9681be7bb414"
      },
      "source": [
        "from math import pi, factorial, log10\n",
        "pi\n",
        "factorial(4)\n",
        "log10(1000)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X8BAX9fdty6E",
        "outputId": "54b6c0aa-c5be-4726-a0f8-a089160d91a2"
      },
      "source": [
        "def outer():\n",
        "    x = \"previous\"\n",
        "    \n",
        "    def inner():\n",
        "      \n",
        "      x = \"later\"\n",
        "      print(\"inner:\", x)\n",
        "    \n",
        "    inner()\n",
        "    print(\"outer:\", x)\n",
        "\n",
        "print(outer())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "inner: later\n",
            "outer: previous\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XfWn-zlPI8VB",
        "outputId": "64514dcc-bf3d-45c0-900c-250deac83ddf"
      },
      "source": [
        "x = 'My name is Richard'\n",
        "def my_function_1(): \n",
        "    x = 'My name is John'\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My name is Richard\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SFmLWVMCns0Z",
        "outputId": "43d6636d-189e-4acb-d270-259d713472be"
      },
      "source": [
        "city = \"I love Paris!\"\n",
        "\n",
        "def my_function(): \n",
        "    city = \"I love\"\n",
        "    print(city)\n",
        "my_function()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I love\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ndViDHsvUZb4",
        "outputId": "417db0b2-6dbc-4ddd-d10d-b8203985c3d2"
      },
      "source": [
        "vowel_list = ['a', 'e', 'i', 'o', 'u']\n",
        "first_ten = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "vowels = filter(lambda x : x in vowel_list, first_ten)\n",
        "print(list(vowels))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', 'e', 'i']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7PV2BEMcOTf5",
        "outputId": "39738e66-5a26-4bd0-e7cd-c9c1be081df8"
      },
      "source": [
        "words = [\"apple\", \"swim\", \"clock\", \"me\", \"kiwi\", \"banana\"]\n",
        "#  list1 = filter(lambda x : len(x) < 5, words)\n",
        "#   print(*list(list1), sep=\"\\n\")\n",
        "for x in filter(lambda x : len(x) < 5, words):\n",
        "  print(x)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "swim\n",
            "me\n",
            "kiwi\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5lHp8UlKJDOy",
        "outputId": "5e9f95e4-d494-4d8f-efa6-e20f3fe75672"
      },
      "source": [
        "words1 = [\"you\", \"much\", \"hard\"]\n",
        "words2 = [\"I\", \"you\", \"he\"]\n",
        "words3 = [\"love\", \"ate\", \"works\"]\n",
        "#  func = lambda x, y, z : x + \" \" + y + \" \" + z\n",
        "var = map(lambda x, y, z : x + \" \" + y + \" \" + z, words2, words3, words1)\n",
        "print(*var, sep=\"\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I love you\n",
            "you ate much\n",
            "he works hard\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qgrfBwTlLTO_"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RNTv9N0iHuO6",
        "outputId": "04ffc55e-033b-4f3a-c3eb-d4839ac7657d"
      },
      "source": [
        "list1 = [9, 6, 7, 4]\n",
        "list2 = [3, 6, 5, 8]\n",
        "list3 = lambda x, y : (x + y) / 2\n",
        "print(list(map(list3, list1, list2)))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[6.0, 6.0, 6.0, 6.0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2KD9ftUf9LG2",
        "outputId": "8dabd5a2-b6d6-440f-b990-5fd36da74b1f"
      },
      "source": [
        "list1 = [1, 2, 3, 4]\n",
        "for var in list1:\n",
        "  print(var, \":\", (lambda x : \"odd\" if x % 2 != 0 else \"even\")(var))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 : odd\n",
            "2 : even\n",
            "3 : odd\n",
            "4 : even\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XXgIT8wc8dGg",
        "outputId": "5ba567b0-546e-42fa-93a8-a139aa0d443f"
      },
      "source": [
        "(lambda a, b : (a + b) / 2)(3, 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4.0"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "3w6cVLiN7kO2",
        "outputId": "930551fb-a505-4974-b1df-82788d05e6a0"
      },
      "source": [
        "(lambda x : x[::-1])(\"ali\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'ila'"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VImY-uTO71jB",
        "outputId": "83318303-4c8f-4cd7-d6f1-646ab8fd08a6"
      },
      "source": [
        "def parrot_trouble(talking, hour):\n",
        "  if talking == True and hour >= 21 or hour <= 6 :\n",
        "    return True\n",
        "  else:\n",
        "    return False\n",
        "print(parrot_trouble(False, 22))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BVMBYUUpxtvu",
        "outputId": "4fb35605-5533-4093-9ac9-12b613373be6"
      },
      "source": [
        "def sum_double(x, y):\n",
        "  if x != y:\n",
        "    return x + y\n",
        "  else:\n",
        "    return 2 * (x + y)\n",
        "sum_double(4, 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BmQc33lRSMUi",
        "outputId": "288b9d3b-75be-48d8-8cc8-a18b829a6914"
      },
      "source": [
        "num = int(input(\"Enter a number: \"))\n",
        "prime_num_list = []\n",
        "for var in range(2, num):\n",
        "  prime_num = True\n",
        "  for i in range(2,var) :\n",
        "    if var % i == 0 :\n",
        "      prime_num = False\n",
        "      break\n",
        "  if prime_num:\n",
        "    prime_num_list.append(var)\n",
        "print(prime_num_list)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 89\n",
            "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q2oYxCWvhdLv",
        "outputId": "a13455e5-0989-47e6-8cf8-0385bbd34109"
      },
      "source": [
        "fibonacci_num = []\n",
        "previous = 0\n",
        "now = 1\n",
        "for i in range(10) :\n",
        "  fibonacci_num.append(now)\n",
        "  next = previous + now\n",
        "  previous = now\n",
        "  now = next\n",
        "print(fibonacci_num)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IIb2ITVhtf0o",
        "outputId": "18284120-88c7-454e-9cfa-0e081051834f"
      },
      "source": [
        "num = int(input(\"Enter a number: \"))\n",
        "prime_num = True\n",
        "for i in range(2,num) :\n",
        "  if num % i == 0 :\n",
        "    prime_num = False\n",
        "    break\n",
        "if prime_num:\n",
        "  print(num, \"is a prime number.\")\n",
        "else:\n",
        "  print(num, \"is not a prime number.\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 2\n",
            "2 is a prime number.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SFc3Dp7UlNFq",
        "outputId": "12023fc8-1306-4744-8828-49f75eb19021"
      },
      "source": [
        "def slicer(*args):\n",
        "  even = []\n",
        "  odd = []\n",
        "  for i in args:\n",
        "    if i %2 == 0:\n",
        "      even.append(i)\n",
        "    else:\n",
        "      odd.append(i)\n",
        "  print(\"even number:\", even)\n",
        "  print(\"odd number:\", odd)\n",
        "slicer(1, 2, 3, 4, 5, 6, 7, 8, 9)\n",
        "slicer(*range(20)) # asterisk is unpacking the range"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "even number: [2, 4, 6, 8]\n",
            "odd number: [1, 3, 5, 7, 9]\n",
            "even number: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n",
            "odd number: [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L1v8K_DqLlHc",
        "outputId": "1021f8bf-f578-4cc6-ec7a-e20d312c7c7e"
      },
      "source": [
        "num = input(\"Please enter a positive number: \")\n",
        "if not num.strip().isdigit():\n",
        "    print(\"It is an invalid entry. Don't use non-numeric, float, or negative values!\")\n",
        "elif int(num) >= 0 :\n",
        "  num2 = 0\n",
        "  for i in num:\n",
        "    num2 += int(i) ** len(num)\n",
        "  if num2 == int(num) :\n",
        "    print(\"{} is an Armstrong number.\".format(num))\n",
        "  else:\n",
        "    print(\"{} is not an Armstrong number.\".format(num))\n",
        "else:\n",
        "  print(\"It is an invalid entry. Don't use non-numeric, float, or negative values!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter a positive number: 2345.8\n",
            "It is an invalid entry. Don't use non-numeric, float, or negative values!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ipbxho6n-W3b",
        "outputId": "db55aadd-259c-4f05-ea11-49f3ae7c16c7"
      },
      "source": [
        "def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):\n",
        "    print(\"-- This parrot wouldn't\", action, end=' ')\n",
        "    print(\"if you put\", voltage, \"volts through it.\")\n",
        "    print(\"-- Lovely plumage, the\", type)\n",
        "    print(\"-- It's\", state, \"!\")\n",
        "#parrot(1000)\n",
        "#parrot(voltage=1000000, action='VOOOOOM') \n",
        "print(parrot(voltage = 5.0))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-- This parrot wouldn't voom if you put 5.0 volts through it.\n",
            "-- Lovely plumage, the Norwegian Blue\n",
            "-- It's a stiff !\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MMVK9zgP8hRb",
        "outputId": "ef302b95-b6ce-48f9-f434-47507602a9d8"
      },
      "source": [
        "def my_sentence(a = \"I\", b = 2):\n",
        "  print(a, \"have\", b, \"kids.\")\n",
        "my_sentence()\n",
        "my_sentence(\"you\", 4)\n",
        "my_sentence(a = \"we\", b = \"kind\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I have 2 kids.\n",
            "you have 4 kids.\n",
            "we have kind kids.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kcNrLH3KQOfF",
        "outputId": "6b768bf9-6bed-46c8-9154-d09267d89bd0"
      },
      "source": [
        "def sentence(par1, par2, par3):\n",
        "    print(par2, par3, par1)\n",
        "sentence(par1 = \"you\", par3 = \"love\", par2 = \"i\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i love you\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mq401duq5Yey",
        "outputId": "5cd494bb-0abd-4444-9b7e-947a12bde222"
      },
      "source": [
        "a = \"i\"\n",
        "b = \"love\"\n",
        "c = \"you\"\n",
        "def sentence(par1, par2, par3):\n",
        "    print(par2, par3, par1)\n",
        "sentence(c, a, b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i love you\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KcyeXmRky2s7",
        "outputId": "f8dc619e-aa83-476e-fd79-60b6b43b62e2"
      },
      "source": [
        "def my_initial(name, surname):\n",
        "    name = name[0:1]\n",
        "    surname = surname[0:1]\n",
        "    return name.upper() + surname.upper()\n",
        "print(my_initial(\"mine\", \"gumus\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "MG\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oLvwc46EA96S",
        "outputId": "cc9a8dd9-bd98-412f-f22e-328257cfea7d"
      },
      "source": [
        "num = input(\"Please enter a positive number: \")\n",
        "num1 = set(num)\n",
        "if not num.strip().isdigit():\n",
        "    print(\"It is an invalid entry. Don't use non-numeric, float, or negative values!\")\n",
        "elif int(num) >= 0 :\n",
        "  num2 = 0\n",
        "  for i in num1:\n",
        "    num2 += int(i) ** len(num1)\n",
        "  if num2 == int(num) :\n",
        "    print(\"{} is an Armstrong number.\".format(num))\n",
        "  else:\n",
        "    print(\"{} is not an Armstrong number.\".format(num))\n",
        "else:\n",
        "  print(\"It is an invalid entry. Don't use non-numeric, float, or negative values!\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter a positive number: one\n",
            "It is an invalid entry. Don't use non-numeric, float, or negative values!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5Mk3l6xqKaD6",
        "outputId": "decbf220-b611-436c-dfa0-97a09ac7bcde"
      },
      "source": [
        "college_years = ['Freshman', 'Sophomore', 'Junior', 'Senior']\n",
        "print(list(enumerate(college_years, 2019)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(2019, 'Freshman'), (2020, 'Sophomore'), (2021, 'Junior'), (2022, 'Senior')]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xfM5RJmjJiO4",
        "outputId": "08b2f3f5-50fc-4401-e820-66816349b3be"
      },
      "source": [
        "z=set('abc')\n",
        "z.add('san')\n",
        "z.update(set(['p', 'q']))\n",
        "print(z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'b', 'c', 'san', 'p', 'q', 'a'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 201
        },
        "id": "GRY6Sx_YHo6W",
        "outputId": "5a99f24d-0cfa-4839-9659-5a4c9d90c7fa"
      },
      "source": [
        "a={}\n",
        "a['a']=1\n",
        "a['b']=[2,3,4]\n",
        "a[4]=\"mine\"\n",
        "dict[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-4-fcf90da88fb0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'b'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"mine\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mdict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'type' object is not subscriptable"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n2DT_pvDHbPS",
        "outputId": "7da9216a-285c-414f-cafc-2d12ea05dec5"
      },
      "source": [
        "d = {\"john\":40, \"peter\":45}\n",
        "print(list(d.keys()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['john', 'peter']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rSaVI4sgHKUF",
        "outputId": "cadc21ee-a6d7-45be-977b-f5e3ea346d6c"
      },
      "source": [
        "d = {\"john\":40, \"peter\":45}\n",
        "d[\"john\"]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "40"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VRsJjVMuGQWV",
        "outputId": "dde9096b-0ed6-40fa-ebf6-f4af03ab0643"
      },
      "source": [
        "for x in set('mine'):\n",
        "    print(x*2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "nn\n",
            "mm\n",
            "ii\n",
            "ee\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fUjFu8xXGess",
        "outputId": "daae1c7f-a6c7-4fdc-d67a-024dc7b9113e"
      },
      "source": [
        "def absulate_value(a) :\n",
        "  if a >= 0:\n",
        "   return a\n",
        "  else:\n",
        "   return a * -1\n",
        "absulate_value(-5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j0gjGTV1-5uD"
      },
      "source": [
        "word=input(\"What word would you like to try? \")\n",
        "check=input(\"Would you like to check out the punctuations? \").lower()\n",
        "punc=\"?/>.<,:;}]{[|\\'+=_-)(*&^%$!\\\"\"\n",
        "check2=input(\"Would you like to try any other words than this one? \").lower()\n",
        "reverse = \"\"\n",
        "if check == \"yes\":\n",
        "   for i in word:\n",
        "      reverse += i\n",
        "      if word == reverse:\n",
        "         print(\"yes\")\n",
        "      else:\n",
        "         print(\"no\")\n",
        "else check != \"no\"\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gCMvp7cH2J_L",
        "outputId": "251eceec-8713-434e-9651-894be4779d8a"
      },
      "source": [
        "word=input(\"What word would you like to try? \")\n",
        "check=input(\"Would you like to check out the punctuations? \").lower()\n",
        "punc=\"?/>.<,:;}]{[|\\'+=_-)(*&^%$!\\\"\"\n",
        "check2=input(\"Would you like to try any other words than this one? \").lower()\n",
        "without=\"\"\n",
        "word1=word.lower()\n",
        "\n",
        "if check==\"no\":\n",
        "    w = \"\"\n",
        "    for i in word:\n",
        "      w += i \n",
        "      if word == w:\n",
        "         print(\"Yes\")\n",
        "      elif word != w:\n",
        "         print(\"No\")\n",
        "elif check==\"yes\":\n",
        "    for i in word1:\n",
        "      if i not in punc:\n",
        "        without += i\n",
        "        w = \"\"\n",
        "        for i in without:\n",
        "          w += i \n",
        "          if without == w:\n",
        "             print(\"Yes\")\n",
        "          elif without != w :\n",
        "             print(\"No\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "What word would you like to try? radar\n",
            "Would you like to check out the punctuations? no\n",
            "Would you like to try any other words than this one? yes\n",
            "No\n",
            "No\n",
            "No\n",
            "No\n",
            "Yes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rQ7cRAnsowxU",
        "outputId": "d17c6095-9d64-4356-8d3e-8e10f92c41eb"
      },
      "source": [
        "[0, 1, 4, 9, 16, 25]\n",
        "generator = (i ** 2 for i in range(6))\n",
        "print(* generator)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 1 4 9 16 25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5B3rK_stajWu",
        "outputId": "e7018e76-5bb5-4223-ef8f-5dfa31260338"
      },
      "source": [
        "def my_function(a, b) :\n",
        "  area = a * b\n",
        "  return area\n",
        "print(my_function(3, 4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TEQKC-56XeEK"
      },
      "source": [
        "def calculator(a, b, operator):\n",
        "  if operator == \"+\" :\n",
        "    print(a + b)\n",
        "  elif operator == \"-\" :\n",
        "    print(a - b)\n",
        "  elif operator == \"*\" :\n",
        "    print(a * b)\n",
        "  elif operator == \"/\" :\n",
        "    print(a / b)\n",
        "  else: \n",
        "    print(\"Enter valid arguments\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t0B4gHgNWoM9",
        "outputId": "17982927-6c1b-4c56-ca34-21b07b813d5c"
      },
      "source": [
        "def add(a, b):\n",
        "  print(a + b)\n",
        "add(1, 6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0gp8T7JisBiN",
        "outputId": "0a98600c-bce7-4eb2-99d4-9c57637e75bb"
      },
      "source": [
        "print(round(3.2234578, 4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.2235\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "id": "stRo8zZ-q9z8",
        "outputId": "609718d9-d135-4c94-9291-04a1ce2d6233"
      },
      "source": [
        "list1 = [1, {}, 0, \"b\"]\n",
        "print(list(filter(False, list1))) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-10-81def17d1af5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mlist1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"b\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'bool' object is not callable"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LUp5lJgWaCJ-",
        "outputId": "46d6ad2a-6166-4eba-d2f4-c8cc2061aec4"
      },
      "source": [
        "even = list(filter(lambda x: x % 2 ==0, [*range(10)]))\n",
        "print(even, type(even))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 2, 4, 6, 8] <class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MduLSKdQYYA8",
        "outputId": "03bc9f26-df94-45a8-c617-c75b19eb92a9"
      },
      "source": [
        "names = [\"susan\", \"tom\", \"False\"]\n",
        "mood = [\"happy\", \"sad\", 0]\n",
        "empty = {}\n",
        "\n",
        "print(all(names), all(mood), all(empty), sep = \"\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K15oiQJdHsNw"
      },
      "source": [
        "Ternary if condition structure :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "403n5fXvHr7J",
        "outputId": "ed7924b6-8887-4149-8c3c-39df7b0d0f80"
      },
      "source": [
        "# execute-body1 if condition else execute-body2\n",
        "condition = False\n",
        "1 if condition else 0"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9GS4LXtUSm1w",
        "outputId": "625d4e66-9767-41cd-c38a-050d6597e503"
      },
      "source": [
        "my_list = [1, 2, 3, 4, 5, 6]\n",
        "[i ** 2 for i in my_list if i % 2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 9, 25]"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YRBBQuw-Iw8y",
        "outputId": "857b9e0c-0ebf-4c57-f964-b145edbb97ba"
      },
      "source": [
        "my_list = [1, 2, 3, 4, 5, 6]\n",
        "[i ** 2 for i in my_list if i % 2 == 0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[4, 16, 36]"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7RyFmWkUHOsU",
        "outputId": "edecf96a-e75c-4a04-8ae5-4e1650589f18"
      },
      "source": [
        "my_list = [1, 2, 3, 4, 5, 6]\n",
        "new_list = []\n",
        "for i in my_list:\n",
        "  if i % 2 :\n",
        "    new_list.append(i**2)\n",
        "print(new_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 9, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jmbSJtd3Ei-3",
        "outputId": "15cd664b-dcb3-470c-d7c1-09f26117cd10"
      },
      "source": [
        "num = []\n",
        "for i in range(5):\n",
        "    num.append(i)\n",
        "num"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I_u9D1KUEbio",
        "outputId": "ea9ffc4c-9455-4a85-f11a-63b09feb1125"
      },
      "source": [
        "# [Expression/ body for i in range(5)]\n",
        "[i for i in range(5)]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 2, 3, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yYwnmVHAFEJd",
        "outputId": "216d3915-e277-4a1a-8e80-a319d65846cd"
      },
      "source": [
        "[i**2 for i in range(1,6)]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 4, 9, 16, 25]"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tPj-Dg6N29bP",
        "outputId": "cf4b6e9c-2f44-420c-f2cf-88e6913eef43"
      },
      "source": [
        "names = [\"susan\", \"tom\", \"edward\"]\n",
        "mood = [\"happy\", \"sad\"]\n",
        "for i in names:\n",
        "  for ii in mood:\n",
        "    print(i, \"is\", ii)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "susan is happy\n",
            "susan is sad\n",
            "tom is happy\n",
            "tom is sad\n",
            "edward is happy\n",
            "edward is sad\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yvgWSKORZDOQ",
        "outputId": "80fca27a-9342-43b1-e940-085215d0739f"
      },
      "source": [
        "def my_function(width, height):\n",
        "     return width*height/2\n",
        "print(my_function(3, 4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e1nqaDlt3Om1",
        "outputId": "b2d54103-92ea-42bc-d625-785ec1cb5c83"
      },
      "source": [
        "name = input(\"Enter your first name: \").title()\n",
        "name1 = \"Mine\"\n",
        "if name1 == name:\n",
        "  print(\"Hello Mine! The password is: O34$\")\n",
        "else:\n",
        "  print(\"Hello {}! See you later.\".format(name))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your first name: gokjhan\n",
            "Hello Gokjhan! See you later.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2KXyQq-J9SUe",
        "outputId": "108dc24f-7ff5-43d9-d147-864bc0f566d9"
      },
      "source": [
        "num = (\"1\", \"2\", \"3\", \"4\", \"5\")\n",
        "for i in num:\n",
        "  print(i + \"-\", end = \"\")\n",
        "print(\"\\b\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1-2-3-4-5-\b\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OKnikEzv7Af-",
        "outputId": "6c7b5562-6918-4451-f010-9498c294b266"
      },
      "source": [
        "names = [\"Ahmed\", \"Aisha\", \"Adam\", \"Joseph\", \"Gabrial\"]\n",
        "for name in names:\n",
        "  print(\"Hello\", name +\"!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Ahmed!\n",
            "Hello Aisha!\n",
            "Hello Adam!\n",
            "Hello Joseph!\n",
            "Hello Gabrial!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q9p8Mowf034K",
        "outputId": "8c61911d-9f1b-47a3-b09c-c131e0225eff"
      },
      "source": [
        "import random\n",
        "answer = random.randint(0,100)\n",
        "question = 'What number am I thinking of?  '\n",
        "print (\"Let's play the guessing game!\")\n",
        "\n",
        "while True:\n",
        "    guess = int(input(question))\n",
        "    if guess < answer:\n",
        "        print('Little higher')\n",
        "    elif guess > answer:\n",
        "        print('Little lower')\n",
        "    else:  # guess == answer\n",
        "        print('Are you a MINDREADER!!!')\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Let's play the guessing game!\n",
            "What number am I thinking of?  120\n",
            "Little lower\n",
            "What number am I thinking of?  100\n",
            "Little lower\n",
            "What number am I thinking of?  70\n",
            "Little lower\n",
            "What number am I thinking of?  50\n",
            "Little lower\n",
            "What number am I thinking of?  30\n",
            "Little higher\n",
            "What number am I thinking of?  40\n",
            "Little lower\n",
            "What number am I thinking of?  35\n",
            "Little higher\n",
            "What number am I thinking of?  37\n",
            "Little lower\n",
            "What number am I thinking of?  36\n",
            "Are you a MINDREADER!!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6s4Z6BlXsoiM",
        "outputId": "00c7b473-f0b4-4363-889e-e5620e19719d"
      },
      "source": [
        "age = input(\"Write your age: \")\n",
        "age.isdigit()\n",
        "print(age.isdigit())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write your age: 34\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YJvgEzsTeZgA",
        "outputId": "cb7c8210-445a-4b79-fb05-5ee5d53b20a2"
      },
      "source": [
        "L1 = []\n",
        "L1.append([1, [2, 3], 4])\n",
        "L1.extend([7, 8, 9])\n",
        "print(L1[0][1][1] + L1[2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VdVtMOtcdiyV",
        "outputId": "79f38fe9-8706-45ed-9fc9-b9032ccc9c82"
      },
      "source": [
        "a=[1,2,3,4]\n",
        "b=a\n",
        "a.append(5)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "frRTgB_C67xE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c504c6d2-c3b7-43ce-8c30-8f59195fc06f"
      },
      "source": [
        "a=[1,2,3,4]\n",
        "b=a.copy()\n",
        "a.append(5)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VRkmY6MQ5gs5",
        "outputId": "7507d989-4d03-431c-b756-a1cc22143fa2"
      },
      "source": [
        "a = float(input(\"Pls enter 1st number: \"))\n",
        "b = float(input(\"Pls enter 2nd number: \"))\n",
        "c = float(input(\"Pls enter 3rd number: \"))\n",
        "if a >= b and a >= c:\n",
        "  print(f\"Largest number is {a}\")\n",
        "elif c >= b:\n",
        "  print(f\"Largest number is {c}\")\n",
        "else: \n",
        "  print(f\"Largest number is {b}\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Pls enter 1st number: 3\n",
            "Pls enter 2nd number: 7\n",
            "Pls enter 3rd number: 1\n",
            "Largest number is 7.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vPHvEWN22LvZ",
        "outputId": "56020820-391e-4ba6-a562-90244dff3263"
      },
      "source": [
        "num1 = float(input(\"enter a number: \"))\n",
        "num2 = float(input(\"enter a number: \"))\n",
        "num3 = float(input(\"enter a number: \"))\n",
        "if (num1 >= num2) and (num1>= num3):\n",
        "  bigger = num1\n",
        "elif (num2 >= num1) and (num2>= num3):\n",
        "  bigger = num2\n",
        "else:\n",
        "  bigger = num3\n",
        "print(bigger)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter a number: 5\n",
            "enter a number: 8\n",
            "enter a number: 1\n",
            "8.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L8XJAGvV0nEy",
        "outputId": "0597ae4b-b2b2-4be6-aa08-ae8d12a1f580"
      },
      "source": [
        "fruits = ['Apples', 'Oranges', 'Bananas']\n",
        "quantities = [5, 3, 4]\n",
        "prices = [1.50, 2.25, 0.89]\n",
        "i = 0\n",
        "output = []\n",
        "for fruit in fruits:\n",
        " temp_qty = quantities[i]\n",
        " temp_price = prices[i]\n",
        " output.append((fruit, temp_qty, temp_price))\n",
        " i += 1\n",
        "print(output)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('Apples', 5, 1.5), ('Oranges', 3, 2.25), ('Bananas', 4, 0.89)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ksr4bhY2m3N6",
        "outputId": "5f3827d7-d24c-4382-f3b4-9c51832cb44e"
      },
      "source": [
        "print(list(\"1,2,3\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['1', ',', '2', ',', '3']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "btMMLF7XVdZI",
        "outputId": "53ab0bb3-4474-4d67-874b-3e8eb4e1a464"
      },
      "source": [
        "fruits = ['Apples', 'Oranges', 'Bananas']\n",
        "quantities = [5, 3, 4]\n",
        "prices = [1.50, 2.25, 0.89]\n",
        "groceries = zip(fruits, quantities, prices)\n",
        "print(list(groceries))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('Apples', 5, 1.5), ('Oranges', 3, 2.25), ('Bananas', 4, 0.89)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nu0H_RoCPwWr",
        "outputId": "f0a23360-4655-4ad9-da8b-560f7f142034"
      },
      "source": [
        "\n",
        "fruits = ['Apples', 'Oranges', 'Bananas']\n",
        "quantities = [5, 3, 4]\n",
        "prices = [1.50, 2.25, 0.89]\n",
        "zipped = zip(fruits, quantities, prices)\n",
        "print(*list(zipped), sep = \",\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Apples', 5, 1.5),\n",
            "('Oranges', 3, 2.25),\n",
            "('Bananas', 4, 0.89)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ad4AweH2ORhi",
        "outputId": "1152dcfd-63d3-444f-ebb1-5017ff11dea0"
      },
      "source": [
        "college_years = ['Freshman', 'Sophomore', 'Junior', 'Senior']\n",
        "print(list(enumerate(college_years, 2019))) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(2019, 'Freshman'), (2020, 'Sophomore'), (2021, 'Junior'), (2022, 'Senior')]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ILFG5xrwsb9l",
        "outputId": "7498e0a0-032b-4fa4-ef39-e8aef81e1c01"
      },
      "source": [
        "num = int(input(\"write a number: \"))\n",
        "if num >0:\n",
        "  print(\"Number is positive\")\n",
        "else:\n",
        "  print(\"Number is negative\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write a number: -12\n",
            "Number is negative\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u469wbWuej_P"
      },
      "source": [
        "set1 = (\"TWELVE PLUS ONE\")\n",
        "set2 = (\"ELEVEN PLUS TWO\")\n",
        "if set1 == set2:\n",
        "  print(\"We are the same!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OVDSCwxbX4rM",
        "outputId": "02e2266d-3c75-4ada-adbe-f70b24c2ccff"
      },
      "source": [
        "num = [12, \"ali\", 6.5]\n",
        "del num[1]\n",
        "print(num)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[12, 6.5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hbaosm0qyCVQ",
        "outputId": "8cbf8f6f-d5cd-4b32-e724-01d9a7cc6cd0"
      },
      "source": [
        "sample_list = [{\"section\":5, \"topic\":2}, 'clarusway', [1, 4], 2020, 3.14, 1+618j, False, (10, 20)]\n",
        "for i in sample_list:\n",
        "  print(\"The type of\", i, \"is\", type(i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The type of {'section': 5, 'topic': 2} is <class 'dict'>\n",
            "The type of clarusway is <class 'str'>\n",
            "The type of [1, 4] is <class 'list'>\n",
            "The type of 2020 is <class 'int'>\n",
            "The type of 3.14 is <class 'float'>\n",
            "The type of (1+618j) is <class 'complex'>\n",
            "The type of False is <class 'bool'>\n",
            "The type of (10, 20) is <class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gm4CV0QLr4lp",
        "outputId": "0a42af7a-f206-4726-fe7e-dc1449281377"
      },
      "source": [
        "num1 = int(input(\"write a number: \"))\n",
        "num2 = int(input(\"write a number: \"))\n",
        "if num1 != num2:\n",
        "  if num1 > num2:\n",
        "    print(f\"The larger number is {num1}.\")\n",
        "  else:\n",
        "    print(f\"The larger number is {num2}.\")\n",
        "else:\n",
        "  print(\"Numbers are equal.\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write a number: 2\n",
            "write a number: 4\n",
            "The larger number is 4.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "003OIMcDomqV",
        "outputId": "018bec08-bbc5-4d98-a174-81871698f1cc"
      },
      "source": [
        "num = int(input(\"write a number: \"))\n",
        "if num % 2 == 0:\n",
        "  print(\"number is even\")\n",
        "else:\n",
        "  print(\"number is odd\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write a number: 33\n",
            "number is odd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hHESqLsGkGN5",
        "outputId": "d0ba08ec-9754-48c7-9791-0ebad36a9bc9"
      },
      "source": [
        "print(\"You entered\", input(\"enter yes or no:\").title().strip() == \"Yes\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter yes or no:no\n",
            "You entered False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uymkwcDCf5wO",
        "outputId": "d540c8a2-32cf-4cfe-cc41-8b45bef991dc"
      },
      "source": [
        "convert = input(\"enter yes or no:\").title().strip() == \"Yes\"\n",
        "print(\"You entered\", convert)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter yes or no:yes\n",
            "You entered True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XfzAwPUEdyFd",
        "outputId": "5efbbbae-36a0-4d97-d7e6-207861d09c8c"
      },
      "source": [
        "yes = True\n",
        "no = False\n",
        "word = input(\"write yes or no: \").lower()\n",
        "if word == \"yes\":\n",
        "  print(\"You entered true\")\n",
        "else:\n",
        "  print(\"You entered False\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write yes or no: no\n",
            "You entered False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEwXuwbscm8F",
        "outputId": "e6ebc1ea-7345-4501-df3b-cd5e2d601af0"
      },
      "source": [
        "set1 = (\"TWELVE PLUS ONE\")\n",
        "set2 = (\"ELEVEN PLUS TWO\")\n",
        "if set1 == set2:\n",
        "  print(\"We are the same!\")\n",
        "else:\n",
        "  print(\"We are not same!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We are not same!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mC-oPgfVXzFG",
        "outputId": "2b9368c0-775c-4ab5-916e-5fa60316cc94"
      },
      "source": [
        "bread = True\n",
        "minced = True\n",
        "grocery = True\n",
        "lettuce = True\n",
        "onion = True\n",
        "hamburger = (bread and lettuce or onion and minced and grocery)\n",
        "if hamburger :\n",
        "  print(\"Bon Appetit\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bon Appetit\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CtJhrj5PVzU0",
        "outputId": "36ee31b1-966c-42e7-ecf1-b4df02c333e0"
      },
      "source": [
        "if \"0\" and \"\":\n",
        "  print(\"Hello world\")\n",
        "print(\"me\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "me\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eLl6W9AiKkFl",
        "outputId": "b4644be9-d3ce-4181-8bbb-fcad334c4352"
      },
      "source": [
        "number = int(input('Please enter a number: '))\n",
        "num = 0\n",
        "while num < number:\n",
        "  print(num ** 2)\n",
        "  num += 1\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter a number: 3\n",
            "0\n",
            "1\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UlVk5kLoZ-4b",
        "outputId": "f5560899-5706-430e-f92d-74cc69396a66"
      },
      "source": [
        "a = int(input(\"write a number: \"))\n",
        "if a >= 999:\n",
        "   print(a ** 0)  \n",
        "else:\n",
        "   print(a * 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write a number: 998\n",
            "1996\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1vRviWsZj9RY",
        "outputId": "6d5303c2-456e-4342-fa82-3e9b3d16cf46"
      },
      "source": [
        "sen = \"My name is Michele\"\n",
        "reversed_sen = sen.split()\n",
        "rs_1 = reversed_sen[::-1]\n",
        "rs_2 = \" \".join(rs_1)\n",
        "print(rs_2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Michele is name My\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CAKtN5LPix4_",
        "outputId": "b0b433ae-c94e-4e69-916c-5f7d96548da0"
      },
      "source": [
        "n = str(input(\"write an integer: \"))\n",
        "nn = int(n+n)\n",
        "nnn = int(n+n+n)\n",
        "print(int(n) + nn + nnn)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write an integer: 5\n",
            "615\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3LgQRUGgfQQk",
        "outputId": "ae353cf7-a555-4ad2-fad2-c1e282e69415"
      },
      "source": [
        "#Write a Python program that accepts an integer (n) and computes the value of n+nn+nnn. \n",
        "sn = str(input(\"write an integer: \"))\n",
        "snn = sn + sn\n",
        "snnn = snn + sn\n",
        "print(int(sn) + int(snn) + int(snnn))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write an integer: 5\n",
            "615\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OMva2-UOain1",
        "outputId": "8d541e91-610f-4198-fd2a-ef9c2679a1e4"
      },
      "source": [
        "# Write a Python program to get the least common multiple (LCM) of two positive integers.\n",
        "x = int(input(\"Enter the first number: \"))\n",
        "y = int(input(\"Enter the second number: \"))\n",
        "if x > y:\n",
        "      z = x\n",
        "else:\n",
        "      z = y\n",
        "while(True):\n",
        "   if((z % x == 0) and (z % y == 0)):\n",
        "          lcm = z\n",
        "          break\n",
        "   z +=1\n",
        "print(lcm)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the first number: 4\n",
            "Enter the second number: 10\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5ECGEzs3ZBYx",
        "outputId": "6ccb2ba7-bdd4-4cc6-fef3-7921e9290a3c"
      },
      "source": [
        "num = 1234\n",
        "reversed_num = 0\n",
        "\n",
        "while num != 0:\n",
        "    digit = num % 10\n",
        "    reversed_num = reversed_num * 10 + digit\n",
        "    num //= 10\n",
        "\n",
        "print(\"Reversed Number: \" + str(reversed_num))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reversed Number: 4321\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gC_SMYdnV29-",
        "outputId": "909b3e5b-b73d-4f96-f2a1-96cf331a4b27"
      },
      "source": [
        "num = int(input(\"write an integer: \"))\n",
        "reversed_num = 0\n",
        "while num != 0:\n",
        "  digit = num % 10\n",
        "  reversed_num = reversed_num * 10 + digit\n",
        "  num //= 10\n",
        "\n",
        "print(str(reversed_num))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write an integer: 234\n",
            "432\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tKAtcmkwTdlr",
        "outputId": "45c85cae-e652-42b1-eb05-4220a71af2ad"
      },
      "source": [
        "str_x = \"Emma is good developer. Emma is a writer\"\n",
        "name = str_x.count(\"Emma\")\n",
        "print(\"Emma appeared {} times\".format(name))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Emma appeared 2 times\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4c07YEihN83n",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3f46820-82c9-4a75-e240-b73917791d5c"
      },
      "source": [
        "# Write a Python program to compute the greatest common divisor (GCD) of two positive integers\n",
        "from math import gcd\n",
        "num1 = int(input(\"write a positive integer: \"))\n",
        "num2 = int(input(\"write a positive integer: \"))\n",
        "print(gcd(num1, num2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write a positive integer: 64\n",
            "write a positive integer: 48\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tRcG08q5x_OR"
      },
      "source": [
        "numbers = []\n",
        "n = input(\"Enter number of integers: \")\n",
        "i = 0\n",
        "while i < int(n):\n",
        "    x = input(\"Enter an integer: \")\n",
        "    numbers.append(int(x))\n",
        "    i += 1\n",
        "j = 0\n",
        "for current in numbers:\n",
        "    if current > j:\n",
        "        j = current\n",
        "print(f\"The largest number is: {j}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3W1LZChnkPAF",
        "outputId": "121753e9-5b85-4b74-a586-8e7f4616a5f3"
      },
      "source": [
        "math_mark = int(input('Please enter the mark: '))\n",
        "if math_mark >= 85:\n",
        "  print(\"A\", \"(Excellent)\")\n",
        "elif math_mark >= 70:\n",
        "  print(\"B\")\n",
        "elif math_mark >= 60:\n",
        "  print(\"C\")\n",
        "elif math_mark >=45:\n",
        "  print(\"D\")\n",
        "else:\n",
        "  print(\"F\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter the mark: 87\n",
            "A (Excellent)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DdpDLHZag-ae",
        "outputId": "e7e9b860-1cf2-43f4-c999-716168066fc5"
      },
      "source": [
        "saved_amount = int(input('Please enter your saved amount: '))\n",
        "ps4_price = 600 \n",
        "if saved_amount <= ps4_price/2:\n",
        "  print(\"You must save more, keep saving!\")\n",
        "elif saved_amount > ps4_price:\n",
        "  print(\"Yippee! You can buy your PS4\")\n",
        "elif saved_amount > ps4_price/2:\n",
        "  print(\"You saved more than half, keep saving!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Please enter your saved amount: 301\n",
            "You saved more than half, keep saving!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QoBTSUKi1zP1",
        "outputId": "ed29a0dc-0268-4f6d-e5bb-e834c102574f"
      },
      "source": [
        "n = int(input('enter a number between 1-10'))\n",
        "\n",
        "for i in range(1,10,2):\n",
        "    print('{}x{} = '.format(n, i), n*i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter a number between 1-104\n",
            "4x1 =  4\n",
            "4x3 =  12\n",
            "4x5 =  20\n",
            "4x7 =  28\n",
            "4x9 =  36\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X_Uyx_rIvxVp",
        "outputId": "0e5105f1-1dd0-45af-d3eb-ecaa23354763"
      },
      "source": [
        "iterable = [1, 2, 3, 4]\n",
        "for i in iterable:\n",
        "  print(i * i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NE-gQR5-jCTq",
        "outputId": "8f08ff01-2f5e-4355-d96b-34cd605def24"
      },
      "source": [
        "test = {1, \"1\", 1.0}\n",
        "type(test)\n",
        "1 is 1.0 # is checks more details, value and type\n",
        "1 == 1.0 # checks only their values"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WgBo-88SNamD",
        "outputId": "e8e6b8be-da35-4664-cd42-852fc960b1d6"
      },
      "source": [
        "list = [1, None, 0]\n",
        "any(list)\n",
        "all(list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OE1aCO5WIwMC",
        "outputId": "725d1877-45cf-4b58-e13b-f4589129de60"
      },
      "source": [
        "usa_cap = set(\"Washington\")\n",
        "nz_cap = set(\"Wellington\")\n",
        "# print(usa_cap)\n",
        "# print(nz_cap)\n",
        "# print(len(usa_cap.union(nz_cap)))\n",
        "# print(type(nz_cap))\n",
        "a = nz_cap.remove(\"n\")\n",
        "print(a)\n",
        "print(nz_cap)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n",
            "{'g', 'e', 't', 'W', 'o', 'l', 'i'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yPKSkmzKICAJ",
        "outputId": "385e7d1f-687a-410f-9059-f048a4f50cb2"
      },
      "source": [
        "given_list = [1, 2, 3, 3, 3, 3, 4, 4, 5, 5]\n",
        "given_list = set([1, 2, 3, 3, 3, 3, 4, 4, 5, 5])\n",
        "print(given_list)\n",
        "given_list."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 2, 3, 4, 5}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5L55kNef_4Qx",
        "outputId": "6b0f49ff-378c-46ef-c4de-e9c8499166d4"
      },
      "source": [
        "friends = {\n",
        "       'friend1': {'first': 'Done', 'last': 'Khalif'},\n",
        "       'friend2': {'first': 'Nancy', 'last': 'Jim'}\n",
        "      }\n",
        "friends[\"friend2\"].update({\"second\": \"Pearl\"})\n",
        "print(friends)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'friend1': {'first': 'Done', 'last': 'Khalif'}, 'friend2': {'first': 'Nancy', 'last': 'Jim', 'second': 'Pearl'}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b4VvcNMLx7k2",
        "outputId": "7d584220-0d80-49e8-e3b7-bbbc966703f1"
      },
      "source": [
        "family = {'name1': 'Adam', \n",
        "          'name2': 'Yve',\n",
        "          'name3': 'Hannah'\n",
        "          }\n",
        "print(\"name3\" in family)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kCnBgTlJDXr-",
        "outputId": "91b15005-eaed-4eda-9918-284b322e15a7"
      },
      "source": [
        "set_1 = {'red', 'blue', 'pink', 'red'}\n",
        "colors = 'red', 'blue', 'pink', 'red'\n",
        "set_2 = set(colors)\n",
        "type(set_1)\n",
        "# print(set_1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "set"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tnujDt30BJH6",
        "outputId": "bb8383ad-e173-4ed0-be28-497cd50d844a"
      },
      "source": [
        "set_1 = {1, 4, 5}\n",
        "print(set_1, type(set_1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{1, 4, 5} <class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TDtZHiH4_kbg",
        "outputId": "d5b27277-d5d6-4ff8-e8bc-aac51f187a31"
      },
      "source": [
        "type([1, 2, 1, 0, 1])\n",
        "len({1, 2, 0, 1, 1})  # burda set oldugu icin 3 tekrar olmaz\n",
        " # len([1, 2, 0, 1, 1]) # list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PQv6Z8gd8IIv"
      },
      "source": [
        "favourite = {\n",
        "    'friends': {\n",
        "       'friend1': {'first' : 'Done', 'last' : 'Khalif'},\n",
        "       'friend2': {'first' : 'Nancy', 'last' : 'Jim'}\n",
        "      },\n",
        "    'family' : {\n",
        "        'name1': 'Adam', \n",
        "        'name2': 'Yve',\n",
        "        'name3': 'Hannah'\n",
        "      }\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "--PxUN211NNv",
        "outputId": "194afeeb-4b1b-4fa8-c6f6-210f89ad23db"
      },
      "source": [
        "school_records={\n",
        "\t'personal_info':\n",
        "\t\t{'kid':{'tom':{'class':'intermediate', 'age':10},\n",
        "\t\t\t'sue':{'class':'elemantary', 'age':8}\n",
        "\t\t\t},\n",
        "\t\t'teen':{'joseph':{'class':'college', 'age':19},\n",
        "\t\t\t'marry':{'class':'high school', 'age':16}\n",
        "\t\t\t},\n",
        "\t\t},\n",
        "\t'grades_info':\n",
        "\t\t{'kid':{'tom':{'math':88, 'speech':69},\n",
        "\t\t\t'sue':{'math':90, 'speech':81}\n",
        "\t\t\t},\n",
        "\t\t'teen':{'joseph':{'coding':80, 'math':89},\n",
        "\t\t\t'marry':{'coding':70, 'math':96}\n",
        "\t\t\t},\n",
        "\t\t}\n",
        "}\n",
        "len(school_records[\"personal_info\"])\n",
        "# print(school_records[\"personal_info\"][\"teen\"][\"joseph\"])\n",
        "# print(school_records[\"personal_info\"])\n",
        "# print(school_records[\"grades_info\"][\"teen\"][\"joseph\"])\n",
        "# print(list(school_records[\"grades_info\"][\"teen\"][\"joseph\"].items()))\n",
        "\n",
        "# print(school_records[\"personal_info\"][\"teen\"][\"marry\"][\"age\"])\n",
        "# marry_age = school_records[\"personal_info\"][\"teen\"][\"marry\"][\"age\"]\n",
        "# print(\"Marry is\", marry_age, \"years old.\")\n",
        "# print(\"Marry is\", marry_age, \"years old.\")\n",
        "# print(school_records[\"grades_info\"][\"teen\"][\"joseph\"])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8tTmFjYJpbGL",
        "outputId": "4ec3ca5f-7efd-4baf-c0fd-b42ea882bf38"
      },
      "source": [
        "flowers = ['Rose', 'Orchid', 'Tulip']\n",
        "count1 = len(flowers)\n",
        "\n",
        "while count1 >= 0 :\n",
        "    print(flowers)\n",
        "    count1 +=1\n",
        "    break\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Rose', 'Orchid', 'Tulip']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "44up9zypmjR4",
        "outputId": "4ca38b7d-17a3-4bc7-d34b-2275a2ad11a6"
      },
      "source": [
        "answer = 44\n",
        "\n",
        "question = 'What number am I thinking of?  '\n",
        "print (\"Let's play the guessing game!\")\n",
        "\n",
        "while True:\n",
        "    guess = int(input(question))\n",
        "    if guess < answer:\n",
        "        print('Little higher')\n",
        "    elif guess > answer:\n",
        "        print('Little lower')\n",
        "    else:  # guess == answer\n",
        "        print('Are you a MINDREADER!!!')\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Let's play the guessing game!\n",
            "What number am I thinking of?  50\n",
            "Little lower\n",
            "What number am I thinking of?  25\n",
            "Little higher\n",
            "What number am I thinking of?  38\n",
            "Little higher\n",
            "What number am I thinking of?  44\n",
            "Are you a MINDREADER!!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SFU-6wFCEOvQ"
      },
      "source": [
        "score = float(input('Please enter your score: '))\n",
        "\n",
        "if score >= 95:\n",
        "  print('Your grade is A+')\n",
        "elif score >= 90 and score < 95:\n",
        "  print('Your grade is A')\n",
        "elif score >= 85 and score < 90:\n",
        "  print('Your grade is B+')\n",
        "elif score >= 80 and score < 85:\n",
        "  print('Your grade is B')\n",
        "else:\n",
        "  print('Your grade is below B')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X_hZrHSUEOLn"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "To2Z9EhQU7xT",
        "outputId": "87528266-e398-41ed-e602-be5c5ae3040d"
      },
      "source": [
        "score = int (input(\"Enter your score :\"))\n",
        "if score >=0 and score <=100:\n",
        " if score >= 90:\n",
        "    if score >= 95:\n",
        "        Score_letter=\"A+\"\n",
        "    else:\n",
        "        Score_letter=\"A\"\n",
        " elif score >= 80:\n",
        "    if score >= 85:\n",
        "        Score_letter=\"B+\"\n",
        "    else:\n",
        "        Score_letter=\"B\"\n",
        " else:\n",
        "    Score_letter=\"below B\"\n",
        "    print(\"Your degree: %s\" % Score_letter)\n",
        "else:\n",
        "  print(\"please enter valid number.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter your score :102\n",
            "please enter valid number.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EfEA-c3s9L1Q",
        "outputId": "95edf38d-35dd-4e54-ad2d-4a79b27c27e1"
      },
      "source": [
        "number = -5\n",
        "if number >= 10:\n",
        "    print(\"The number is equal or greater than 10\")\n",
        "else:\n",
        "    print(\"The number is less than 10\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The number is less than 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YNljNofk6t-U",
        "outputId": "fe2be122-7c4b-434a-e01b-6d3e59bed6f4"
      },
      "source": [
        "triangle_h = int(input(\"write the height of triangle: \"))\n",
        "triangle_b = int(input(\"write the base of triangle: \"))\n",
        "triangle_area = ((triangle_h * triangle_b) / 2)\n",
        "print(triangle_area)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "write the height of triangle: 4\n",
            "write the base of triangle: 6\n",
            "12.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WmTkCeDL6mSD"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N1jggwjs5I3y",
        "outputId": "08df6cef-7e3d-4a8d-816e-8018174a31d2"
      },
      "source": [
        "mail = \"mailto: Clarusway admission@clarusway.com, 6 Haz 2021 Paz, 21:08 tarihinde sunu yazdi:\"\n",
        "print(mail[28:41])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "clarusway.com\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q2YL7oFdIymV"
      },
      "source": [
        "word = input(“Please enter your word :“).lower()\n",
        "my_set = set(word)\n",
        "Left_side = {‘q’, ‘w’, ‘e’, ‘r’, ‘t’, ‘a’, ‘s’, ‘d’, ‘f’, ‘g’, ‘z’, ‘x’, ‘c’, ‘v’, ‘b’}\n",
        "Right_side = {‘y’, ‘u’, ‘i’, ‘o’, ‘p’, ‘h’, ‘j’, ‘k’, ‘l’, ‘n’, ‘m’}\n",
        "bool = True\n",
        "if my_set == my_set.intersection(Left_side) :\n",
        "    print(not bool)\n",
        "elif my_set == my_set.intersection(Right_side) :\n",
        "    print(not bool)\n",
        "elif my_set:\n",
        "    print(bool)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l5ZP42T1fdi5",
        "outputId": "811618cd-9c8a-403c-e6af-abd6a160157a"
      },
      "source": [
        "word = input(\"Write a word: \").lower()\n",
        "word_1 = set(word)\n",
        "left_hand = set(['q', 'w', 'e', 'r', 't', 'a', 's', 'd', 'f', 'g', 'z', 'x', 'c', 'v', 'b'])\n",
        "right_hand = set(['y', 'u', 'i', 'o', 'p', 'h', 'j', 'k', 'l', 'n', 'm'])\n",
        "if(len(word_1.intersection(left_hand)) > 0 and len(word_1.intersection(right_hand)) > 0):\n",
        "  print(True)\n",
        "else:\n",
        "  print(False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write a word: mine\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ORCKRANC2qit",
        "outputId": "d7ff9ff3-fd8a-41b4-b882-8240c1fbe243"
      },
      "source": [
        "word = input(\"Write a word: \").lower()\n",
        "word_1 = set(word)\n",
        "print(word_1)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Write a word: Mine\n",
            "{'m', 'e', 'n', 'i'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R2Zf8IJV4rlR",
        "outputId": "885f9df9-3df2-4368-e596-2d34bdc90f88"
      },
      "source": [
        "print('abcdefcdghcd'.split('cd'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['ab', 'ef', 'gh', '']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DawYD7Y-4dYk",
        "outputId": "521a12f0-7592-4b99-aee0-689a301f4aa9"
      },
      "source": [
        "print(\"xyyzxyzxzxyy\".count('xyy', 2, 11))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 246
        },
        "id": "i_1_PHIvqleI",
        "outputId": "5857fafc-48d3-4bf2-9183-90f0ccb8d235"
      },
      "source": [
        "word = input(\"Write a word: \").lower()\n",
        "word = set()\n",
        "word_list1 = set('q', 'w', 'e', 'r', 't', 'a', 's', 'd', 'f', 'g', 'z', 'x', 'c', 'v', 'b')\n",
        "word_list2 = set('y', 'u', 'i', 'o', 'p', 'h', 'j', 'k', 'l', 'n', 'm')\n",
        "if word_list1 in word:\n",
        "   print(False)\n",
        "elif word_list2 in word:\n",
        "   print(False)\n",
        "#else \n",
        "  # print(True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Write a word: Mine\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-11-b58916a7f6ce>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mword\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Write a word: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlower\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mword\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mword_list1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'q'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'w'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'e'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'r'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m't'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'a'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m's'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'd'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'f'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'g'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'z'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'x'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'c'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'v'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'b'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mword_list2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'y'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'u'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'i'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'o'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'p'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'h'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'j'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'k'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'l'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'n'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'm'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mword_list1\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mword\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: set expected at most 1 arguments, got 15"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H1V1Lyf9MYkr",
        "outputId": "02165fb0-fbfd-4c18-d6cd-81338e064adf"
      },
      "source": [
        "strs = [\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\", \"cat\", \"tac\"]\n",
        "group = {}\n",
        "\n",
        "for i in strs :\n",
        "  kelime = \"\".join(sorted(i))\n",
        "  if kelime in group :\n",
        "    group[kelime].append(i)\n",
        "  else :\n",
        "    group[kelime] = [i]\n",
        "\n",
        "print(list(group.values()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat'], ['cat', 'tac']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OsVVzR5y_MLw",
        "outputId": "2cd5abb4-e0ab-460e-8634-e642dd71c429"
      },
      "source": [
        "from collections import defaultdict\n",
        "\n",
        "source = [\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\"]\n",
        " \n",
        "temporary = defaultdict(list)\n",
        "for element in source:\n",
        "  temporary[str(sorted(element))].append(element)\n",
        "result = list(temporary.values())\n",
        " \n",
        "print(*result, sep = \",\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['eat', 'tea', 'ate'],\n",
            "['tan', 'nat'],\n",
            "['bat']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kK9zqnhiy4Lf",
        "outputId": "a299bb67-4065-40ee-8a1b-f3a1e7348121"
      },
      "source": [
        "source_tuble = [\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\"],\n",
        "words_list = list(source_tuble)\n",
        "print(type(words_list))\n",
        "new_list = {}\n",
        "print(type(new_list))\n",
        "for ele in words_list:\n",
        "  print(ele)\n",
        "  # new_list[str(sorted(ele))].append(ele)\n",
        "result = list(new_list.values())\n",
        "print(new_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'>\n",
            "<class 'dict'>\n",
            "['eat', 'tea', 'tan', 'ate', 'nat', 'bat']\n",
            "{}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RjF-IdvRnZZ5",
        "outputId": "f3c0422d-8ddd-4964-c187-67a0fa4837f4"
      },
      "source": [
        "class Solution:\n",
        "   def groupAnagrams(self, strs):\n",
        "      result = {}\n",
        "      for i in strs:\n",
        "         x = \"\".join(sorted(i))\n",
        "         if x in result:\n",
        "            result[x].append(i)\n",
        "         else:\n",
        "            result[x] = [i]\n",
        "      return list(result.values())\n",
        "ob1 = Solution()\n",
        "print(ob1.groupAnagrams([\"eat\", \"tea\", \"tan\", \"ate\", \"nat\", \"bat\"]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[['eat', 'tea', 'ate'], ['tan', 'nat'], ['bat']]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "Feg90bnaujzo",
        "outputId": "51b2663e-e1a9-4f40-9246-f3cb869e0cb2"
      },
      "source": [
        "for i in {'n1' : 'one', 'n2' : 'two'}: \n",
        "print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "IndentationError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-15-754ff79889fa>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(i)\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n-Y3RLh1gPmR",
        "outputId": "47d4352f-ee58-4621-c8a6-354db1408d78"
      },
      "source": [
        "flowers = ['Rose', 'Orchid', 'Tulip']\n",
        "count1 = len(flowers)\n",
        "count2 = 0\n",
        "\n",
        "while count1 >0 :\n",
        "    print(flowers[count2])\n",
        "    count1 -= 1\n",
        "    count2 += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rose\n",
            "Orchid\n",
            "Tulip\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-MdHVod8m7Wq",
        "outputId": "8d914cf3-1a64-4b36-dec8-5610600575b1"
      },
      "source": [
        "numbers = [2, 3, 6, 1, 7, 2, 5, 2, 3]\n",
        "# print(type(numbers))\n",
        "mostCommon = max(numbers, key=numbers.count)\n",
        "# print(mostCommon)\n",
        "counts2 = numbers.count(mostCommon)\n",
        "print(\"the most frequent number is {} and it was {} times repeated\".format(mostCommon, counts2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the most frequent number is 2 and it was 3 times repeated\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hq_wGW1lmQas",
        "outputId": "2881ed8a-173a-4184-8dd4-091ed36efbd0"
      },
      "source": [
        "numbers = [1, 3, 7, 4, 3, 0, 3, 6, 3]\n",
        "mostCommon = max(numbers, key = numbers.count)\n",
        "counts_time = numbers.count(mostCommon)\n",
        "print(\"the most frequent number is {} and it was {} times repeated\".format(mostCommon, counts_time))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the most frequent number is 3 and it was 4 times repeated\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KAETlzEjZNAP",
        "outputId": "92825d2e-c714-4394-ebc7-2a9a52f16349"
      },
      "source": [
        "\n",
        "numbers = [1, 3, 7, 4, 3, 0, 3, 6, 3]\n",
        "count = numbers.count(3)\n",
        "print(\"the most frequent number is 3\", \"and it was\", count, \"times repeated\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "the most frequent number is 3 and it was 4 times repeated\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jSGYgvBdYRQE",
        "outputId": "0b0327a4-b803-4360-fe3b-3cb3687541d3"
      },
      "source": [
        "family_members = ['Meghan', 'Tom', 'Nicole', 'Tim']\n",
        "print(tuple(family_members))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Meghan', 'Tom', 'Nicole', 'Tim')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5lKr-GHJWsoz",
        "outputId": "13eb29b3-e53c-4cb9-dc61-c8e4510afb55"
      },
      "source": [
        "fruits_vegetables = [\"fruit\", \"vegetable\", [\"apple\", \"banana\", [\"mango\", \"avocado\"]], [\"spinach\", \"broccoli\"]]\n",
        "print(fruits_vegetables[3][0], type(fruits_vegetables))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "spinach <class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9i3cgU6pWGf3",
        "outputId": "2ec4919d-d728-4317-c932-5c4dd0870336"
      },
      "source": [
        "numbers_10 = [10, 30, 40, 50, 60, 70, 80, 90, 100]\n",
        "numbers_10.insert(1, 20)\n",
        "print(numbers_10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZckGbpM-VkCE",
        "outputId": "e191d9c8-c276-48f2-e37d-21ac871bb35f"
      },
      "source": [
        "numbers = {}\n",
        "\n",
        "numbers['x'] = 12\n",
        "numbers['y'] = 4\n",
        "numbers.update({'z': 3})\n",
        "\n",
        "print(numbers['x'] + numbers['y'] + numbers['z']**2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "25\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NZ_wXEuNmCex"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Ji6-4boXFYJ"
      },
      "source": [
        "family.update(name4 = ‘Joseph’)\n",
        "print(family)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tCsX8RWBT9f8",
        "outputId": "e33102ff-dbc2-4c1d-ae08-e04bf714a161"
      },
      "source": [
        "family = {'name1': 'Adam', \n",
        "          'name2': 'Yve',\n",
        "          'name3': 'Hannah'\n",
        "          }\n",
        "family.update(name4 = 'Joseph')\n",
        "family.update({\"name5\":\"Yasmin\"})\n",
        "# print(family)\n",
        "# del family[\"name2\"], family[\"name3\"]\n",
        "# print(family)\n",
        "list(family.items())\n",
        "list(family.values())\n",
        "dict(family)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'name1': 'Adam',\n",
              " 'name2': 'Yve',\n",
              " 'name3': 'Hannah',\n",
              " 'name4': 'Joseph',\n",
              " 'name5': 'Yasmin'}"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XW3eduiXP0S4",
        "outputId": "23927848-090e-4ba6-ee95-5491b44a2f2d"
      },
      "source": [
        "mix_values = {'animal': ('dog', 'cat'),  \n",
        "              'planet': ['Neptun', 'Saturn', 'Jupiter'], \n",
        "              'number': 40,  \n",
        "              'pi': 3.14,  \n",
        "              'is_good': True}  \n",
        "\n",
        "mix_keys = {22 : \"integer\",\n",
        "            1.2 : \"float\",\n",
        "            True : \"boolean\",\n",
        "            \"key\" : \"string\"}\n",
        "print(mix_keys[1.2])\n",
        "\"number\" not in mix_values\n",
        "40 in mix_values.values()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "float\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "svoZR-kTy8yk",
        "outputId": "c5ee15bc-4500-44d6-b3e6-404200c98970"
      },
      "source": [
        "\"h\" in 'float'\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "drozs9M2N_Ju",
        "outputId": "9e2bc87f-8516-4180-d66e-d579063ff26e"
      },
      "source": [
        "state_capitals = {'Arkansas': 'Little Rock',\n",
        "                  'Colorado': 'Denver',\n",
        "                  'California': 'Sacramento',\n",
        "                  'Georgia': 'Atlanta' \n",
        "                 }\n",
        "state_capitals['Georgia'] = 'chicago'\n",
        "print(state_capitals)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Arkansas': 'Little Rock', 'Colorado': 'Denver', 'California': 'Sacramento', 'Georgia': 'chicago'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4yP3sk5mK87o",
        "outputId": "44c46897-cb02-4e55-a934-839da28f88eb"
      },
      "source": [
        "grocery1 = {'fruit':'apple', 'drink':'water'}\n",
        "grocery2 = dict(fruit='apple', drink='water')\n",
        "print(grocery1)\n",
        "print(grocery2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'fruit': 'apple', 'drink': 'water'}\n",
            "{'fruit': 'apple', 'drink': 'water'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zas2m9LdzTsF"
      },
      "source": [
        "set([1,2,2,3,4,5])\n",
        "{1,2,3,4}\n",
        "set((1,2,3,4))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FpGuKLBwzIWT",
        "outputId": "338dee9f-ef22-4836-d507-9e0dffc20ceb"
      },
      "source": [
        "a = {1,2,3,4}\n",
        "print(type(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "geS6FiTokF48",
        "outputId": "9b26a597-a1e4-450e-8f54-d972673f6e9b"
      },
      "source": [
        "student_ages = {\"Harry\": 29,\n",
        "                \"Clark\": 32,\n",
        "                \"Peter\": 22,\n",
        "                \"Bruce\": 36\n",
        "                }\n",
        "print(student_ages[\"Clark\"])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mq-Nw2zaXHSc",
        "outputId": "43e4236b-d8c0-41a9-cc37-f745d334f510"
      },
      "source": [
        "escapes = [\"\\n\\t\", (\"\\t\", \"\\t\\t\"), [\"\\n\", \"\\n\\t\\t\"]]\n",
        "\n",
        "sentence = \"I am 40 years old. {} I have two children. {} Data Science is my IT domain.\"\n",
        "\n",
        "print(sentence.format(escapes[0], escapes[2][1]))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I am 40 years old. \n",
            "\t I have two children. \n",
            "\t\t Data Science is my IT domain.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ET_LNnpJXHIi",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd44ec5d-0eb7-4350-8e24-d59474e50fa9"
      },
      "source": [
        "sehirler = [\"ankara\", \"agri\", \"istanbul\", \"van\"]\n",
        "sehirler.sort(key=len)\n",
        "print(sehirler)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['van', 'agri', 'ankara', 'istanbul']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Z1Zcv31XG88",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "884fd68b-3a72-4706-d693-b98d73d7413a"
      },
      "source": [
        "print(len(set('listen to the voice of enlisted')))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_DuynTUyXGte"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1SPmRe1vQ9HC",
        "outputId": "662c8eee-8d4e-41b2-c540-5d39f1029e65"
      },
      "source": [
        "flowers = [[\"jasmine\", [\"lavender\", \"rose\"], \"tulip\"]]\n",
        "colors = [\"red\", (\"blue\", [\"yellow\", \"green\"]), \"pink\"]\n",
        "# text = \"My two favorite flowers {} and {}, two favorite colors are {} and {}.\".fromat((flowers[2][1][1]), colors([1][0][1][1][1]))\n",
        "text = \"My two favorite flowers {} and {}, two favorite colors are {} and {}.\"\n",
        "print(text.format(flowers[0][2], flowers[0][1][1], colors[1][0], colors[1][1][1]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My two favorite flowers tulip and rose, two favorite colors are blue and green.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N4FS4zEAOwEs",
        "outputId": "8a6b63a3-9e5b-44e7-ed81-c9df58f942f9"
      },
      "source": [
        "grocer = [\"banana\", [\"orange\", [\"apple\", \"eggplant\", \"melon\", \"spinach\", \"cheese\", \"leek\" ], \"water\"], \"mandarin\"]\n",
        "print(grocer[1][1][1:6:2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['eggplant', 'spinach', 'leek']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d0UUPWdpJD9u",
        "outputId": "b42f1ffe-9524-4787-e08b-617d333d8cea"
      },
      "source": [
        "my_list = list(range(1,11))\n",
        "my_list.sort(reverse=True)\n",
        "print(my_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pkR0CyF-NagA",
        "outputId": "e2050183-bb4e-4b4d-af5a-678ad6613bb8"
      },
      "source": [
        "mix_tuple = (\"11\", 11, [2, \"two\", (\"six\", 6)], (5, 'fair'))\n",
        "print(mix_tuple[3][1])\n",
        "print(mix_tuple[-1][-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fair\n",
            "fair\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N2PPO9Cs8VH5",
        "outputId": "707604a8-4ffa-4d9f-c37a-8d59fc88764b"
      },
      "source": [
        "myData = 1\n",
        "print(type(myData))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kd4jnxdE7HZa",
        "outputId": "e3bbb643-825e-403a-896c-459ee26fa43d"
      },
      "source": [
        "my_tuple = (\"Solar\")\n",
        "print(my_tuple, type(my_tuple), sep=\"\\n\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Solar\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l-5B5RgQoIm1",
        "outputId": "df903d0a-20b3-4de6-dafe-d8fd8b85007d"
      },
      "source": [
        "planets = \"mars\", \"jupiter\", \"earth\"\n",
        "print(planets)\n",
        "print(type(planets))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('mars', 'jupiter', 'earth')\n",
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pUyE31duxX59"
      },
      "source": [
        "num = [[1, 2, 3, [4, 5, [6, 7, 8]]]]]\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LhFq0NWDxz5A"
      },
      "source": [
        "[['New York', 'London', 'Istanbul', 'Seoul', 'Sydney'],\n",
        " ['red', 'purple', 'blue', 'yellow', 'green'],"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YbbRYtNKfUnb",
        "outputId": "dd10415a-ed8a-4a09-cca4-5e772b6cb38d"
      },
      "source": [
        "print([[12, 34, 56]][0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[12, 34, 56]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nNXtZa3hedh-",
        "outputId": "18750202-7d45-408b-f357-b87024f3dfe8"
      },
      "source": [
        "print(len([[12, 34, 56]]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m6EZ2dqCePZn",
        "outputId": "223bebbb-d623-4f9d-8635-726037106883"
      },
      "source": [
        "print(len([[12, 34, 56]][0]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q8810BArYrCp",
        "outputId": "893302fb-163c-4fbe-9f43-a86494320dcb"
      },
      "source": [
        "city_list = [['New York', 'London', 'Istanbul', 'Seoul', 'Sydney'], [2, 5]]\n",
        "print(city_list[1][0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HTYhCTVFu3L0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a65d3c4f-52a2-4cd7-8a29-49ca19432b44"
      },
      "source": [
        "warning = 'You must quit smoking!'\n",
        "\n",
        "print(len(list(warning)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "22\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "6M0h4nyQPiiO",
        "outputId": "4d1eeebc-c0d0-4687-9853-1e7178068109"
      },
      "source": [
        "word1 = \"asdfilzxkjhg\"\n",
        "word2 = \"ijklgfhtcdsa\"\n",
        "if [0:]\n",
        "  print(\"This is an anagram.\")\n",
        "else\n",
        "  print(\"This is not an anagram.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-e525848fee4d>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    if (word1 = word2)\u001b[0m\n\u001b[0m              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uB-zLkdFPiR6"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5_Jg3DObGCgB",
        "outputId": "db39b8e7-e86c-437c-ec6a-d2b5c6292503"
      },
      "source": [
        "example = \"snow_world\"\n",
        "print(example[4:7])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "_wo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ebUrTfRsFdel",
        "outputId": "727c8a44-1571-4654-98ab-d7a5680e9642"
      },
      "source": [
        "print(format(\"Welcome\" + \" 10s\"), end = '#') \n",
        "print(format(111, \"4d\"), end = '#') \n",
        "print(format(924.656, \"3.2f\"))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Welcome 10s# 111#924.66\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZZ4wVw83HowK",
        "outputId": "c34d45ef-6f00-451f-b7c1-e15f98f8d43f"
      },
      "source": [
        "print(\"xyyzxyzxzxyy\".count('yy', 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xqMFM4eaI6WZ",
        "outputId": "d47e1f01-ce0f-4043-c838-26d11ab00d21"
      },
      "source": [
        "print(\"xyyzxyzxzxyy\".endswith(\"xyy\", 0, 3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OsB8ZDwXEQlJ",
        "outputId": "baf1b682-9cbc-4619-ccbf-dd37ece3a9a9"
      },
      "source": [
        "print(chr(ord('b') + 1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "c\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 215
        },
        "id": "6EIwgL3jYuYU",
        "outputId": "ba84d2ea-d73c-410c-c9ec-dfb27c430fcc"
      },
      "source": [
        "nums = []\n",
        "nums.append(1)\n",
        "nums.append(2)\n",
        "nums.append(3)\n",
        "nums.insert(2, 5)\n",
        "print(nums)\n",
        "nums.sort()\n",
        "print(sort)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 5, 3]\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-75-3f7690ea0ecc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnums\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mnums\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'sort' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yqiqd2qRUShx",
        "outputId": "bd10e403-e162-4f5f-b255-8dfbc3598207"
      },
      "source": [
        "mty = []\n",
        "mty.append('3*5')\n",
        "print(mty)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['3*5']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HR8JDwoPWhgc",
        "outputId": "29018694-b248-4da3-b423-34296a1e48e4"
      },
      "source": [
        "[0, 'a', (1+2)], [2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([0, 'a', 3], [2])"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9HitTMN6YhEN"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eUV1PLfcF8MI",
        "outputId": "1be8daee-479f-495b-92f1-9ae25ed9b9e7"
      },
      "source": [
        "city = \"SARAJEVO\"\n",
        "text = f\"{city.title()}\"\n",
        "print(\"I live in\", text)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I live in Sarajevo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sSn2nDN6Io_n",
        "outputId": "f82739f1-58b7-4f84-954b-2e34a684ad4a"
      },
      "source": [
        "country = [5, 'a', 'p', 'p', 'y']\n",
        "print(country)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5, 'a', 'p', 'p', 'y']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hHNjGZp0Jvwi",
        "outputId": "d29f461f-5f8e-46c9-caf1-08c849d174af"
      },
      "source": [
        "string_1 = 'I quit smoking'\n",
        "new_list_1 = list(string_1)\n",
        "print(new_list_1)\n",
        "\n",
        "new_list_2 = [string_1]\n",
        "print(new_list_2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['I', ' ', 'q', 'u', 'i', 't', ' ', 's', 'm', 'o', 'k', 'i', 'n', 'g']\n",
            "['I quit smoking']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f8ojgySt1eLK",
        "outputId": "5983d361-c447-4dee-b73f-bd4c09b14d18"
      },
      "source": [
        "print(False or {0} and [])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gjSg3uiGB6DF",
        "outputId": "34f90447-48d5-4d79-e9bb-0ce4ee8f3db6"
      },
      "source": [
        "print(int(\"5\" + \"1\"))\n",
        "print(str(\"5\" + \"1\"))\n",
        "print(\"5\" + \"1\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "51\n",
            "51\n",
            "51\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k3YEFVMw0kJh",
        "outputId": "30b1afbe-592f-44d7-86db-658a7aded314"
      },
      "source": [
        "section_3_5 = \"python data types and useful operations\"\n",
        "print(section_3_5.title())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python Data Types And Useful Operations\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qyehLXHqPwGw",
        "outputId": "ca71ca2e-a9b5-4aff-e5fb-943b0aa40e3c"
      },
      "source": [
        "age = input(\"Are you a cigarette addict older than 75 years old?(Please answer as a Yes or No): \")\n",
        "chronic = input(\"Do you have a severe chronic disease?(Please answer as a Yes or No): \")\n",
        "immune = input(\"Is your immune system too weak?(Please answer as a Yes or No): \")\n",
        "if age == \"Yes\" or chronic == \"Yes\" or immune == \"Yes\":\n",
        "  print(bool(\"There is a risk of death\"))\n",
        "else:\n",
        "  print(bool())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Are you a cigarette addict older than 75 years old?(Please answer as a Yes or No): No\n",
            "Do you have a severe chronic disease?(Please answer as a Yes or No): No\n",
            "Is your immune system too weak?(Please answer as a Yes or No): No\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KJkBgyb7fusH",
        "outputId": "3a688dc2-bb8b-4785-f735-629d908eecef"
      },
      "source": [
        "print('www', 'clarusway', \"com\", sep='.', end=' ')\n",
        "print('will', end=' ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "www.clarusway.com will "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rcaVg45xgCCD",
        "outputId": "8d17171c-86f5-46d5-a8f2-f1af6f7e2217"
      },
      "source": [
        "print('www', 'clarusway', \"com\", sep='.')\n",
        "print('will', end=' ')\n",
        "print('open', end=' ')\n",
        "print('your', end=' ')\n",
        "print('path', end='.')\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "www.clarusway.com\n",
            "will open your path."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "th9K5AragREB",
        "outputId": "dcce4536-5503-4134-fe86-f511b994aae5"
      },
      "source": [
        "print('clarusway' + str(2020))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "clarusway2020\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "id": "ZwAoz9Igj5ch",
        "outputId": "0016e7df-9419-49c7-d800-7786e451806e"
      },
      "source": [
        "print(\"32\" + int(1988))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-37-bb7c6e65be7e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"32\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1988\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6hisvTPFfTI0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ecbef539-13a2-4804-ae1f-da133ccf9b3e"
      },
      "source": [
        "age = input(\"Are you a cigarette addict older than 75 years old?(Y/N): \")\n",
        "chronic = input(\"Do you have a severe chronic disease?(Y/N): \")\n",
        "immune = input(\"Is your immune system too weak?(Y/N): \")\n",
        "result = False\n",
        "\n",
        "if not((age == \"Y\" or age == \"N\") and (chronic == \"Y\" or chronic == \"N\") and (immune == \"Y\" or immune == \"N\")):\n",
        "  print(\"user did not enter proper values.\")\n",
        "elif ():\n",
        "  result = True\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Are you a cigarette addict older than 75 years old?(Y/N): N\n",
            "Do you have a severe chronic disease?(Y/N): N\n",
            "Is your immune system too weak?(Y/N): W\n",
            "user did not enter proper values.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "OTFOGpqENfg3",
        "outputId": "c4ad58fb-1d80-415a-fdd6-672f52e73167"
      },
      "source": [
        "text = 'In God wee trust'\n",
        "text2 = 'we'\n",
        "f'In God {text2} trust'\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'In God we trust'"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9T-1enPKoMhO"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ceP8EppMmSfW"
      },
      "source": [
        "# New Section"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AQGCrWvPqOy-",
        "outputId": "cb9c4280-166d-4f80-a08a-0c74fbcbec4c"
      },
      "source": [
        "var_str = 'In God we Trust'\n",
        "print(var_str.lower())\n",
        "print(var_str)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "in god we trust\n",
            "In God we Trust\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f2slgQ_ayAWX",
        "outputId": "4f9cf47a-34db-4e90-d63d-0b35da5c25eb"
      },
      "source": [
        "phrase = \"myemailaddress@clarusway.com\"\n",
        "\n",
        "print(len(phrase))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "28\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sT5ABXvBefBa",
        "outputId": "5ebd3929-ef40-4e82-fc60-66989eca2525"
      },
      "source": [
        "print(\"{6} {0} {5} {3} {4} {1} {2}\".format('have', 6, 'months', 'a job', 'in', 'found', 'I will'))\n",
        "                "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I will have found a job in 6 months\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "st5cWMMipbuv",
        "outputId": "cca8da46-9c36-43c0-ed94-88673e52f8a3"
      },
      "source": [
        "temp_Celcius = float(input(\"Enter the temperature at Celsius degree: \"))\n",
        "temp_Fahrenheit = 1.8 * temp_Celcius + 32\n",
        "print(\"Temperature is\", temp_Fahrenheit, \"\\bF\", \"degree.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the temperature at Celsius degree: 10\n",
            "Temperature is 50.0 \bF degree.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kEqbQVYxb3br",
        "outputId": "1616153a-1299-431d-d639-20748f6ef077"
      },
      "source": [
        "str_one = 'upper'\n",
        "print(* str_one)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "u p p e r\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Gm4WZSXbi_XQ",
        "outputId": "03cb80de-2a46-435a-b221-01796724b108"
      },
      "source": [
        "distance1 = float(input(\"Enter the distance in kilometers: \"))\n",
        "distance2 = distance1 / 1.609344\n",
        "print(distance2, \"mile\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the distance in kilometers: 2\n",
            "1.242742384474668 mile\n"
          ]
        }
      ]
    }
  ]
}