01-introduction-to-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Theory of Programming\n",
    "\n",
    "A computer does two things, and two things only: it performs calculations and it remembers the results of those calculations. But it does those two things extremely well.\n",
    "\n",
    "### Computation\n",
    "\n",
    "A **computation** is any type of arithmetic or non-arithmetic calculation that is well-defined.\n",
    "\n",
    "* **Logical operations** determine whether statements $p, q, r, \\ldots$ evaluate to **true** or **false**. There are three typical operations on statements that programming languages can perform: NOT ($\\neg$), OR ($\\vee$), and AND ($\\wedge$). For example, if we have statements $p$ and $q$ and we don't know their logical values, we can build logical tables that present possible results of any of these operations. Remember that 0 means **false**, and 1 means **true**.\n",
    "    $$\\begin{array}{c | c}\n",
    "        p & \\neg p \\\\\n",
    "        \\hline\n",
    "        0 & 1 \\\\\n",
    "        1 & 0\n",
    "    \\end{array} \\quad \\begin{array}{c | c | c | c}\n",
    "        p & q & p \\vee q & p \\wedge q \\\\\n",
    "        \\hline\n",
    "        0 & 0 & 0 & 0 \\\\\n",
    "        0 & 1 & 1 & 0 \\\\\n",
    "        1 & 0 & 1 & 0 \\\\\n",
    "        1 & 1 & 1 & 1\n",
    "    \\end{array}$$\n",
    "\n",
    "* **Arithmetic operations** that we know from primary school include addition ($+$), subtraction ($-$), multiplication ($⋅$), division ($/$), and also modulo (`mod`). The last one returns the remainder of dividing two numbers. For example, $5 / 3$ returns $1$ with a remainder of $2$. Thus, the operation $5 \\text{ mod } 3$ returns $2$.\n",
    "\n",
    "* **Data manipulation** is necessary because a computer must store values to operate on them later. This mechanism is called variables. You know it from classical mathematics. However, computers are able to manipulate these values. For example, the statement $x \\gets 1$ means that the variable $x$ stores the value $1$. So, when we want to evaluate the expression $x + 6$, we get $7$. The statement $x \\gets x + 3$ means that now the variable $x$ stores its previous value increased by $3$. So now, when we want to evaluate $x + 6$, we get $10$ because $x$ stores $4$ at this moment. This is a very simple example, but computers are able to create extended data structures that can contain many variables. Some of these structures have specified types of data (for example, arrays), while others can store any type (for example, lists).\n",
    "\n",
    "* **Decision-making processes** can change the direction of code evaluation. Normally, programs execute commands line by line, but usually we want to change a program's behavior based on the value of logical statements. For example, if the variable $x$ stores an odd number, we want to print `x is odd`, and if $x$ stores an even number, we want to print `x is even`. It is impossible to make this process work by evaluating line by line, so programmers need a mechanism to change the order of execution. To achieve this, most programming languages use the `if-else` mechanism. If some logical statement is true, the program executes the body of the if statement. Otherwise, the lines after the `else` statement are executed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithm\n",
    "\n",
    "Informally, an **algorithm** is any well-defined computational procedure that takes some value, or set of values, as **input** and produces some value, or set of values, as **output** in a finite amount of time. An algorithm is thus a sequence of computational steps that transform the input into the output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Imperative versus Declarative Knowledge\n",
    "\n",
    "All knowledge can be thought of as either declarative or imperative. **Declarative knowledge** is composed of statements of fact. **Imperative knowledge** is “how to” knowledge, or recipes for deducing information.\n",
    "\n",
    "Assume we want to evaluate the value of $\\sqrt{x}$ given $x$.\n",
    "\n",
    "- By **declarative programming**, we say that $\\sqrt{x}$ is the value of some $y$ such that $y^2 = x$.\n",
    "\n",
    "- By **imperative programming**, the value of $\\sqrt{x}$ is the result of the following procedure.\n",
    "\n",
    "    ```bash\n",
    "    SQUARE_ROOT(int x): float\n",
    "        g <- x / 2\n",
    "        if g^2 is close enough to x then\n",
    "            return g\n",
    "        else\n",
    "            g <- (g + (x/g)) / 2\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fixed-Program Computer\n",
    "\n",
    "The earliest computing machines were, in fact, **fixed-program computers**, meaning they were designed to do very specific things, and were mostly tools to solve a specific mathematical problem.\n",
    "\n",
    "Examples of fixed-program computers.\n",
    "\n",
    "* **Calculator** - arithmetic operations.\n",
    "\n",
    "    ![calculator](https://upload.wikimedia.org/wikipedia/commons/thumb/c/cf/Casio_calculator_JS-20WK_in_201901_002.jpg/340px-Casio_calculator_JS-20WK_in_201901_002.jpg)\n",
    "\n",
    "* **Atanasoff-Berry Computer** - solving large systems of linear equations.\n",
    "\n",
    "    ![Atanasoff-Berry Computer](https://upload.wikimedia.org/wikipedia/commons/thumb/0/01/Atanasoff-Berry_Computer_at_Durhum_Center.jpg/440px-Atanasoff-Berry_Computer_at_Durhum_Center.jpg)\n",
    "\n",
    "* **Turing's Bombe** - encrypting secret messages during World War II.\n",
    "\n",
    "    ![Turing's Bombe](https://upload.wikimedia.org/wikipedia/commons/thumb/7/7a/Wartime_picture_of_a_Bletchley_Park_Bombe.jpg/500px-Wartime_picture_of_a_Bletchley_Park_Bombe.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stored-Program Computer\n",
    "\n",
    "In **stored-program computers**, instructions to be executed by the processor called the CPU (Central Processing Unit) are stored in the computer's memory along with data.\n",
    "\n",
    "![von Neumann Architecture](https://media.geeksforgeeks.org/wp-content/uploads/basic_structure.png)\n",
    "\n",
    "The **Von Neumann Architecture** is a computer architecture design that describes a system where program instructions and data share the same memory space. It consists of the following key components:\n",
    "\n",
    "**Memory**\n",
    "\n",
    "- Stores both data and program instructions.\n",
    "\n",
    "- Uses a single read/write system for data and instructions.\n",
    "\n",
    "- Addressable in a linear fashion, where each memory location has a unique address.\n",
    "\n",
    "**Control Unit (CU)**\n",
    "\n",
    "- Directs the operation of the processor.\n",
    "\n",
    "- Fetches instructions from memory, decodes them, and executes them.\n",
    "\n",
    "- Manages the flow of data between components.\n",
    "\n",
    "**Arithmetic Logic Unit (ALU)**\n",
    "\n",
    "- Performs mathematical operations (addition, subtraction, multiplication, division).\n",
    "\n",
    "- Handles logical operations (AND, OR, NOT, XOR).\n",
    "\n",
    "- Works closely with the control unit to execute instructions.\n",
    "\n",
    "**Accumulator**\n",
    "\n",
    "- A special-purpose register within the ALU.\n",
    "\n",
    "- Temporarily holds data being processed (e.g., intermediate results of calculations).\n",
    "\n",
    "- Reduces the need for frequent memory access, improving efficiency.\n",
    "\n",
    "**Processor (CPU)**\n",
    "\n",
    "- The central processing unit that contains the Control Unit and ALU.\n",
    "\n",
    "- Executes instructions stored in memory.\n",
    "\n",
    "- Controls all operations within the computer.\n",
    "\n",
    "**Input/Output (I/O)**\n",
    "\n",
    "- Handles communication between the computer and external devices.\n",
    "\n",
    "- Input devices (e.g., keyboard, mouse) provide data to the computer.\n",
    "\n",
    "- Output devices (e.g., monitor, printer) display processed data.\n",
    "\n",
    "This architecture is the foundation of most modern computing systems and remains widely used in various computing devices.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Languages\n",
    "\n",
    "It's time to present one of the programming languages. I will be using **Python** due to its simplicity and low entry threshold.  \n",
    "\n",
    "**Important note:** This is not a repository on Python as a programming language. I will use Python to present the basics of programming, basic concepts, and paradigms of programming that can be applied to other languages.\n",
    "\n",
    "Another important thing to note is that the perfect programming language does not exist. Every language has a specific role, and the choice depends on the role that the language has to fulfill.\n",
    "\n",
    "- **Matlab** - great for working with vectors and matrices.  \n",
    "\n",
    "- **C** - great for programming tasks involving data networks.  \n",
    "\n",
    "- **Scheme** - great for problems involving arbitrarily structured datasets.  \n",
    "\n",
    "- **PHP** - great for building Web sites.  \n",
    "\n",
    "- **Python** - great for beginners who have never written any programs.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Literals\n",
    "\n",
    "The primitive constructs in Python include *literals* (e.g., the numbers `8` and `3.2` and the string like `'abc'`) and *infix operators* (e.g., `+` and `/`).  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Syntax\n",
    "\n",
    "The **syntax** of a language defines which strings of characters and symbols are well-formed.  \n",
    "For example, in English, the string `\"Cat dog boy\"` is not a syntactically valid sentence because the syntax of English does not accept sentences of the form `<noun> <noun> <noun>`.  \n",
    "In Python, the sequence of primitives `3.2 + 3.2` is syntactically well-formed, but the sequence `3.2 3.2 +` is not. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Static Semantics\n",
    "\n",
    "The **static semantics** defines which syntactically valid strings have a meaning.  \n",
    "For example, in English, the string `\"I runs fast\"` is of the form `<pronoun> <verb> <adverb>`, which is a syntactically acceptable sequence. Nevertheless, it is not valid English because the noun `\"I\"` is singular, and the verb `\"runs\"` is plural.  \n",
    "This is an example of a static semantic error.  \n",
    "\n",
    "In Python, the sequence `3.2/'abc'` is syntactically well-formed (`<literal> <operator> <literal>`), but produces a static semantic error since it is not meaningful to divide a number by a string of characters.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Semantics\n",
    "\n",
    "The **semantics**, also called **full semantics**, of a language associates a meaning with each syntactically correct string of symbols that has no static semantic errors.  \n",
    "In natural languages, the semantics of a sentence can be ambiguous.  \n",
    "For example, the sentence `\"I cannot praise this student too highly\"` can be either flattering or damning.  \n",
    "Programming languages are designed so that each legal program has exactly one meaning.  \n",
    "\n",
    "Assume we want to create a function that will multiply three values.\n",
    "\n",
    "*Incorrect version*:\n",
    "\n",
    "```bash\n",
    "MULTIPLIER(int a, int b, int c): int\n",
    "    return a + b + c\n",
    "```\n",
    "\n",
    "This program is statically semantically correct but produces unexpected output. This implies that the program is not fully correct semantically.\n",
    "\n",
    "*Correct version*:\n",
    "```bash\n",
    "MULTIPLIER(int a, int b, int c): int\n",
    "    return a * b * c\n",
    "```\n",
    "\n",
    "This procedure is fully correct semantically."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Low-level versus High-level\n",
    "\n",
    "**Low-level** versus **high-level** refers to whether we program using instructions and data objects at the level of the machine (e.g., moving 64 bits of data from one location to another) or whether we program using more abstract operations (e.g., popping up a menu on the screen) that have been provided by the language designer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### General-purpose versus Domain-specific\n",
    "\n",
    "**General-purpose** versus **domain-specific** refers to whether the primitive operations of the programming language are widely applicable or fine-tuned to a specific domain.  \n",
    "\n",
    "For example, **SQL** is designed for extracting information from relational databases, but you wouldn’t want to use it to build an operating system."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interpreted versus Compiled\n",
    "\n",
    "**Interpreted** versus **compiled** refers to whether the sequence of instructions written by the programmer (source code) is executed directly by an **interpreter**, or whether it is first converted by a **compiler** into a sequence of machine-level operations.\n",
    "\n",
    "- **Interpreted languages** (e.g., Python) allow for easier debugging since errors can be caught during execution.\n",
    "\n",
    "- **Compiled languages** (e.g., C) generally produce programs that run faster and use less memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python\n",
    "\n",
    "Python is a **High-level, General-purpose, and Interpreted** language.\n",
    "\n",
    "The symbol `>>>` is a shell prompt indicating that the interpreter is expecting the user to type some Python code into the shell. The line below the line with the prompt is produced when the interpreter evaluates the Python code entered at the prompt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "69\n"
     ]
    }
   ],
   "source": [
    "print(34 + 35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scalar Objects\n",
    "\n",
    "*Scalar* objects are indivisible. Think of them as the atoms of the language. Python has four types of scalar objects:\n",
    "\n",
    "- **`int`** - Used to represent integers. Literals of type `int` are written in the way we typically denote integers (e.g., `-3`, `5`, or `10002`).\n",
    "\n",
    "- **`float`** - Used to represent real numbers. Literals of type `float` always include a decimal point (e.g., `3.0`, `3.17`, or `-28.72`). \n",
    "\n",
    "  - It is also possible to write `float` literals using scientific notation. For example, the literal `1.6E3` stands for $1.6 \\times 10^3$, i.e., it is the same as `1600.0`.  \n",
    "\n",
    "  - You might wonder why this type is not called *real*. Within the computer, values of type `float` are stored as **floating-point numbers**. This representation, which is used by all modern programming languages, has many advantages. However, in some situations, floating-point arithmetic behaves slightly differently from arithmetic on real numbers.  \n",
    "\n",
    "- **`bool`** - Used to represent the Boolean values `True` and `False`.\n",
    "\n",
    "- **`None`** - A type with a single value.\n",
    "\n",
    "You can check the type of data using `type()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(25.75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(49.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(34 > 35)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operators\n",
    "\n",
    "Operators on objects of type `int` and `float` are listed below:\n",
    "\n",
    "- **`i + j`** → Sum of `i` and `j`.  \n",
    "\n",
    "  - If `i` and `j` are both of type `int`, the result is an `int`.  \n",
    "\n",
    "  - If either of them is a `float`, the result is a `float`.\n",
    "\n",
    "- **`i - j`** → `i` minus `j`.  \n",
    "\n",
    "  - If `i` and `j` are both of type `int`, the result is an `int`.  \n",
    "\n",
    "  - If either of them is a `float`, the result is a `float`.\n",
    "\n",
    "- **`i * j`** → Product of `i` and `j`.  \n",
    "\n",
    "  - If `i` and `j` are both of type `int`, the result is an `int`.  \n",
    "\n",
    "  - If either of them is a `float`, the result is a `float`.\n",
    "\n",
    "- **`i // j`** → Integer division.  \n",
    "\n",
    "  - Example: `6 // 2` results in the `int` `3`, and `6 // 4` results in the `int` `1` because integer division returns the quotient and ignores the remainder.  \n",
    "\n",
    "  - If `j = 0`, an error occurs.\n",
    "\n",
    "- **`i / j`** → `i` divided by `j`.  \n",
    "\n",
    "  - In Python 3, `/` performs floating-point division.  \n",
    "\n",
    "  - Example: `6 / 4` results in `1.5`.  \n",
    "\n",
    "  - If `j = 0`, an error occurs.  \n",
    "\n",
    "  - *(In Python 2, if `i` and `j` are both of type `int`, `/` behaves like `//` and returns an `int`. If either `i` or `j` is a `float`, it behaves like Python 3's `/` operator.)*\n",
    "\n",
    "- **`i % j`** → The remainder when `int` `i` is divided by `int` `j`.  \n",
    "\n",
    "  - Typically pronounced as \"`i` mod `j`,\" short for \"`i` modulo `j`.\"\n",
    "\n",
    "- **`i ** j`** → `i` raised to the power of `j`.  \n",
    "\n",
    "  - If `i` and `j` are both of type `int`, the result is an `int`.  \n",
    "\n",
    "  - If either of them is a `float`, the result is a `float`.\n",
    "\n",
    "- **Comparison operators**:  \n",
    "\n",
    "  - `==` (equal)  \n",
    "\n",
    "  - `!=` (not equal)  \n",
    "\n",
    "  - `>` (greater)  \n",
    "\n",
    "  - `>=` (at least)  \n",
    "  \n",
    "  - `<` (less)  \n",
    "\n",
    "  - `<=` (at most)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(3 + 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(8 - 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4\n"
     ]
    }
   ],
   "source": [
    "print(5 - 9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n"
     ]
    }
   ],
   "source": [
    "print(3.0 + 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n"
     ]
    }
   ],
   "source": [
    "print(3.0 + 4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56\n"
     ]
    }
   ],
   "source": [
    "print(7 * 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6666666666666667\n"
     ]
    }
   ],
   "source": [
    "print(5 / 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "print(12 / 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(12 // 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(10 // 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[20], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m)\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "print(3 / 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "integer division or modulo by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[21], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m)\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: integer division or modulo by zero"
     ]
    }
   ],
   "source": [
    "print(3 // 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(8 % 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(9 % 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(7 % 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(3 ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "343\n"
     ]
    }
   ],
   "source": [
    "print(7 ** 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "print(16 ** (1 / 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n"
     ]
    }
   ],
   "source": [
    "print(16 ** 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(4 == 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(4 != 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(4 > 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(4 >= 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(5 >= 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(4 < 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(4 <= 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic Precedence\n",
    "\n",
    "The arithmetic operators have the usual precedence.  \n",
    "\n",
    "For example, `*` binds more tightly than `+`, so the expression `x + y * 2` is evaluated by first multiplying `y` by `2` and then adding the result to `x`.  \n",
    "\n",
    "The order of evaluation can be changed by using parentheses to group subexpressions.  \n",
    "For example, `(x + y) * 2` first adds `x` and `y`, and then multiplies the result by `2`.  \n",
    "\n",
    "There is only one exception to this rule: the `**` operator, which evaluates from right to left.  \n",
    "For example, the expression `4 ** 3 ** 2` is evaluated as `262144` instead of `4096`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.741309711199751\n"
     ]
    }
   ],
   "source": [
    "print((3 ** (1 / 2) ** (1 / 3) - 4 ** (1 / 2)) * 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.940096426719496\n"
     ]
    }
   ],
   "source": [
    "print((4 ** ((1 / 2) ** (1 / 512) * 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.942763357360935\n"
     ]
    }
   ],
   "source": [
    "print(17 - (2 ** (3 * (2 / 7))) * 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bool Operators\n",
    "\n",
    "The primitive operators on type `bool` are `and`, `or`, and `not`.\n",
    "\n",
    "- **`a and b`** → `True` if both `a` and `b` are `True`, and `False` otherwise.  \n",
    "\n",
    "- **`a or b`** → `True` if at least one of `a` or `b` is `True`, and `False` otherwise.  \n",
    "\n",
    "- **`not a`** → `True` if `a` is `False`, and `False` if `a` is `True`.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(not 3 > 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(5 > 6 and not 7 > 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(7 > 6 and not 5 > 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(15 > 12 and not 4 > 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(not True or 3 > 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not True or 3 > 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(16 > 15 or 7 < 5 and 4 > -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(12 > 7 or 14 < 8 and 5 < 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print((18 > 13 or 17 < 12) and (7 < 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print((3 > 2 or 9 < 4) and 7 < 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables\n",
    "\n",
    "**Variables** provide a way to associate names with objects. A variable is just a name, nothing more. Remember this because it is important.  \n",
    "\n",
    "An assignment statement associates the name to the left of the `=` symbol with the object denoted by the expression to the right of the `=`. Remember this too.  \n",
    "\n",
    "An object can have one, more than one, or no name associated with it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28\n"
     ]
    }
   ],
   "source": [
    "y = 4 * 7\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-3.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-4.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-5.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'x' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[52], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m x\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mx\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'x' is not defined"
     ]
    }
   ],
   "source": [
    "del x\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-6.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[53], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m y\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43my\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "del y\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-8.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-9.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "y = 10\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-10.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "z = x\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-11.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 10 10\n"
     ]
    }
   ],
   "source": [
    "x = x + 1\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-12.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Variable](images/variables-13.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reserved Words\n",
    "\n",
    "There are a small number of *reserved words* (sometimes called *keywords*) in Python that have built-in meanings and cannot be used as variable names. Different versions of Python have slightly different lists of reserved words.  \n",
    "\n",
    "The reserved words in Python 3 are:  \n",
    "`and`, `as`, `assert`, `break`, `class`, `continue`, `def`, `del`, `elif`, `else`, `except`, `False`, `finally`, `for`, `from`, `global`, `if`, `import`, `in`, `is`, `lambda`, `nonlocal`, `None`, `not`, `or`, `pass`, `raise`, `return`, `True`, `try`, `while`, `with`, and `yield`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "true = 1\n",
    "print(true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to False (1160946929.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[60], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    False = 0\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m cannot assign to False\n"
     ]
    }
   ],
   "source": [
    "False = 0"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}