Let's Learn Python/09. Python - While Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. While Loops\n",
    "\n",
    "**While loops** are control flow statements used to repeatedly execute a block of code as long as a specified condition remains true. They provide a way to iterate over a block of code until a certain condition is met.\n",
    "\n",
    "We'll learn about the following topics:\n",
    "\n",
    "   - [9.1. Introduction to While Loops](#Introduction_to_While_Loops)\n",
    "   - [9.2. Pass, Break, Continue Statements](#Pass_Break_Continue_Statements)\n",
    "   - [9.3. One-Line while Loops](#OneLine_while_Loops)\n",
    "   - [9.4. Useful Functions and Operators for Loops](#Useful_Functions_and_Operators_for_Loops)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"center\">\n",
    "  <img width=\"550\" height=\"300\" src=\"https://realpython.com/cdn-cgi/image/width=960,format=auto/https://files.realpython.com/media/Python-while-Loops-Indefinite-Iteration_Watermarked.2dfa40d8e92c.jpg\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Introduction_to_While_Loops'></a>\n",
    "\n",
    "## 9.1. Introduction to While Loops:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A while loop allows you to repeatedly execute a block of code as long as a certain condition is true.\n",
    "\n",
    "The general syntax of a while loop is as follows:\n",
    "\n",
    "``while condition:\n",
    "    code block to execute while the condition is true``\n",
    "    \n",
    "Here's a breakdown of the different components:\n",
    "\n",
    "**1. Condition:** The condition is an expression that evaluates to either True or False. It determines whether the code block associated with the while loop should be executed or not. The loop continues executing as long as the condition is True.\n",
    "\n",
    "**2. Code Block:** The code block is indented and consists of one or more lines of code. It is executed repeatedly as long as the condition is True. The code block may include any valid Python statements.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count: 0\n",
      "Count: 1\n",
      "Count: 2\n",
      "Count: 3\n",
      "Count: 4\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "\n",
    "while count < 5:\n",
    "    print(f'Count: {count}')\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the variable count is initially set to 0. The while loop's condition count < 5 is evaluated. If the condition is True, the code block is executed, which prints the value of count and increments it by 1 using the count += 1 statement. The loop continues executing until the condition becomes False. The loop is executed five times because the condition count < 5 is satisfied until count becomes 5. Once count is 5, the condition becomes False, and the loop terminates."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to be cautious while using while loops to avoid creating infinite loops. An infinite loop occurs when the condition never becomes False, causing the loop to execute indefinitely. To prevent this, ensure that the condition within the while loop eventually evaluates to False or include an appropriate exit condition within the code block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, you can add an **else** clause to a while loop. The code within the else block will be executed once the while loop condition becomes False. Here's the modified syntax:\n",
    "\n",
    "``while condition:\n",
    "    code block to execute while the condition is true\n",
    "else:\n",
    "    code block to execute once the condition is false``"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count: 0\n",
      "Count: 1\n",
      "Count: 2\n",
      "Count: 3\n",
      "Count: 4\n",
      "Loop completed successfully\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "\n",
    "while count < 5:\n",
    "    print(f'Count: {count}')\n",
    "    count += 1\n",
    "else:\n",
    "    print('Loop completed successfully')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the while loop executes as long as the condition count < 5 is true. Once count becomes 5, the condition becomes False, and the loop terminates. At that point, the code block within the else clause is executed, which prints the message \"Loop completed successfully\".\n",
    "\n",
    "The else clause provides a way to include code that should execute after the while loop completes normally, i.e., when the condition becomes False. It is useful when you want to perform some actions or provide feedback once the looping is finished."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Pass_Break_Continue_Statements'></a>\n",
    "\n",
    "## 9.2. Pass, Break, Continue Statements:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align=\"center\">\n",
    "  <img width=\"300\" height=\"150\" src=\"https://files.realpython.com/media/t.899f357dd948.png\">\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Pass Statement:**\n",
    "\n",
    "The pass statement in Python is a placeholder statement that does nothing. It is used when you need a statement syntactically but don't want to execute any code. It is often used as a placeholder for future code implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in [0,2,4]:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the pass statement is used inside a for loop. The loop will iterate three times, but since pass does nothing, it effectively does not affect the loop's behavior. It allows you to create a syntactically valid loop without executing any code within the loop body."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Break Statement:**\n",
    "\n",
    "The break statement is used to exit a loop prematurely. It terminates the execution of the nearest enclosing loop and transfers control to the next statement after the loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is currently:  0\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  1\n",
      " x is still less than 10, adding 1 to x\n",
      "x is currently:  2\n",
      " x is still less than 10, adding 1 to x\n",
      "Breaking because x==3\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "\n",
    "while x < 10:\n",
    "    print('x is currently: ',x)\n",
    "    print(' x is still less than 10, adding 1 to x')\n",
    "    x+=1\n",
    "    if x==3:\n",
    "        print('Breaking because x==3')\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Continue Statement:**\n",
    "\n",
    "The continue statement is used to skip the remaining code within a loop iteration and move to the next iteration. It allows you to bypass specific parts of the loop's code block based on a certain condition."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,3,4]:\n",
    "    if i == 2:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the loop iterates over the numbers 0 to 4. When i equals 2, the continue statement is executed, and the remaining code within that iteration (the print(i) statement) is skipped. The loop then proceeds to the next iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "\n",
    "while count < 5:\n",
    "    count += 1\n",
    "    if count == 3:\n",
    "        continue\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the while loop continues as long as count is less than 5. When count equals 3, the continue statement is executed, skipping the remaining code in that iteration (the print(count) statement). The control then goes back to the loop's condition evaluation. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='OneLine_while_Loops'></a>\n",
    "\n",
    "## 9.3. One-Line while Loops:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A one-line while loop, also known as an inline while loop or a single-line while loop, allows you to write a compact while loop in a single line of code.\n",
    "\n",
    "``while condition: statement``\n",
    "\n",
    "Here's a breakdown of the components:\n",
    "\n",
    "**1. Condition:** The condition is an expression that evaluates to either True or False. It determines whether the loop will continue executing or terminate.\n",
    "\n",
    "**2. Statement:** The statement is the code or action to be executed within the loop. It typically performs a specific task or updates variables.\n",
    "\n",
    "It's important to note that one-line while loops are suitable for simple and concise situations. For more complex scenarios, it is generally recommended to use multi-line while loops for better readability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count: 1\n",
      "Count: 2\n",
      "Count: 3\n",
      "Count: 4\n",
      "Count: 5\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "\n",
    "while count < 5: count += 1; print(f'Count: {count}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the one-line while loop has two statements separated by a semicolon (;). The first statement count += 1 increments the count variable by 1, and the second statement ``print(f\"Count: {count}\")`` prints the current value of count. The loop continues executing as long as the condition count < 5 is True. The following multi-line while loops is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count: 0\n",
      "Count: 1\n",
      "Count: 2\n",
      "Count: 3\n",
      "Count: 4\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "\n",
    "while count < 5:\n",
    "    print(f'Count: {count}')\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "\n",
    "while n > 0: n -= 1; print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name='Useful_Functions_and_Operators_for_Loops'></a>\n",
    "\n",
    "## 9.4. Useful Functions and Operators for Loops:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Range**: The `range()` function is used to generate a sequence of numbers within a specified range.\n",
    "\n",
    "``range(start, stop, step)``\n",
    "\n",
    "Here's a breakdown of the different parameters:\n",
    "\n",
    "1. start (optional): This parameter represents the starting value of the range. If not specified, it defaults to 0.\n",
    "\n",
    "2. stop (required): This parameter represents the end value of the range. The range() function generates numbers up to, but not including, this value.\n",
    "\n",
    "3. step (optional): This parameter specifies the increment between each number in the sequence. If not specified, it defaults to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 5)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to note that the range() function returns a range object, which is an immutable sequence type. To obtain a list of numbers, you can convert the range object to a list using the ``list()`` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(0,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "numbers = list(range(5, 0, -1))\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The range() function is commonly used in combination with loops, such as for and while, to iterate over a sequence of numbers. It provides a convenient way to generate and work with ranges of values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Enumerate**: The enumerate() function is used to iterate over a sequence while simultaneously obtaining both the index and the corresponding value of each item in the sequence.\n",
    "\n",
    "The general syntax of the enumerate() function is as follows:\n",
    "\n",
    "``enumerate(iterable, start=0)``\n",
    "\n",
    "Here's a breakdown of the different parameters:\n",
    "\n",
    "1. Iterable: This parameter represents the sequence, such as a list, tuple, string, or any other iterable object, over which you want to iterate.\n",
    "\n",
    "2. Start (optional): This parameter specifies the starting value of the index. It defaults to 0 if not specified.\n",
    "\n",
    "The enumerate() function returns an enumerate object, which is an iterator that generates pairs of index-value tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 apple\n",
      "1 banana\n",
      "2 orange\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'orange']\n",
    "\n",
    "for index, fruit in enumerate(fruits):\n",
    "    print(index, fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 apple\n",
      "1 banana\n",
      "2 orange\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'orange']\n",
    "\n",
    "for index, fruit in enumerate(fruits):\n",
    "    print(index, fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'apple'), (1, 'banana'), (2, 'orange')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(fruits))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the enumerate() function is used to iterate over the fruits list. For each item in the list, the function returns a tuple containing the index and the corresponding fruit. The for loop then unpacks the tuples into the variables index and fruit, which are then printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth noting that the index values start from 0 by default, but you can specify a different starting value using the start parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 apple\n",
      "2 banana\n",
      "3 orange\n"
     ]
    }
   ],
   "source": [
    "fruits = ['apple', 'banana', 'orange']\n",
    "\n",
    "for index, fruit in enumerate(fruits, start=1):\n",
    "    print(index, fruit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "At index 0 the letter is a\n",
      "At index 1 the letter is b\n",
      "At index 2 the letter is c\n",
      "At index 3 the letter is d\n",
      "At index 4 the letter is e\n"
     ]
    }
   ],
   "source": [
    "for i, letter in enumerate('abcde'):\n",
    "    print(f'At index {i} the letter is {letter}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Input**:  The `input()` function is used to receive input from the user through the console or terminal during the execution of a Python program.\n",
    "\n",
    "The input() function pauses the program's execution and waits for the user to enter some text, which is typically followed by pressing the Enter key. The text entered by the user is then returned as a string, which can be stored in a variable or used in any way necessary within the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Pegah\n",
      "Hello, Pegah! Welcome!\n"
     ]
    }
   ],
   "source": [
    "name = input('Enter your name: ')\n",
    "print('Hello, ' + name + '! Welcome!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the input() function is used to prompt the user to enter their name. The string \"Enter your name: \" is displayed as a prompt to the user. The program then waits for the user to enter their name and press Enter. The text entered by the user is assigned to the variable name. Finally, the program uses the entered name to print a personalized welcome message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's important to note that the input() function always returns a **string**, even if the user enters a numerical value or any other type of input. If you require a different data type, such as an integer or float, you need to explicitly convert the input using appropriate conversion functions like int() or float()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your age: 26\n",
      "Next year, you will be 27\n"
     ]
    }
   ],
   "source": [
    "age = int(input('Enter your age: '))\n",
    "print('Next year, you will be', age + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the input() function is used to receive the user's age as input. The entered value is immediately converted to an integer using the int() function and assigned to the variable age. The program then performs a calculation using the converted integer and displays the result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Min and Max**: The `min()` and `max()` function in Python is used to find the smallest item in an iterable or a series of arguments. It returns the minimum/maximum value from the given inputs.\n",
    "\n",
    "The general syntax of the min()/max() function is as follows:\n",
    "\n",
    "`min(iterable, *args, key=None, default=None)\n",
    "max(iterable, *args, key=None, default=None)`\n",
    "\n",
    "Here's a breakdown of the different parameters:\n",
    "\n",
    "1. iterable (required): This parameter represents an iterable object such as a list, tuple, or string. It can also be multiple arguments passed directly to the function.\n",
    "\n",
    "2. *args (optional): This parameter allows you to pass additional arguments to the function, which will be included in the calculation of the minimum value.\n",
    "\n",
    "3. key (optional): This parameter specifies a function that will be used to determine the value by which the minimum is calculated. It takes a callable as an argument.\n",
    "\n",
    "4. default (optional): This parameter specifies the default value to be returned if the iterable is empty and no minimum value is found. If not specified, the min() function raises a ValueError in such cases."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "numbers = [5, 2, 8, 1, 9]\n",
    "minimum = min(numbers)\n",
    "print(minimum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the min() function is used to find the minimum value from the numbers list. The minimum value, which is 1, is then assigned to the variable minimum and printed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "maximum = max(5, 2, 8, 1, 9)\n",
    "print(maximum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "date\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "words = ['apple', 'banana', 'cherry', 'date']\n",
    "shortest_word = min(words, key=len)\n",
    "longest_word = max(words, key=len)\n",
    "print(shortest_word)\n",
    "print(longest_word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the min() function is used to find the shortest word from the words list based on their lengths. The key parameter is set to len, which specifies that the length of each word should be considered when determining the minimum. The shortest word, which is 'date', is then assigned to the variable shortest_word and printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Zip**: The `zip()` function is used to combine multiple iterables (such as lists, tuples, or strings) into a single iterable of tuples. Each tuple contains elements from the corresponding positions of the input iterables.\n",
    "\n",
    "The general syntax of the zip() function is as follows:\n",
    "\n",
    "``zip(*iterables)``\n",
    "\n",
    "Here's a breakdown of the different components:\n",
    "\n",
    "1. *iterables: This parameter represents one or more iterables that you want to combine. It can be any number of iterables separated by commas. The * notation is used to unpack the iterables, allowing them to be passed as separate arguments.\n",
    "\n",
    "The zip() function returns an iterator of tuples, where each tuple contains elements from the input iterables at the corresponding positions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 25), ('Bob', 30), ('Charlie', 35)]\n"
     ]
    }
   ],
   "source": [
    "names = ['Alice', 'Bob', 'Charlie']\n",
    "ages = [25, 30, 35]\n",
    "\n",
    "zipped = zip(names, ages)\n",
    "print(list(zipped))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the zip() function combines the names and ages lists into a single iterable of tuples. Each tuple contains an element from the names list and the corresponding element from the ages list. The resulting iterable is then converted to a list using the list() function and printed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's worth noting that the input iterables passed to zip() do not need to have the same length. The resulting iterable will only contain tuples up to the length of the shortest input iterable. Any extra elements from longer iterables will be ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Alice', 25), ('Bob', 30)]\n"
     ]
    }
   ],
   "source": [
    "names = ['Alice', 'Bob', 'Charlie']\n",
    "ages = [25, 30]\n",
    "\n",
    "zipped = zip(names, ages)\n",
    "print(list(zipped))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this modified example, the ages list has only two elements, while the names list has three. The resulting iterable from zip() contains tuples up to the length of the shortest input iterable, which is two in this case."
   ]
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}