python_lesson_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bb36bfe1",
   "metadata": {},
   "source": [
    "# Control Flow\n",
    "\n",
    "## Conditional Statements\n",
    "Conditional statements allow you to execute different blocks of code depending on whether a certain condition is true or false. In Python, the two main types of conditional statements are if statements and if-else statements.\n",
    "\n",
    "An if statement checks whether a condition is true, and if it is, executes a block of code. For example:\n",
    "\n",
    "```py\n",
    "x = 5\n",
    "if x > 0:\n",
    "    print(\"x is positive\")\n",
    "```\n",
    "This code checks whether x is greater than 0, and if it is, prints the message \"x is positive\". If x is not greater than 0, the code does nothing.\n",
    "\n",
    "An if-else statement is similar to an if statement, but also includes a block of code to be executed if the condition is false. For example:\n",
    "\n",
    "```py\n",
    "x = -5\n",
    "if x > 0:\n",
    "    print(\"x is positive\")\n",
    "else:\n",
    "    print(\"x is not positive\")\n",
    "```\n",
    "This code checks whether x is greater than 0, and if it is, prints the message \"x is positive\". If x is not greater than 0, the code executes the else block and prints the message \"x is not positive\".\n",
    "\n",
    "You can also use elif (short for \"else if\") to check additional conditions. For example:\n",
    "\n",
    "```py\n",
    "x = 0\n",
    "if x > 0:\n",
    "    print(\"x is positive\")\n",
    "elif x < 0:\n",
    "    print(\"x is negative\")\n",
    "else:\n",
    "    print(\"x is zero\")\n",
    "```\n",
    "This code checks whether x is greater than 0, and if it is, prints the message \"x is positive\". If x is not greater than 0, it checks whether x is less than 0, and if it is, prints the message \"x is negative\". If neither of those conditions is true, the code executes the else block and prints the message \"x is zero\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "af1d6548",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is positive\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "if x > 0:\n",
    "    print(\"x is positive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4da90a3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is not positive\n"
     ]
    }
   ],
   "source": [
    "x = -5\n",
    "if x > 0:\n",
    "    print(\"x is positive\")\n",
    "else:\n",
    "    print(\"x is not positive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ee198c98",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is zero\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "if x > 0:\n",
    "    print(\"x is positive\")\n",
    "elif x < 0:\n",
    "    print(\"x is negative\")\n",
    "else:\n",
    "    print(\"x is zero\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f239c1d6",
   "metadata": {},
   "source": [
    "### None \n",
    "\n",
    "In Python, None is a special value that represents the absence of a value. It can be used as a placeholder when a variable or parameter needs to be assigned a value later.\n",
    "\n",
    "For example, let's say we have a variable result that we want to initialize but don't have a value for yet. We can set it to None and then assign a value later:\n",
    "\n",
    "```py\n",
    "result = None\n",
    "# some code that calculates result\n",
    "result = 10\n",
    "```\n",
    "In conditional statements, None can be used as a default value when checking if a variable has been assigned a value. For example:\n",
    "\n",
    "```py\n",
    "name = None\n",
    "if name:\n",
    "    print(\"Hello, \" + name)\n",
    "else:\n",
    "    print(\"Hello, stranger\")\n",
    "```   \n",
    "In this example, if name is None, the if statement evaluates to False and the program prints \"Hello, stranger\". If name had a value assigned to it, the if statement would evaluate to True and the program would print \"Hello, \" followed by the value of name.\n",
    "\n",
    "Using None in conditional statements is a common pattern in Python, and is often used to check if a variable has been initialized or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "29598c50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, stranger\n"
     ]
    }
   ],
   "source": [
    "name = None\n",
    "if name:\n",
    "    print(\"Hello, \" + name)\n",
    "else:\n",
    "    print(\"Hello, stranger\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4bf9251",
   "metadata": {},
   "source": [
    "### Condition \n",
    "\n",
    "The if statement in Python allows us to execute a block of code only if a certain condition is true. The condition can be a Boolean expression that evaluates to either True or False. The syntax for the if statement is as follows:\n",
    "\n",
    "```py\n",
    "if condition:\n",
    "    # code to be executed if the condition is True\n",
    "```    \n",
    "The condition is written as an expression that is either true or false. Here are some common types of expressions that can be used in an if statement:\n",
    "\n",
    "- **Comparison operators**: == (equal to), != (not equal to), < (less than), > (greater than), <= (less than or equal to), >= (greater than or equal to). For example:\n",
    "```py\n",
    "x = 5\n",
    "if x == 5:\n",
    "    print(\"x is equal to 5\")\n",
    "```\n",
    "\n",
    "- **Logical operators**: and, or, not. For example:\n",
    "```py\n",
    "x = 5\n",
    "y = 10\n",
    "if x > 0 and y > 0:\n",
    "    print(\"Both x and y are positive\")\n",
    "```\n",
    "\n",
    "- **Membership operators**: `in` (checks if a value is in a sequence), not in (checks if a value is not in a sequence). For example:\n",
    "```py\n",
    "names = [\"Alice\", \"Bob\", \"Charlie\"]\n",
    "if \"Bob\" in names:\n",
    "    print(\"Bob is in the list of names\")\n",
    "```\n",
    "\n",
    "- **Identity operators**: `is` (checks if two variables refer to the same object), is not (checks if two variables refer to different objects). For example:\n",
    "```py\n",
    "x = [1, 2, 3]\n",
    "y = [1, 2, 3]\n",
    "if x is y:\n",
    "    print(\"x and y refer to the same object\")\n",
    "else:\n",
    "    print(\"x and y refer to different objects\")\n",
    "```\n",
    "\n",
    "\n",
    "It is important to note that the condition in the if statement must always evaluate to a Boolean value (True or False). If the condition is not a Boolean expression, it will be automatically converted to one, with the following rules:\n",
    "\n",
    "- Numbers: 0 is False, any other number is True\n",
    "- Sequences: empty sequences (e.g. empty lists or strings) are False, non-empty sequences are True\n",
    "- Other objects: all objects are considered True, except for `None` which is False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "08458910",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is equal to 5\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "if x == 5:\n",
    "    print(\"x is equal to 5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a8155dd4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both x and y are positive\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 10\n",
    "if x > 0 and y > 0:\n",
    "    print(\"Both x and y are positive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "99cf481f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob is in the list of names\n"
     ]
    }
   ],
   "source": [
    "names = [\"Alice\", \"Bob\", \"Charlie\"]\n",
    "if \"Bob\" in names:\n",
    "    print(\"Bob is in the list of names\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c98f5231",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x and y refer to different objects\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [1, 2, 3]\n",
    "if x is y:\n",
    "    print(\"x and y refer to the same object\")\n",
    "else:\n",
    "    print(\"x and y refer to different objects\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d21e8428",
   "metadata": {},
   "source": [
    "### Shortcut feature of logical operators\n",
    "\n",
    "In Python, logical operators and and or have a shortcut feature that can be useful in certain situations. When using and, if the first expression is false, the whole expression will be false regardless of the value of the second expression, so the second expression is not evaluated. Similarly, when using or, if the first expression is true, the whole expression will be true regardless of the value of the second expression, so the second expression is not evaluated. This can save computation time when evaluating complex expressions or when the second expression may cause an error.\n",
    "\n",
    "For example, consider the following code snippet:\n",
    "\n",
    "```py\n",
    "x = 10\n",
    "y = 0\n",
    "\n",
    "if y > 0 and x/y > 0.5:\n",
    "    print(\"True\")\n",
    "```\n",
    "\n",
    "In this case, the second condition x/y > 0.5 will not be evaluated if y > 0 is false, because the entire expression will be false regardless of the value of x/y > 0.5. This can save time and prevent potential errors that may arise from evaluating x/y > 0.5 when y is zero or negative."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4fc3c45c",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 10\n",
    "y = 0\n",
    "\n",
    "if y > 0 and x/y > 0.5:\n",
    "    print(\"True\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acd4c72e",
   "metadata": {},
   "source": [
    "## Loops\n",
    "Loops allow you to execute a block of code multiple times. In Python, the two main types of loops are for loops and while loops.\n",
    "\n",
    "A for loop allows you to iterate over a sequence of values, such as a list or a range of numbers. For example:\n",
    "\n",
    "```py\n",
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for fruit in fruits:\n",
    "    print(fruit)\n",
    "```\n",
    "This code creates a list of fruits, and then uses a for loop to iterate over the fruits and print each one.\n",
    "\n",
    "A while loop allows you to execute a block of code as long as a certain condition is true. For example:\n",
    "\n",
    "```py\n",
    "i = 0\n",
    "while i < 5:\n",
    "    print(i)\n",
    "    i += 1\n",
    "```\n",
    "This code uses a while loop to print the numbers 0 to 4. The loop continues as long as the variable i is less than 5.\n",
    "\n",
    "You can use the break statement to exit a loop early, and the continue statement to skip to the next iteration of a loop. For example:\n",
    "\n",
    "```py\n",
    "i = 0\n",
    "while i < 10:\n",
    "    if i == 5:\n",
    "        break\n",
    "    if i % 2 == 0:\n",
    "        i += 1\n",
    "        continue\n",
    "    print(i)\n",
    "    i += 1\n",
    "```\n",
    "This code uses a while loop to print the odd numbers less than 10, but skips even numbers and exits the loop when it reaches 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "5258c697",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "cherry\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\"]\n",
    "for fruit in fruits:\n",
    "    print(fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "72a81950",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ac442e80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    if i == 5:\n",
    "        break\n",
    "    if i % 2 == 0:\n",
    "        i += 1\n",
    "        continue\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4537245f",
   "metadata": {},
   "source": [
    "### The range() function\n",
    "The range function is a built-in function in Python that allows you to generate a sequence of numbers. The range function can take up to three arguments: start, stop, and step. The start argument specifies the starting value of the sequence (defaulting to 0), the stop argument specifies the ending value of the sequence (excluding the value itself), and the step argument specifies the increment between values in the sequence (defaulting to 1).\n",
    "\n",
    "Here are some examples of using the range function:\n",
    "\n",
    "```py\n",
    "# Generate a sequence of numbers from 0 to 4 (excluding 4)\n",
    "for i in range(4):\n",
    "    print(i)\n",
    "\n",
    "# Generate a sequence of numbers from 1 to 10 (excluding 10) with a step of 2\n",
    "for i in range(1, 10, 2):\n",
    "    print(i)\n",
    "\n",
    "# Generate a sequence of numbers from 5 to 1 (excluding 1) with a step of -1\n",
    "for i in range(5, 1, -1):\n",
    "    print(i)\n",
    "```\n",
    "In the first example, we generate a sequence of numbers from 0 to 4 (excluding 4), and print out each number in the sequence using a for loop.\n",
    "\n",
    "In the second example, we generate a sequence of numbers from 1 to 10 (excluding 10) with a step of 2, and print out each number in the sequence using a for loop.\n",
    "\n",
    "In the third example, we generate a sequence of numbers from 5 to 1 (excluding 1) with a step of -1, and print out each number in the sequence using a for loop.\n",
    "\n",
    "The range function can be useful when you need to iterate over a sequence of numbers, such as when you want to perform a certain action a specific number of times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7c034a67",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Generate a sequence of numbers from 0 to 4 (excluding 4)\n",
    "for i in range(4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "7fea6a3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Generate a sequence of numbers from 1 to 10 (excluding 10) with a step of 2\n",
    "for i in range(1, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "dc631881",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# Generate a sequence of numbers from 5 to 1 (excluding 1) with a step of -1\n",
    "for i in range(5, 1, -1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbe4e1ed",
   "metadata": {},
   "source": [
    "### Traverse a dictionary\n",
    "\n",
    "To traverse a dictionary in Python, you can use a for loop with the items() method. The items() method returns a list of key-value pairs of the dictionary, which you can then iterate over. Here's an example:\n",
    "\n",
    "```py\n",
    "my_dict = {\"apple\": 2, \"banana\": 3, \"orange\": 4}\n",
    "\n",
    "# print the keys\n",
    "for key in my_dict:\n",
    "    print(key)\n",
    "\n",
    "# print the values\n",
    "for value in my_dict.values():\n",
    "    print(value)\n",
    "\n",
    "# print the key-value pairs\n",
    "for key, value in my_dict.items():\n",
    "    print(key, value)\n",
    "````\n",
    "\n",
    "In the first for loop, we iterate over the keys of the dictionary and print them. In the second for loop, we iterate over the values of the dictionary and print them. In the third for loop, we iterate over the key-value pairs of the dictionary and print them.\n",
    "\n",
    "Note that the order in which the keys, values, or key-value pairs are returned is not guaranteed to be the same every time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "570ebcac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple\n",
      "banana\n",
      "orange\n"
     ]
    }
   ],
   "source": [
    "my_dict = {\"apple\": 2, \"banana\": 3, \"orange\": 4}\n",
    "\n",
    "# print the keys\n",
    "for key in my_dict:\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bd7b8056",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# print the values\n",
    "for value in my_dict.values():\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "48d68163",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple 2\n",
      "banana 3\n",
      "orange 4\n"
     ]
    }
   ],
   "source": [
    "# print the key-value pairs\n",
    "for key, value in my_dict.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a3a5bad",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "Functions are a way to group together code that performs a specific task, making it easier to organize and reuse your code. In Python, you can define a function using the def keyword followed by the function name and any parameters the function takes, enclosed in parentheses. The code inside the function should be indented to indicate that it is part of the function.\n",
    "\n",
    "Here's an example of a simple function that adds two numbers together:\n",
    "\n",
    "```py\n",
    "def add_numbers(a, b):\n",
    "    sum = a + b\n",
    "    return sum\n",
    "```\n",
    "In this example, the add_numbers function takes two parameters a and b and returns their sum. You can call the function and pass in values for a and b like this:\n",
    "\n",
    "```py\n",
    "result = add_numbers(2, 3)\n",
    "print(result)  # Output: 5\n",
    "```\n",
    "Note that when you call a function, you can assign its return value to a variable or use it directly in your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "274d56a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_numbers(a, b):\n",
    "    sum = a + b\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "627d2ffc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "result = add_numbers(2, 3)\n",
    "print(result)  # Output: 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1571a90",
   "metadata": {},
   "source": [
    "\n",
    "## Default arguments\n",
    "Functions can also have optional parameters with default values, allowing you to provide more flexibility in how the function is used. For example, here's a modified version of the add_numbers function that allows you to specify a default value for the b parameter:\n",
    "\n",
    "```py\n",
    "def add_numbers(a, b=0):\n",
    "    sum = a + b\n",
    "    return sum\n",
    "```\n",
    "Now, if you call add_numbers with just one argument, b will default to 0:\n",
    "\n",
    "```py\n",
    "result = add_numbers(2)\n",
    "print(result)  # Output: 2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4d3023fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_numbers(a, b=0):\n",
    "    sum = a + b\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7f903416",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "result = add_numbers(2)\n",
    "print(result)  # Output: 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bc1c007",
   "metadata": {},
   "source": [
    "## Variable-length arguments (*args and **kwargs)\n",
    "You can also define a function that takes a variable number of arguments using the *args syntax. Here's an example:\n",
    "\n",
    "```py\n",
    "def print_arguments(*args):\n",
    "    for arg in args:\n",
    "        print(arg)\n",
    "```\n",
    "In this example, the print_arguments function takes any number of arguments and prints them out one by one. You can call the function with any number of arguments like this:\n",
    "\n",
    "```py\n",
    "print_arguments(1, 2, 3)  # Output: 1 2 3\n",
    "print_arguments('hello', 'world')  # Output: hello world\n",
    "```\n",
    "\n",
    "\n",
    "In addition to `*args`, Python also has a special syntax for passing keyword arguments to a function, which is denoted by `**kwargs`. The ** operator is used to unpack a dictionary of keyword arguments passed to a function, and these arguments are then accessed by name in the function's body.\n",
    "\n",
    "The kwargs variable name is a convention; it is not a keyword and any valid variable name can be used instead. When calling a function with keyword arguments, the keyword and value pairs are passed as a dictionary to the **kwargs parameter.\n",
    "\n",
    "One common use case for kwargs is when a function needs to accept a variable number of arguments, and each argument needs to have a specific name associated with it. Another use case is when a function needs to pass a large number of optional arguments to another function, without having to explicitly specify each one.\n",
    "\n",
    "Here is an example of a function that takes in a variable number of keyword arguments using **kwargs:\n",
    "\n",
    "```py\n",
    "def print_info(name, **kwargs):\n",
    "    print(\"Name:\", name)\n",
    "    for key, value in kwargs.items():\n",
    "        print(key.capitalize() + \":\", value)\n",
    "\n",
    "# Calling the function with keyword arguments\n",
    "print_info(\"John\", age=30, occupation=\"Engineer\", city=\"New York\")\n",
    "```\n",
    "\n",
    "In this example, the print_info() function takes a required parameter name and an arbitrary number of keyword arguments using **kwargs. Inside the function, the name parameter is printed first, followed by the keyword arguments passed in as a dictionary. The items() method is used to iterate through the key-value pairs of the kwargs dictionary, and the capitalize() method is used to make the keys more readable in the printed output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c2b9a782",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_arguments(*args):\n",
    "    for arg in args:\n",
    "        print(arg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1df74bab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "print_arguments(1, 2, 3)  # Output: 1 2 3\n",
    "print_arguments('hello', 'world')  # Output: hello world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7389cf4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_info(name, **kwargs):\n",
    "    print(\"Name:\", name)\n",
    "    for key, value in kwargs.items():\n",
    "        print(key.capitalize() + \":\", value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "50cf3434",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: John\n",
      "Age: 30\n",
      "Occupation: Engineer\n",
      "City: New York\n"
     ]
    }
   ],
   "source": [
    "# Calling the function with keyword arguments\n",
    "print_info(\"John\", age=30, occupation=\"Engineer\", city=\"New York\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a85415bf",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "## Modules and external libraries\n",
    "Python comes with a lot of built-in functions and modules, but you can also import external libraries to add more functionality to your code. To import a module, you can use the import keyword followed by the name of the module. For example, to use the math module, you can do:\n",
    "\n",
    "```py\n",
    "import math\n",
    "```\n",
    "Now you can use any of the functions or constants defined in the math module. For example, to calculate the square root of a number, you can use the sqrt function from the math module:\n",
    "\n",
    "```py\n",
    "import math\n",
    "\n",
    "x = math.sqrt(25)\n",
    "print(x)  # Output: 5.0\n",
    "```\n",
    "You can also import specific functions or constants from a module using the from ... import syntax. For example:\n",
    "\n",
    "```py\n",
    "from math import pi\n",
    "\n",
    "print(pi)  # Output: 3.141592653589793\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "208fa68d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "x = math.sqrt(25)\n",
    "print(x)  # Output: 5.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2b0a3df3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "\n",
    "print(pi)  # Output: 3.141592653589793"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59aee25c",
   "metadata": {},
   "source": [
    "## Name Scope in Functions\n",
    "\n",
    "Name scope refers to the region of a program where a particular variable can be accessed. In Python, there are two types of Name scopes: global and local.\n",
    "\n",
    "A global variable is a variable that is defined outside of any function, and can be accessed from anywhere in the program. A local variable is a variable that is defined inside a function, and can only be accessed from within that function.\n",
    "\n",
    "When a function is called, Python creates a new local namespace for the function. Any variables that are defined within the function are stored in this local namespace. When the function returns, the local namespace is destroyed and any variables defined within it are lost.\n",
    "\n",
    "If a variable is defined both globally and locally within a function, the local variable takes precedence over the global variable within the function. However, the global variable can still be accessed from within the function using the global keyword.\n",
    "\n",
    "Here's an example:\n",
    "\n",
    "```py\n",
    "x = 10  # global variable\n",
    "\n",
    "def my_func():\n",
    "    x = 5  # local variable\n",
    "    print(x)  # prints 5\n",
    "\n",
    "my_func()\n",
    "print(x)  # prints 10\n",
    "```\n",
    "In this example, we define a global variable x with a value of 10. We then define a function my_func that creates a local variable x with a value of 5, and prints its value. When we call my_func, it prints the value of the local variable x, which is 5. After the function returns, we print the value of the global variable x, which is still 10.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "73526b4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10  # global variable\n",
    "\n",
    "def my_func():\n",
    "    x = 5  # local variable\n",
    "    print(x)  # prints 5\n",
    "\n",
    "my_func()\n",
    "print(x)  # prints 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ea4539",
   "metadata": {},
   "source": [
    "### The nonlocal keyword\n",
    "\n",
    "Suppose we want to modify the value of count in the outer function outer_func from the inner function inner_func. We can use the nonlocal keyword to indicate that count is not a local variable but a variable in the outer function.\n",
    "\n",
    "Here's an updated code example:\n",
    "\n",
    "```py\n",
    "def outer_func():\n",
    "    count = 0\n",
    "    \n",
    "    def inner_func():\n",
    "        nonlocal count\n",
    "        count += 1\n",
    "        print(count)\n",
    "    \n",
    "    inner_func()\n",
    "    \n",
    "outer_func()  # Output: 1\n",
    "```\n",
    "In this updated example, we add the nonlocal keyword before count in the inner_func function to indicate that we want to modify the count variable in the outer function. Now when we call inner_func, the count variable is incremented by 1, and the updated value of count (which is 1) is printed to the console.\n",
    "\n",
    "Without the nonlocal keyword, Python would assume that count is a local variable inside inner_func, and any changes to it would not affect the count variable in the outer function. Using nonlocal allows us to modify variables in outer functions from inner functions, which can be useful in certain situations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "11aa038a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "def outer_func():\n",
    "    count = 0\n",
    "    \n",
    "    def inner_func():\n",
    "        nonlocal count\n",
    "        count += 1\n",
    "        print(count)\n",
    "    \n",
    "    inner_func()\n",
    "    \n",
    "outer_func()  # Output: 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8428d57",
   "metadata": {},
   "source": [
    "## Recursion\n",
    "\n",
    "Recursion is a powerful technique in programming where a function calls itself, either directly or indirectly. When a function calls itself, it is said to be recursive. Recursive functions are useful when solving problems that can be broken down into smaller and similar subproblems.\n",
    "\n",
    "The process of recursion can be divided into two parts: the base case and the recursive case. The base case is the condition under which the function does not call itself again and returns a value. The recursive case is the condition under which the function calls itself again.\n",
    "\n",
    "A recursive function can be very efficient and concise for certain types of problems, but it can also be slow and use a lot of memory if not implemented correctly. It is important to carefully consider the design of a recursive function and ensure that the base case is properly defined and that the function will eventually reach the base case.\n",
    "\n",
    "Here is an example of a recursive function that calculates the factorial of a given number:\n",
    "\n",
    "```py\n",
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)\n",
    "```\n",
    "\n",
    "In this example, the base case is defined as n == 0, and the recursive case is defined as n * factorial(n-1). This function will keep calling itself with smaller and smaller values of n until it reaches the base case where n == 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "554928fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "1c109f1f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3628800"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "b8af6187",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa12c482",
   "metadata": {},
   "source": [
    "# Exercises\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Sum of Squares\n",
    "Write a Python function that takes a list of numbers as input and returns the sum of the squares of the elements in the list. For example, if the input list is [1, 2, 3, 4, 5], the program should return 55, which is the sum of the squares of the elements in the list.\n",
    "\n",
    "To solve this problem, you can use a for loop to iterate over the input list, and a variable to store the sum of the squares. For each element in the input list, you can compute its square, and add it to the sum. You can then return the sum of the squares.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "182ebfab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "def sum_of_squares(input_list):\n",
    "    ans = 0\n",
    "    for element in input_list:\n",
    "        ans += element * element\n",
    "    return ans\n",
    "\n",
    "input_list = [1, 2, 3, 4, 5]\n",
    "print(sum_of_squares(input_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6afa11",
   "metadata": {},
   "source": [
    "## Remove Duplicates\n",
    "\n",
    "Write a Python function that takes a list of numbers as input and returns a new list that contains only the unique elements of the input list, in the order in which they first appear. For example, if the input list is [1, 2, 3, 2, 4, 1, 5], the program should return the list [1, 2, 3, 4, 5].\n",
    "\n",
    "To solve this problem, you can use a for loop to iterate over the input list, and a second list to store the unique elements. For each element in the input list, you can check whether it is already in the second list, and if not, add it to the second list. You can then return the second list, which should contain only the unique elements in the order in which they first appeared in the input list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4c9828cb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "def remove_duplicates(input_list):\n",
    "    unique_elements = []\n",
    "    for element in input_list:\n",
    "        if element not in unique_elements:\n",
    "            unique_elements.append(element)\n",
    "    return unique_elements\n",
    "\n",
    "input_list = [1, 2, 3, 2, 4, 1, 5]\n",
    "print(remove_duplicates(input_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cd02f150",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "def remove_duplicates_v2(input_list):\n",
    "    # much more efficient\n",
    "    return list(set(input_list))\n",
    "\n",
    "input_list = [1, 2, 3, 2, 4, 1, 5]\n",
    "print(remove_duplicates_v2(input_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a246cc84",
   "metadata": {},
   "source": [
    "## Is Prime Number\n",
    "\n",
    "Write a Python function is_prime that takes an integer as input and returns True if the number is prime, and False otherwise. A prime number is a positive integer greater than 1 that has no positive divisors other than 1 and itself.\n",
    "\n",
    "For example, is_prime(5) should return True because 5 is a prime number, and is_prime(10) should return False because 10 is not a prime number (it has divisors 2 and 5).\n",
    "\n",
    "Hint: One way to check if a number is prime is to loop through all the integers from 2 to the square root of the number (inclusive) and check if the number is divisible by any of them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e4a68315",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n",
      "73\n",
      "79\n",
      "83\n",
      "89\n",
      "97\n",
      "The total number of prime numbers between 1 and 100 is 25\n"
     ]
    }
   ],
   "source": [
    "def is_prime(number):\n",
    "    if number < 2:\n",
    "        return False\n",
    "    for divisor in range(2, number):\n",
    "        if number % divisor == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "from math import sqrt\n",
    "def is_prime_v2(number):\n",
    "    if number < 2:\n",
    "        return False\n",
    "    for divisor in range(2, int(sqrt(number))+1):\n",
    "        if number % divisor == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "start, end = 1, 100\n",
    "cnt = 0\n",
    "for i in range(start, end):\n",
    "    if is_prime(i):\n",
    "        print(i)\n",
    "        cnt += 1\n",
    "        \n",
    "print(\"The total number of prime numbers between {} and {} is {}\".format(start, end, cnt))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e7cd06a",
   "metadata": {},
   "source": [
    "## Newton-Raphson method for finding the square root of a number\n",
    "\n",
    "1. Ask the user to enter a positive number. If the input is not a number or the number is negative, ask the user the re-enter the number. \n",
    "2. Initialize a variable x to be the user's number divided by 2.\n",
    "3. Use a loop to repeatedly update the value of x according to the Newton-Raphson formula: x = (x + n / x) / 2.\n",
    "4. Continue iterating until the difference between x * x and the original number n is less than a small threshold (e.g., 0.0001).\n",
    "5. Print out the final value of x, which should be a good estimate of the square root of the original number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "40642c2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a positive number:3\n",
      "The square root of 3 is approximately 1.7321, while math.sqrt(3) returns 1.7321\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "# Ask the user to enter a positive number\n",
    "def my_sqrt(n):\n",
    "    # Initialize the estimate\n",
    "    x = n / 2\n",
    "\n",
    "    # Iterate until the estimate is accurate enough\n",
    "    while abs(x * x - n) > 1e-6:\n",
    "        # Update the estimate\n",
    "        x = (x + n / x) / 2\n",
    "    \n",
    "    return x\n",
    "\n",
    "while True:\n",
    "    n = input(\"Enter a positive number:\")\n",
    "    if not n.isdigit() or int(n) < 0:\n",
    "        print(\"Please enter a positive number\")\n",
    "        continue\n",
    "    n = int(n)\n",
    "    break\n",
    "\n",
    "# Print out the final estimate\n",
    "print(f\"The square root of {n} is approximately {my_sqrt(n):.4f}, while math.sqrt({n}) returns {sqrt(n):.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b65ce13a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}