main.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comments\n",
    "\n",
    "These are the lines in the code which are not identified by the interpreter                           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This is a comment"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables\n",
    "\n",
    "These store some type of data inside them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#normal method of printing\n",
    "print(\"Hello World!\") \n",
    "\n",
    "#storing the value in a variable and printing\n",
    "name = \"Ashutosh\"\n",
    "print(name)\n",
    "\n",
    "width, height = 10, 5\n",
    "print(width, height)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Input\n",
    "\n",
    "Allows the user to provide/input some sort of data which can be stored in variables and then used in the code later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"Enter your name: \")\n",
    "print(\"hi \" + name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number1 = input(\"Enter the first number: \")\n",
    "number2 = input(\"Enter the second number: \")\n",
    "\n",
    "print(number1 + number2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Data Types\n",
    "\n",
    "1. `strings` = \"ashutosh\" \"coding\"\n",
    "2. `int` = 3 11 2007\n",
    "3. `float` = 3.11 11.3 20.07\n",
    "4. `lists` = [\"Ashutosh\", \"Swamy\"] [23, 32]\n",
    "5. `dictionaries` = {key: value}\n",
    "6. `boolean` = true false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number1 = int(input(\"Enter the first number: \"))\n",
    "number2 = int(input(\"Enter the second number: \"))\n",
    "print(number1 + number2)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mathematical Operations\n",
    "\n",
    "1. `+` = To add two numbers\n",
    "2. `-` = To subtract two numbers\n",
    "3. `*` = To multiply two numbers\n",
    "4. `/` = To divide two numbers\n",
    "5. `//` = To divide two numbers but get an approx answer\n",
    "6. `%` = To get the remainder of a number\n",
    "7. `**` = To get the exponent of a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tip Calculator\n",
    "bill_amount = int(input(\"Enter the bill amount: \"))\n",
    "tip_percentage = int(input(\"Enter the tip percentage: \"))\n",
    "tip = (tip_percentage / 100) * bill_amount\n",
    "total_bill = bill_amount + tip\n",
    "\n",
    "#printing with normal method of concatenating\n",
    "print(\"Bill Amount: $\" + str(bill_amount))\n",
    "print(\"Tip Percentage: \" + str(tip_percentage) + \"%\")\n",
    "print(\"Total Bill: $\" + str(total_bill))\n",
    "\n",
    "#printing with the help of strig formatting\n",
    "print(f\"Bill Amount: ${bill_amount}\")\n",
    "print(f\"Tip Percentage: {tip_percentage}%\")\n",
    "print(f\"Total Bill: ${total_bill}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods to make your strings look good\n",
    "\n",
    "1. `\\n` = Get on the new line\n",
    "2. `\\t` = Adds tab"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If Else Statements\n",
    "\n",
    "In this first we set an intial condition, if that condition is true then the code written in the `if` block runs but if the condition is not true then the code written in the `else` block runs\n",
    "\n",
    "```\n",
    "if withdrawal_amount is greater than the balance\n",
    "    deny withdrawal\n",
    "else\n",
    "    accept withdrawal\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Basic Weather App\n",
    "weather = \"rain\"\n",
    "\n",
    "if weather == \"rain\":\n",
    "    print(\"Carry an umbrella\")\n",
    "else:\n",
    "    print(\"Carry your sunglasses\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comparison Operators\n",
    "\n",
    "1. `>` = Greater than\n",
    "2. `<` = Less than\n",
    "3. `>=` = Greater than or equal to\n",
    "4. `<=` = Less than or equal to\n",
    "5. `==` = To compare any two values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding input to the weather app and adding more than two conditions\n",
    "weather = str(input(\"How's the weather?:  \"))\n",
    "\n",
    "if weather == \"rain\":\n",
    "    print(\"Carry your umbrella\")\n",
    "elif weather == \"cloudy\":\n",
    "    print(\"rain anytime\")\n",
    "elif weather == \"thunderstorm\":\n",
    "    print(\"don't go out\")\n",
    "else:\n",
    "    print(\"Carry your sunglasses\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Grading System\n",
    "\n",
    "score = 94\n",
    "\n",
    "if score >= 90:\n",
    "    print(\"A\")\n",
    "elif score >= 80:\n",
    "    print(\"B\")\n",
    "elif score >= 70:\n",
    "    print(\"C\")\n",
    "elif score >= 60:\n",
    "    print(\"D\")\n",
    "else:\n",
    "    print(\"F\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical Operators\n",
    "\n",
    "1. `and` = To check two conditions at once\n",
    "2. `or` = One condition must be true out of the two conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = 69\n",
    "\n",
    "if score >= 60 and score <= 100:\n",
    "    print(\"you passed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = 54\n",
    "\n",
    "if score <= 60 or score >= 100:\n",
    "    print(\"you passed or failed\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions or Definations\n",
    "\n",
    "These are lines of code which can be used as many times as you want and you can use it anywhere you want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating the function\n",
    "def say_my_name():\n",
    "    print(\"Ashutosh Swamy\")\n",
    "    print(\"Pratibha Swamy\")\n",
    "    print(\"Vishwanath Swamy\")\n",
    "\n",
    "#calling the function\n",
    "say_my_name()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using arguments in the function\n",
    "def say_my_name(name):\n",
    "    print(name)\n",
    "\n",
    "say_my_name(\"Ashutosh Swamy\")\n",
    "say_my_name(\"Pratibha Swamy\")\n",
    "say_my_name(\"Vishwanath Swamy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greeting(name):\n",
    "    print(f\"Hi, {name}\")\n",
    "\n",
    "greeting(\"Ashutosh Swamy\")\n",
    "greeting(\"Pratibha Swamy\")\n",
    "greeting(\"Vishwanath Swamy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using multiple arguments in the function\n",
    "def greeting(greet, name):\n",
    "    print(f\"{greet}, {name}\")\n",
    "\n",
    "greeting(\"hello\", \"ashutosh\")\n",
    "greeting(\"hola\", \"ashutosh\")\n",
    "greeting(\"aloha\", \"ashutosh\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using arguments but one of them has a fixed value in the function declaration\n",
    "def greeting(name, greet=\"Hello\"):\n",
    "    print(f\"{greet}, {name}\")\n",
    "\n",
    "greeting(\"ashutosh\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using named arguments\n",
    "def greeting(greet, name):\n",
    "    print(f\"{greet}, {name}\")\n",
    "\n",
    "greeting(greet=\"hello\", name=\"ashutosh\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Take two numbers as the argument and return rhe sum of those numbers\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "\n",
    "print(add(11, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "sum = add(11, 3)\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Converting the Tip Calculator into a function\n",
    "def tip_calculator(bill_amount, tip_percentage):\n",
    "    tip = (tip_percentage / 100) * bill_amount\n",
    "    total_bill = bill_amount + tip\n",
    "    print(f\"Bill Amount: ${bill_amount}\")\n",
    "    print(f\"Tip Percentage: {tip_percentage}%\")\n",
    "    print(f\"Total Bill: ${total_bill}\")\n",
    "\n",
    "tip_calculator(230, 12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Converting the Basic Weather App into a function\n",
    "def weather_to_emoji(weather):\n",
    "    if weather == \"rainy\":\n",
    "        print(\"☔\")\n",
    "    elif weather == \"cloudy\":\n",
    "        print(\"☁️\")\n",
    "    elif weather == \"thunderstorm\":\n",
    "        print(\"⛈️\")\n",
    "    else:\n",
    "        print(\"😎\")\n",
    "\n",
    "weather_to_emoji(\"thunderstorm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Assigning the data type to the arguments of the functions and the return type of the function\n",
    "def weather(weather: str) -> None:\n",
    "    if weather == \"rainy\":\n",
    "        print(\"☔\")\n",
    "    elif weather == \"cloudy\":\n",
    "        print(\"☁️\")\n",
    "    elif weather == \"thunderstorm\":\n",
    "        print(\"⛈️\")\n",
    "    else:\n",
    "        print(\"😎\")\n",
    "\n",
    "weather_to_emoji(\"rainy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a: int, b: int) -> int:\n",
    "    return a + b\n",
    "\n",
    "print(add(12, 12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tip_calculator(bill_amount: float, tip_percentage: int) -> float:\n",
    "    tip = (tip_percentage / 100) * bill_amount\n",
    "    total_bill = bill_amount + tip\n",
    "    return f\"Bill Amount: ${bill_amount}\\nTip Percentage: {tip_percentage}%\\nTotal Bill: ${total_bill}\"\n",
    "\n",
    "print(tip_calculator(230.7, 12))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function to compare two values and return the bigger one\n",
    "def bigger_guy(a: int, b: int) -> int:\n",
    "    if a > b:\n",
    "        return a\n",
    "    else:\n",
    "        return b\n",
    "    \n",
    "print(bigger_guy(11, 3))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lambda Functions\n",
    "\n",
    "These functions don't have a special identity, they are anonymous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum = lambda a, b: a + b\n",
    "print(sum(11, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = lambda greet, name: f\"{greet}, {name}\"\n",
    "print(greeting(\"Hello\", \"Ashutosh\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assert Testing\n",
    "\n",
    "This helps in testing your code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum = lambda a, b: a + b\n",
    "\n",
    "assert sum(2, 3) == 5, \"Not returning the desired output\"\n",
    "assert sum(-20, 20) == 0, \"Not returning the desired output\"\n",
    "\n",
    "print(\"Sum Function: All tests passed\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays or Lists \n",
    "\n",
    "These are the collection of different values of different data types or same data type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using append() function to add elements to the list\n",
    "numbers = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
    "print(numbers)\n",
    "numbers.append(33)\n",
    "print(numbers)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing\n",
    "\n",
    "It shows the position of an element in the list but indexing starts with 0, this means that first element of an array possess the index number 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Printing the elements of the list according to the index number\n",
    "numbers = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
    "print(numbers)\n",
    "print(numbers[0])\n",
    "print(numbers[1])\n",
    "print(numbers[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Printing the last element of the list\n",
    "numbers = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
    "print(numbers[-1])\n",
    "print(numbers[-2])\n",
    "print(numbers[-3])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing\n",
    "\n",
    "Printing the elements of the list from the start index to end index provided, in this the start index in inclusive and the end index is exclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
    "print(numbers[0:3])\n",
    "print(numbers[0:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Printing the length of the list\n",
    "numbers = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
    "print(len(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Indexing and slicing through the string\n",
    "name = \"Hello, I am Ashutosh Swamy\"\n",
    "print(name[1])\n",
    "print(name[0:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Revering the list\n",
    "numbers = [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]\n",
    "print(numbers[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#List with different data types\n",
    "mixed_list = [3, 11, \"Ashutosh\", 20.07, [11, 3]]\n",
    "print(mixed_list)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some pre-defined functions for lists\n",
    "\n",
    "1. `append()`\n",
    "2. `clear()`\n",
    "3. `insert()`\n",
    "4. `index()`\n",
    "5. `remove()`\n",
    "6. `count()`\n",
    "7. `pop()`\n",
    "8. `sort()`\n",
    "9. `reverse()`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries\n",
    "\n",
    "These are special type of lists with contains a key and a value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = {\n",
    "    \"name\": \"Ashutosh\",\n",
    "    \"age\": 15,\n",
    "    \"hobby\": \"Coding\"\n",
    "}\n",
    "print(person)\n",
    "\n",
    "#Printing the value of a specific key\n",
    "print(person[\"name\"])\n",
    "print(person[\"age\"])\n",
    "print(person[\"hobby\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def introducer():\n",
    "    person = {\n",
    "        \"name\": \"Ashutosh Swamy\",\n",
    "        \"age\": 15,\n",
    "        \"hobby\": \"Coding\"\n",
    "    }\n",
    "\n",
    "    print(f\"Hello, my name is {person['name']}.\\nI am {person['age']} years old.\\nMy hobby is {person['hobby']}.\")\n",
    "\n",
    "introducer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def introducer():\n",
    "    person = {\n",
    "        \"name\": \"Ashutosh Swamy\",\n",
    "        \"age\": 15,\n",
    "        \"assets\": 50000,\n",
    "        \"debt\": 10000,\n",
    "        \"net_worth\": lambda: person['assets'] - person['debt']\n",
    "    }\n",
    "\n",
    "    print(f\"Name: {person['name']}\\nAge: {person['age']} years old\\nAssets: ${person['assets']}\\nDebt: ${person['debt']}\\nNet Worth: ${person['net_worth']()}\")\n",
    "\n",
    "introducer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Printing all the keys and values of the dictionary at once\n",
    "def introducer():\n",
    "    person = {\n",
    "        \"name\": \"Ashutosh Swamy\",\n",
    "        \"age\": 15,\n",
    "        \"assets\": 50000,\n",
    "        \"debt\": 10000,\n",
    "        \"net_worth\": lambda: person['assets'] - person['debt']\n",
    "    }\n",
    "\n",
    "    print(person.keys())\n",
    "    print(person.values())\n",
    "\n",
    "    #Printing them as a list\n",
    "    print(list(person.keys()))\n",
    "    print(list(person.values()))\n",
    "\n",
    "introducer()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing the value of a key\n",
    "person = {\n",
    "    \"name\": \"Ashutosh Swamy\",\n",
    "    \"age\": 15,\n",
    "    \"hobby\": \"Coding\"\n",
    "}\n",
    "\n",
    "print(person[\"name\"])\n",
    "person[\"name\"] = \"Pratibha Swamy\"\n",
    "print(person[\"name\"])\n",
    "print(person[\"age\"])\n",
    "person[\"age\"] = 44\n",
    "print(person[\"age\"])\n",
    "print(person[\"hobby\"])\n",
    "person[\"hobby\"] = \"Singing\"\n",
    "print(person[\"hobby\"])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples\n",
    "\n",
    "These are same as arrays or lists but we cannot change the value of the element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = (11, 3)\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Printing a specific element from the tuple\n",
    "numbers = (11, 3)\n",
    "print(numbers[0])\n",
    "print(numbers[1])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets\n",
    "\n",
    "They are also same as arrays or list but they help in removing the duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = {1, 2, 3, 3}\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using the set() function to convert a list into a set\n",
    "numbers = [1, 2, 2, 3]\n",
    "print(numbers)\n",
    "print(set(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [\"javascript\", \"python\", \"ruby\", \"java\"]\n",
    "list2 = [\"javascript\", \"python\", \"c++\", \"sql\"]\n",
    "list = list1 + list2\n",
    "print(list)\n",
    "print(set(list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = {1, 2, 3}\n",
    "print(2 in numbers)\n",
    "print(0 in numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def unique(numbers) -> None:\n",
    "    print(set(numbers))\n",
    "\n",
    "numbers = [1, 2, 2, 3, 3, 3, 4, 5, 6, 7, 8, 9, 9]\n",
    "unique(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unique = lambda numbers: print(set(numbers))\n",
    "\n",
    "numbers = [1, 2, 2, 3, 3, 4, 5, 6, 7, 8, 9, 9]\n",
    "unique(numbers)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Loops\n",
    "\n",
    "These are iteration statements used to make your work easier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using indexing to print the elements of a list\n",
    "names = [\"Ashutosh\", \"Pratibha\", \"Vishwanath\"]\n",
    "print(names[0])\n",
    "print(names[1])\n",
    "print(names[2])\n",
    "\n",
    "#Using for loop to print the elements of a list\n",
    "for name in names:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = [\"Ashutosh\", \"Pratibha\", \"Vishwanath\"]\n",
    "for name in names:\n",
    "    print(f\"Name: {name}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using the enumerate() function to print the element and it's index number\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "for number in enumerate(numbers):\n",
    "    print(\"Number: \", number[1], number[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Tuple Unpacking with the use of enumerate() function\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "for index, number in enumerate(numbers):\n",
    "    print(\"Number: \", number, index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using range() function to append element into a list\n",
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for _ in range(5):\n",
    "    print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"mango\", \"orange\"]\n",
    "for _ in range(5):\n",
    "    fruits.append(\"apple\")\n",
    "    print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"apple\", \"mango\", \"orange\"]\n",
    "for _ in range(5):\n",
    "    fruits.append(\"apple\")\n",
    "\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Infinite Loop using while\n",
    "pos = \"sitting\"\n",
    "\n",
    "while pos != \"standing\":\n",
    "    print(\"Get Up\")\n",
    "\n",
    "#Never run this piece of code unless you have a good computer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "counter = 0\n",
    "\n",
    "while counter < 10:\n",
    "    print(counter)\n",
    "    counter += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def double(numbers) -> None:\n",
    "    result = []\n",
    "    for i in numbers:\n",
    "        i *= 2\n",
    "        result.append(i)\n",
    "    print(numbers)\n",
    "    print(result)\n",
    "\n",
    "numbers = [2, 4, 6, 8, 10]\n",
    "double(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_words(string: str) -> None:\n",
    "    words = string.split()\n",
    "    print(len(words))\n",
    "\n",
    "count_words(\"Hi, my name is Ashutosh Swamy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def spliting(string: str) -> None:\n",
    "    words = string.split(\",\")\n",
    "    print(words)\n",
    "\n",
    "spliting(\"ashutosh,pratibha,vishwanath\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_list(numbers) -> None:\n",
    "    sum = 0\n",
    "    for i in numbers:\n",
    "        sum += i \n",
    "    print(numbers)\n",
    "    print(sum)\n",
    "\n",
    "numbers = [1, 2, 3]\n",
    "sum_list(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_max(numbers) -> None:\n",
    "    current_max = numbers[0]\n",
    "    for i in numbers:\n",
    "        if i > current_max:\n",
    "            current_max = i\n",
    "    print(current_max)\n",
    "\n",
    "def find_min(numbers) -> None:\n",
    "    current_min = numbers[0]\n",
    "    for i in numbers:\n",
    "        if i < current_min:\n",
    "            current_min = i\n",
    "    print(current_min)\n",
    "\n",
    "numbers = [3, 11, 10, 15, 16, 17, 27, 29]\n",
    "find_max(numbers)\n",
    "find_min(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def frequency(string: str) -> None:\n",
    "    result = {}\n",
    "    words = string.split()\n",
    "    for word in words:\n",
    "        if word not in result:\n",
    "            result[word] = 1\n",
    "        else:\n",
    "            result[word] += 1\n",
    "    print(result)\n",
    "\n",
    "string = input(str(\"Enter a string: \"))\n",
    "frequency(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using the high order functions\n",
    "#Using map() function\n",
    "def double(number) -> None:\n",
    "    print(number * 2)\n",
    "\n",
    "set(map(double, [1, 2, 3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(set(map(lambda x: x * 2, [1, 2, 3])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using filter() function\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n",
    "set(filter(lambda number: number % 2 == 0, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Using List Comprehensions\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n",
    "print([number for number in numbers if number % 2 == 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [2, 4, 6, 8, 10]\n",
    "print([number * 2 for number in numbers])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n",
    "print([number for number in numbers if number % 2 != 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]\n",
    "print([number ** 3 for number in numbers if number % 2 != 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Some built-in functions\n",
    "print(sum([1, 2, 3, 4, 5]))\n",
    "print(len([1, 2, 3, 4, 5]))\n",
    "print(max(12, 32, 47))\n",
    "print(min(12, 32, 47))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}