Lab5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lab 5, Create Snippets of what we learned from each chapter on zybook. Each should include a markdown file of what we learned from the chapter and snippets of code in a code cell. Add a TON of review, this is review for myself for our midterm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 1: Introduction to Python\n",
    "\n",
    "A computer program consists of instructions executing one at a time. Basic instruction types are:\n",
    "\n",
    "Input: A program receives data from a file, keyboard, touchscreen, network, etc.\n",
    "Process: A program performs computations on that data, such as adding two values like x + y.\n",
    "Output: A program puts that data somewhere, such as a file, screen, or network.\n",
    "Programs use variables to refer to data, like x, y, and z below. The name is due to a variable's value \"varying\" as a program assigns a variable like x with new values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "# Imagine x and y are taking from input()\n",
    "\n",
    "x = 5\n",
    "y = 6\n",
    "z = x + y\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mathematical thinking became increasingly important throughout the industrial age, enabling people to successfully live and work. In the information age, many people believe computational thinking, or creating a sequence of instructions to solve a problem, will become increasingly important for work and everyday life. A sequence of instructions that solves a problem is called an algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Python interpreter is a computer program that executes code written in the Python programming language. An interactive interpreter is a program that allows the user to execute one line of code at a time.\n",
    "\n",
    "Code is a common word for the textual representation of a program (and hence programming is also called coding). A line is a row of text."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A statement is a program instruction. A program mostly consists of a series of statements, and each statement usually appears on its own line.\n",
    "Expressions are code that return a value when evaluated; for example, the code wage * hours * weeks is an expression that computes a number. The symbol * is used for multiplication. The names wage, hours, weeks, and salary are variables, which are named references to values stored by the interpreter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Text is output from a Python program using the built-in function print( ). Ex: print('hello world!'). Text enclosed in quotes is known as a string. Text in strings may have letters, numbers, spaces, or symbols like @ or #."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An escape sequence is a string that has a special meaning, like the newline character \"\\n\", that always starts with a backslash \"\\\". Other escape sequences exist, such as \"\\t\" to insert a tab, or \"\\\\\" to print an actual backslash character."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The input() function is used to read input from a user. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = input()\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 2: Variables and Expressions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a program, a variable is a named item, such as x or num_people, that holds a value.\n",
    "\n",
    "An assignment statement assigns a variable with a value, such as x = 5. That statement means x is assigned with 5, and x keeps that value during subsequent statements, until x is assigned again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = x + 3\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Increasing a variable's value by 1, as in x = x + 1, is common and known as incrementing the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables can have different types. The type of a variable can be changed by assigning a new value of a different type to it. The type of a variable can be checked with the type() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "num_students = 10\n",
    "num_students = num_students + 1\n",
    "print(num_students)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An identifier, also called a name, is a sequence of letters (a-z, A-Z), underscores (_), and digits (0–9), and must start with a letter or an underscore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is case sensitive, meaning uppercase and lowercase letters differ. Ex: \"Cat\" and \"cat\" are different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "cat = 1\n",
    "Cat = 2\n",
    "\n",
    "print(cat)\n",
    "print(Cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An object represents a value and is automatically created by the interpreter when executing a line of code. For example, executing x = 4 creates a new object to represent the value 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deleting unused objects is an automatic process called garbage collection that frees memory space."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name binding is the process of associating names with interpreter objects. An object can have more than one name bound to it, and every name is always bound to exactly one object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66000.0\n"
     ]
    }
   ],
   "source": [
    "bob_salary = 25000\n",
    "tom_salary = 30000\n",
    "bob_salary = tom_salary\n",
    "tom_salary = tom_salary * 1.2\n",
    "total_salaries = bob_salary + tom_salary\n",
    "print(total_salaries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mutability indicates whether the object's value is allowed to be changed. Integers and strings are immutable; meaning integer and string values cannot be changed. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "x = 2 + 2         \n",
    "print(type(x))      \n",
    "\n",
    "print(type('ABC'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each Python object has three defining properties: value, type, and identity.\n",
    "\n",
    "Value: A value such as \"20\", \"abcdef\", or \"55\".\n",
    "\n",
    "Type: The type of the object, such as integer or string.\n",
    "\n",
    "Identity: A unique identifier that describes the object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A floating-point number is a real number, like 98.6, 0.0001, or -666.667. The term \"floating-point\" refers to the decimal point appearing anywhere (\"floating\") in the number. Thus, float is a data type for floating-point numbers.\n",
    "\n",
    "A floating-point literal is written with the fractional part even if that fraction is 0, as in 1.0, 0.0, or 99.0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 2 + 2.0\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Overflow occurs when a value is too large to be stored in the memory allocated by the interpreter. Ex: The program in the figure below tries to store the value 2.01024, which causes an overflow error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An expression is a combination of items, like variables, literals, operators, and parentheses, that evaluates to a value, like 2 * (x + 1). A common place where expressions are used is on the right side of an assignment statement, as in y = 2 * (x + 1).\n",
    "\n",
    "A literal is a specific value in code like 2. An operator is a symbol that performs a built-in calculation, like +, which performs addition. Common programming operators are shown below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+\tThe addition operator is +, as in x + y.\n",
    "\n",
    "-\tThe subtraction operator is -, as in x - y. Also, the - operator is for negation, as in -x + y, or x + -y.\n",
    "\n",
    "*\tThe multiplication operator is *, as in x * y.\n",
    "\n",
    "+\tThe division operator is /, as in x / y.\n",
    "\n",
    "+\tThe exponent operator is **, as in x ** y (x to the power of y)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2 + 2\n",
    "b = 2 - 2\n",
    "c = 2 * 2\n",
    "d = 2 / 2\n",
    "e = 2 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 3: Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string is a sequence of characters, like the text MARY, that can be stored in a variable. A string literal is a string value specified in the source code of a program. A programmer creates a string literal by surrounding text with single or double quotes, such as 'MARY' or \"MARY\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "string = 'Hello, World!'\n",
    "print(string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The len() built-in function can be used to find the length of a string (and any other sequence type)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "string = \"Hello, World!\"\n",
    "print(len(string))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A programmer can access a character at a specific index by appending brackets [ ] containing the index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n"
     ]
    }
   ],
   "source": [
    "string = 'Hello, World!'\n",
    "print(string[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list is a container created by surrounding a sequence of variables or literals with brackets [ ]. Ex: my_list = [10, 'abc'] creates a new list variable my_list that contains the two items: 10 and 'abc'. A list item is called an element. A list is mutable, meaning that the elements in a list can be replaced, reordered, or removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "list = [1, 2, 3, 4, 5]\n",
    "print(list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An element can be updated with a new value by performing an assignment to a position in the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "list = [1, 2, 3, 4, 5]\n",
    "print(list[0])\n",
    "list[0] = 6\n",
    "print(list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple, usually pronounced \"tuhple\" or \"toople,\" stores a collection of data, like a list, but is immutable – once created, the tuple's elements cannot be changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "tuple = (1, 2, 3, 4, 5)\n",
    "print(tuple[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A named tuple allows the programmer to define a new simple data type that consists of named attributes. A Car named tuple with fields like Car.price and Car.horsepower would more clearly represent a car object than a list with index positions correlating to some attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Car(make='Chevrolet', model='Blazer', price=32000, horsepower=275, seats=8)\n",
      "Car(make='Chevrolet', model='Impala', price=37495, horsepower=305, seats=5)\n"
     ]
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Car = namedtuple('Car', ['make','model','price','horsepower','seats'])  # Create the named tuple\n",
    "\n",
    "chevy_blazer = Car('Chevrolet', 'Blazer', 32000, 275, 8)  # Use the named tuple to describe a car\n",
    "chevy_impala = Car('Chevrolet', 'Impala', 37495, 305, 5)  # Use the named tuple to describe a different car\n",
    "\n",
    "print(chevy_blazer)\n",
    "print(chevy_impala)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A set is an unordered collection of unique elements. A set has the following properties:\n",
    "\n",
    "+ Elements are unordered: Elements in the set do not have a position or index.\n",
    "\n",
    "+ Elements are unique: No elements in the set share the same value.\n",
    "\n",
    "A set can be created using the set() function, which accepts a sequence-type iterable object (list, tuple, string, etc.) whose elements are inserted into the set. A set literal can be written using curly braces { } with commas separating set elements. Note that an empty set can only be created using set()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "{8, 9, 7}\n"
     ]
    }
   ],
   "source": [
    "nums1 = set([1, 2, 3])\n",
    "\n",
    "nums2 = { 7, 8, 9 }\n",
    "\n",
    "print(nums1)\n",
    "print(nums2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets are mutable – elements can be added or removed using set methods. The add() method places a new element into the set if the set does not contain an element with the provided value. The remove() and pop() methods remove an element from the set.\n",
    "\n",
    "Anything added to a set or a list or anything using the .add() method, the data will be added to the end of the data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "{8, 9, 10, 7}\n"
     ]
    }
   ],
   "source": [
    "nums1 = set([1, 2, 3])\n",
    "\n",
    "nums2 = { 7, 8, 9 }\n",
    "\n",
    "nums1.add(4)\n",
    "nums2.add(10)\n",
    "\n",
    "print(nums1)\n",
    "print(nums2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dictionary is a Python container used to describe associative relationships. A dictionary is represented by the dict object type. A dictionary associates (or \"maps\") keys with values. A key is a term that can be located in a dictionary, such as the word \"cat\" in the English dictionary. A value describes some data associated with a key, such as a definition. A key can be any immutable type, such as a number, string, or tuple; a value can be any type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "25\n",
      "New York\n"
     ]
    }
   ],
   "source": [
    "dictionary = { 'name': 'John', 'age': 25, 'city': 'New York' }\n",
    "\n",
    "print(dictionary['name'])\n",
    "print(dictionary['age'])\n",
    "print(dictionary['city'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dict object is created using curly braces { } to surround the key:value pairs that comprise the dictionary contents."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A type conversion is a conversion of one type to another, such as an integer to a float. An implicit conversion is a type conversion automatically made by the interpreter, usually between numeric types. For example, the result of an arithmetic operation like + or * will be a float only if either operand of the operation is a float."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'dict'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "int_var = 5\n",
    "float_var = 5.0\n",
    "string = '5'\n",
    "list = [5]\n",
    "tuple = (5,)\n",
    "dictionary = {5: 'five'}\n",
    "\n",
    "print(type(int_var))\n",
    "print(type(float_var))\n",
    "print(type(string))\n",
    "print(type(list))\n",
    "print(type(tuple))\n",
    "print(type(dictionary))\n",
    "\n",
    "# Ensure float is not redefined\n",
    "float_value = int_var\n",
    "\n",
    "print(type(int_var))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 4: Branching"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a program, a branch is a sequence of statements only executed under a certain condition. Ex: A hotel may discount a price only for people over age 65. An if branch is a branch taken only if an expression is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 is greater than 2\n"
     ]
    }
   ],
   "source": [
    "if 5 > 2:\n",
    "    print('5 is greater than 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An if-else branch has two branches: The first branch is executed if an expression is true, else the other branch is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 is greater than 2\n"
     ]
    }
   ],
   "source": [
    "if 5 > 2:\n",
    "    print('5 is greater than 2')\n",
    "else:\n",
    "    print('5 is not greater than 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An expression involving an equality or inequality operator evaluates to a Boolean value. A Boolean is a type that has just two values: True or False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boolean is true\n"
     ]
    }
   ],
   "source": [
    "boolean = True\n",
    "\n",
    "if boolean:\n",
    "    print('Boolean is true')\n",
    "else:\n",
    "    print('Boolean is false')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a == b means a is equal to b.\tx == 3 is True\n",
    "                                    x == 4 is False\n",
    "\n",
    "a != b means a is not equal to b\tx != 3 is False\n",
    "                                        x != 4 is True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 5\n"
     ]
    }
   ],
   "source": [
    "a == b\n",
    "\n",
    "a != b\n",
    "\n",
    "a < b\n",
    "\n",
    "a > b\n",
    "\n",
    "a <= b\n",
    "\n",
    "a >= b\n",
    "\n",
    "a = 5\n",
    "\n",
    "if a == 5:\n",
    "    print('a is 5')\n",
    "else:\n",
    "    print('a is not 5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a AND b\tLogical AND: True when both of its operands are True.\n",
    "\n",
    "a OR b\tLogical OR: True when at least one of its two operands are True.\n",
    "\n",
    "NOT a\tLogical NOT: True when its one operand is False, and vice versa.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is 5 and greater than 2\n"
     ]
    }
   ],
   "source": [
    "a and b \n",
    "\n",
    "a or b\n",
    "\n",
    "not a\n",
    "\n",
    "a = 5\n",
    "\n",
    "if a == 5 and a > 2:\n",
    "    print('a is 5 and greater than 2')\n",
    "else:\n",
    "    print('a is not 5 and greater than 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes the programmer has multiple if statements in sequence, which looks similar to a multi-branch if-else statement but has a very different meaning. Each if statement is independent and more than one branch can execute, in contrast to the multi-branch if-else arrangement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are old enough to drive.\n",
      "You are old enough to vote.\n",
      "Most car rental companies will rent to you.\n"
     ]
    }
   ],
   "source": [
    "user_age = 26\n",
    "\n",
    "if user_age < 16:\n",
    "    print('Enjoy your early years.')\n",
    "   \n",
    "if user_age > 15:\n",
    "    print('You are old enough to drive.')\n",
    "\n",
    "if user_age > 17:\n",
    "    print('You are old enough to vote.')\n",
    "\n",
    "if user_age > 24:\n",
    "    print('Most car rental companies will rent to you.')\n",
    "\t   \n",
    "if user_age > 34:\n",
    "\tprint('You can run for president.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The in and not in operators, known as membership operators, yield True or False if the left operand matches the value of an element in the right operand, which is always a container."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "prices = [10, 20, 30, 40, 50]\n",
    "print(10 in prices)\n",
    "print(60 in prices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The programmer can use the identity operator, is, to check whether two operands are bound to a single object. The inverse identity operator, is not, gives the negated value of \"is\". Thus, if x is y is True, then x is not y is False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "c = [1, 2, 3]\n",
    "\n",
    "print(a is b)\n",
    "print(a is c)\n",
    "\n",
    "x = 10\n",
    "y = 20\n",
    "z = 10\n",
    "\n",
    "print(x is not y)\n",
    "print(x is not z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A code block is a series of statements grouped together. A code block in Python is defined by its indentation level. Ex: the number of blank columns from the left edge. The initial code block is not indented. A new code block can follow a statement that ends with a colon, such as an \"if\" or \"else\". In addition, a new code block must be more indented than the previous code block. The program below includes comments indicating where each new code block begins."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 5: Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A program may perform the same operation repeatedly, causing a large and confusing program due to redundancy. Program redundancy can be reduced by creating a grouping of predefined statements for repeated operations, known as a function. Even without redundancy, functions can prevent a main program from becoming large and confusing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function is a named series of statements.\n",
    "\n",
    "+ A function definition consists of the function's name and a block of statements. Ex: def calc_pizza_area(): is followed by an indented block of statements.\n",
    "\n",
    "+ A function call is an invocation of the function's name, causing the function's statements to execute.\n",
    "\n",
    "Python comes with a number of built-in functions, such as input(), int(), len(), etc. The def keyword is used to create new functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12.0 inch pizza is 113.097 square inches\n"
     ]
    }
   ],
   "source": [
    "def calc_pizza_area():\n",
    "    pi_val = 3.14159265\n",
    "\n",
    "    pizza_diameter = 12.0\n",
    "    pizza_radius = pizza_diameter / 2.0\n",
    "    pizza_area = pi_val * pizza_radius * pizza_radius\n",
    "    return pizza_area\n",
    "\n",
    "print(f'{12:.1f} inch pizza is {calc_pizza_area():.3f} square inches')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function that only prints typically does not return a value. A function with no return statement is called a void function, and such a function returns the value None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice!\n"
     ]
    }
   ],
   "source": [
    "def greet(name):\n",
    "    print(f\"Hello, {name}!\")\n",
    "\n",
    "greet(\"Alice\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function's behavior of adding together different types is a concept called polymorphism. Polymorphism is an inherent part of the Python language. For example, consider the multiplication operator *. If the two operands are numbers, then the result is the product of those two numbers. If one operand is a string and the other an integer (e.g., 'x' * 5), then the result is a repetition of the string five times: 'xxxxx'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 * 3 = 15\n",
      "'x' * 5 = xxxxx\n"
     ]
    }
   ],
   "source": [
    "# Example of polymorphism with the multiplication operator\n",
    "num_result = 5 * 3\n",
    "str_result = 'x' * 5\n",
    "\n",
    "print(f'5 * 3 = {num_result}')  # Output: 15\n",
    "print(f\"'x' * 5 = {str_result}\")  # Output: xxxxx"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses dynamic typing to determine the type of objects as a program executes. Ex: The consecutive statements num = 5 and num = '7' first assign with an integer type and then a string type. The type of num can change depending on the value it references. The interpreter is responsible for checking that all operations are valid as the program executes. If the function call add(5, '100') is evaluated, an error is generated when adding the string to an integer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num is 5 and its type is <class 'int'>\n",
      "num is now 7 and its type is <class 'str'>\n",
      "Error: can only concatenate str (not \"int\") to str\n"
     ]
    }
   ],
   "source": [
    "# Example of dynamic typing in Python\n",
    "num = 5\n",
    "print(f'num is {num} and its type is {type(num)}')\n",
    "\n",
    "num = '7'\n",
    "print(f'num is now {num} and its type is {type(num)}')\n",
    "\n",
    "# This will cause an error because you cannot add an integer and a string\n",
    "try:\n",
    "    result = num + 100\n",
    "except TypeError as e:\n",
    "    print(f'Error: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In contrast to dynamic typing, many other languages like C, C++, and Java use static typing, which requires the programmer to define the type of every variable and every function parameter in a program's source code. Ex: string name = \"John\" declares a string variable in C++. When the source code is compiled, the compiler attempts to detect non type-safe operations, and halts the compilation process if such an operation is found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "variable is 10 and its type is <class 'int'>\n",
      "variable is now Python and its type is <class 'str'>\n",
      "Error: can only concatenate str (not \"int\") to str\n"
     ]
    }
   ],
   "source": [
    "# Example of dynamic typing in Python\n",
    "variable = 10\n",
    "print(f'variable is {variable} and its type is {type(variable)}')\n",
    "\n",
    "variable = 'Python'\n",
    "print(f'variable is now {variable} and its type is {type(variable)}')\n",
    "\n",
    "# This will cause an error because you cannot concatenate a string and an integer\n",
    "try:\n",
    "    result = variable + 100\n",
    "except TypeError as e:\n",
    "    print(f'Error: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scope is the area of code where a name is visible. Namespaces are used to make scope work. Each scope, such as global scope or a local function scope, has its own namespace. If a namespace contains a name at a specific location in the code, then that name is visible and a programmer can use it in an expression."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+ Global variables are added to the global namespace.\n",
    "+ Calling a function creates a new local namespace for local variables.\n",
    "+ Variables are resolved by looking in the local namespace first, then global, then built-in.\n",
    "+ The local namespace is removed when the function returns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local x: 5\n",
      "Global x: 10\n"
     ]
    }
   ],
   "source": [
    "# Global variable\n",
    "x = 10\n",
    "\n",
    "def my_function():\n",
    "    # Local variable\n",
    "    x = 5\n",
    "    print(f'Local x: {x}')\n",
    "\n",
    "my_function()\n",
    "print(f'Global x: {x}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arguments to functions are passed by object reference, a concept known in Python as pass-by-assignment. When a function is called, new local variables are created in the function's local namespace by binding the names in the parameter list to the passed arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside function: [1, 2, 3, 100]\n",
      "Outside function: [1, 2, 3, 100]\n"
     ]
    }
   ],
   "source": [
    "def modify_list(my_list):\n",
    "    # Modify the list by appending an element\n",
    "    my_list.append(100)\n",
    "    print(f'Inside function: {my_list}')\n",
    "\n",
    "# Create a list\n",
    "original_list = [1, 2, 3]\n",
    "\n",
    "# Call the function and pass the list\n",
    "modify_list(original_list)\n",
    "\n",
    "# Print the list after the function call\n",
    "print(f'Outside function: {original_list}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes a programmer doesn't know how many arguments a function requires. A function definition can include an *args parameter that collects optional positional parameters into an arbitrary argument list tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "def print_args(*args):\n",
    "    for arg in args:\n",
    "        print(arg)\n",
    "\n",
    "# Example usage\n",
    "print_args(1, 2, 3, 'a', 'b', 'c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding a final function parameter of **kwargs, short for keyword arguments, creates a dictionary containing \"extra\" arguments not defined in the function definition. The keys of the dictionary are the parameter names specified in the function call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name = Alice\n",
      "age = 25\n",
      "city = New York\n"
     ]
    }
   ],
   "source": [
    "def print_kwargs(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(f'{key} = {value}')\n",
    "\n",
    "# Example usage\n",
    "print_kwargs(name='Alice', age=25, city='New York')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chapter 6: Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A loop is a program construct that repeatedly executes the loop's statements (known as the loop body) while the loop's expression is true; when the expression is false, execution proceeds past the loop. Each time through a loop's statements is called an iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count is: 0\n",
      "Count is: 1\n",
      "Count is: 2\n",
      "Count is: 3\n",
      "Count is: 4\n",
      "Iteration: 0\n",
      "Iteration: 1\n",
      "Iteration: 2\n",
      "Iteration: 3\n",
      "Iteration: 4\n"
     ]
    }
   ],
   "source": [
    "# Example of a while loop\n",
    "count = 0\n",
    "while count < 5:\n",
    "    print(f'Count is: {count}')\n",
    "    count += 1\n",
    "\n",
    "# Example of a for loop\n",
    "for i in range(5):\n",
    "    print(f'Iteration: {i}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A while loop is a construct that repeatedly executes an indented block of code (known as the loop body) as long as the loop's expression is True. At the end of the loop body, execution goes back to the while loop statement and the loop expression is evaluated again. If the loop expression is True, the loop body is executed again. But, if the expression evaluates to False, then execution instead proceeds to below the loop body. Each execution of the loop body is called an iteration, and looping is also called iterating."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i = 0, j = 0\n",
      "i = 0, j = 1\n",
      "i = 1, j = 0\n",
      "i = 1, j = 1\n",
      "i = 2, j = 0\n",
      "i = 2, j = 1\n"
     ]
    }
   ],
   "source": [
    "# Example of a nested loop\n",
    "for i in range(3):\n",
    "    for j in range(2):\n",
    "        print(f'i = {i}, j = {j}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Commonly, a loop should iterate a specific number of times, such as 10 times. The programmer can use a variable to count the number of iterations, called a loop variable. To iterate N times using an integer loop variable i, a loop1 with the following form is used\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Iterating N times using a loop variable\n",
    "N = 10  # Define N with a value\n",
    "i = 1\n",
    "while i <= N:\n",
    "    # Loop body statements go here\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A for loop statement loops over each element in a container one at a time, assigning a variable with the next element that can then be used in the loop body. The container in the for loop statement is typically a list, tuple, or string. Each iteration of the loop assigns the name given in the for loop statement with the next element in the container."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of N is: 10\n",
      "The value of i is: 11\n",
      "11 is greater than 10\n"
     ]
    }
   ],
   "source": [
    "# Example using the variables N and i\n",
    "print(f'The value of N is: {N}')\n",
    "print(f'The value of i is: {i}')\n",
    "\n",
    "# Check if i is greater than N\n",
    "if i > N:\n",
    "    print(f'{i} is greater than {N}')\n",
    "else:\n",
    "    print(f'{i} is not greater than {N}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "range() generates a sequence of integers between a starting integer that is included in the range, an ending integer that is not included in the range, and an integer step value. The sequence is generated by starting at the start integer and incrementing by the step value until the ending integer is reached or surpassed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n",
      "13\n",
      "15\n",
      "17\n",
      "19\n"
     ]
    }
   ],
   "source": [
    "# Example of using range() to generate a sequence of integers\n",
    "start = 1\n",
    "end = 20\n",
    "step = 2\n",
    "\n",
    "sequence = range(start, end, step)\n",
    "for num in sequence:\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both while loops and for loops can be used to count a specific number of loop iterations. A for loop combined with range() is generally preferred over while loops, since for loops are less likely to become stuck in an infinite loop situation. A programmer may easily forget to increment a while loop's variable (causing an infinite loop), but for loops iterate over a finite number of elements in a container and are thus guaranteed to complete."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration 1\n",
      "Iteration 2\n",
      "Iteration 3\n",
      "Iteration 4\n",
      "Iteration 5\n",
      "Iteration 6\n",
      "Iteration 7\n",
      "Iteration 8\n",
      "Iteration 9\n",
      "Iteration 10\n"
     ]
    }
   ],
   "source": [
    "# Using a for loop with range() to iterate N times\n",
    "for i in range(1, N + 1):\n",
    "    print(f'Iteration {i}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A nested loop is a loop that appears as part of the body of another loop. The nested loops are commonly referred to as the outer loop and inner loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Outer loop iteration 1\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 2\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 3\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 4\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 5\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 6\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 7\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 8\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 9\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n",
      "Outer loop iteration 10\n",
      "  Inner loop iteration 1\n",
      "  Inner loop iteration 2\n",
      "  Inner loop iteration 3\n",
      "  Inner loop iteration 4\n",
      "  Inner loop iteration 5\n",
      "  Inner loop iteration 6\n",
      "  Inner loop iteration 7\n",
      "  Inner loop iteration 8\n",
      "  Inner loop iteration 9\n"
     ]
    }
   ],
   "source": [
    "# Outer loop\n",
    "for outer in range(1, N + 1):\n",
    "    print(f'Outer loop iteration {outer}')\n",
    "    \n",
    "    # Inner loop\n",
    "    for inner in range(1, i):\n",
    "        print(f'  Inner loop iteration {inner}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Experienced programmers practice incremental programming by starting with a simple version of the program, and growing the program little by little into a complete version."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A break statement in a loop causes the loop to exit immediately. A break statement can sometimes yield a loop that is easier to understand."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continue statement in a loop causes an immediate jump to the while or for loop header statement. A continue statement can improve the readability of a loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example of break statement:\n",
      "Iteration 1\n",
      "Iteration 2\n",
      "Iteration 3\n",
      "Iteration 4\n",
      "\n",
      "Example of continue statement:\n",
      "Iteration 1\n",
      "Iteration 3\n",
      "Iteration 5\n",
      "Iteration 7\n",
      "Iteration 9\n"
     ]
    }
   ],
   "source": [
    "# Example of break statement\n",
    "print(\"Example of break statement:\")\n",
    "for num in range(1, N + 1):\n",
    "    if num == 5:\n",
    "        break\n",
    "    print(f'Iteration {num}')\n",
    "\n",
    "# Example of continue statement\n",
    "print(\"\\nExample of continue statement:\")\n",
    "for num in range(1, N + 1):\n",
    "    if num % 2 == 0:\n",
    "        continue\n",
    "    print(f'Iteration {num}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loop else construct executes if the loop completes normally. In the following example, a special message \"All names printed\" is displayed if the entire list of names is completely iterated through."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice\n",
      "Bob\n",
      "Charlie\n",
      "David\n",
      "All names printed\n"
     ]
    }
   ],
   "source": [
    "names = [\"Alice\", \"Bob\", \"Charlie\", \"David\"]\n",
    "\n",
    "for name in names:\n",
    "    print(name)\n",
    "else:\n",
    "    print(\"All names printed\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The enumerate() function retrieves both the index and corresponding element value at the same time, providing a cleaner and more readable solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unpacking is a process that performs multiple assignments at once, binding comma-separated names on the left to the elements of a sequence on the right. Ex: num1, num2 = [350, 400] is equivalent to the statements num1 = 350 and num2 = 400."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index: 0, Fruit: apple\n",
      "Index: 1, Fruit: banana\n",
      "Index: 2, Fruit: cherry\n",
      "x: 10, y: 20\n"
     ]
    }
   ],
   "source": [
    "# Example of using enumerate() to retrieve index and element value\n",
    "fruits = ['apple', 'banana', 'cherry']\n",
    "for index, fruit in enumerate(fruits):\n",
    "    print(f'Index: {index}, Fruit: {fruit}')\n",
    "\n",
    "# Example of unpacking\n",
    "coordinates = (10, 20)\n",
    "x, y = coordinates\n",
    "print(f'x: {x}, y: {y}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}