activities/day1_variables_and_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "360c13df-200c-4a07-afd2-ca8cfb7749f2",
   "metadata": {},
   "source": [
    "# UQ SMP Programming Bootcamp (Python) V1\n",
    "\n",
    "## Day 1 activities: variables and basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45da76df-a658-4efd-8cc8-fbb4758910b3",
   "metadata": {},
   "source": [
    "There are 6 tasks for this day. Ideally have each task solved in a different Python file running in Spyder. Ideally have these files in your GitHub repo by the end of the day as well (only work on getting git going once tasks and key points are complete)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fdc52b2-51e7-4b3e-8fe6-e8aaba0839a9",
   "metadata": {},
   "source": [
    "The following cells are to be typed line by line into the prompt:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b0f9a1ee-44a3-49d8-8deb-b394930f8b63",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ebe75663-0799-4d3f-94ed-ef9678f2c13c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a # when you do this Jupyter presents the variable value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2f7fdea4-a8f1-460e-8dd6-cd27f51ff962",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'A' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[3], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mA\u001b[49m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'A' is not defined"
     ]
    }
   ],
   "source": [
    "A # \"A\" and \"a\" are different things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "da9765c9-4619-4be3-bf0b-1ca5ff30a8a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 6 # another variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "992d7573-cd87-421f-963c-bb2c18575cb1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b # operations between variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5a55310b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - b # subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "693d288c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "144"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*b # multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d713de26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a/b # division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "51db3d8d-c3a7-4443-9a35-30c7ee334818",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = a + b # = means assignment (put RHS in LHS)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3b8adf06-99d7-4e60-bd64-44d855fdb022",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"hello\" #Variables don't have to be numbers. This is a string\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8d90f87a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dogcat'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"dog\"\n",
    "b = \"cat\"\n",
    "c = a + b # we can add strings together (concatenation)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "08f97fe6-96c5-4564-844a-393b1953d561",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[12], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdog\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m      2\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m\n\u001b[1;32m----> 3\u001b[0m c \u001b[38;5;241m=\u001b[39m \u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m \u001b[38;5;66;03m# but you'll get an error adding a number and a string\u001b[39;00m\n\u001b[0;32m      4\u001b[0m c\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "a = \"dog\"\n",
    "b = 3\n",
    "c = a + b # but you'll get an error adding a number and a string\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0d692d4b",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[13], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m3\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m5\u001b[39;49m\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "\"3\" + 5 # it still will not work even if the string contains a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "517d9739",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'35'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"3\" + \"5\" #adding two strings that are numbers will work differently to adding two integers together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "5047db03-1aff-4ac2-b536-e30d6b7e0ca7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"3\"\n",
    "type(a) #A is a string (str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fb24cc86-ef87-4d34-a2f9-658bd2e82e5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 5\n",
    "type(b) #B is an integer value (int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "70a26c82-0597-49c9-a1e0-f6835fd9151e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = int(a) # we can convert a string into an integer\n",
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "07a49744",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'hello!'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[18], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mhello!\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'hello!'"
     ]
    }
   ],
   "source": [
    "int(\"hello!\") # it needs to make sense as an integer for this conversion to work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6bfdbadd-1f22-4a84-9cf6-42d853a92877",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(a) + b # once we have converted the string to an integer, we can now add it to the integer b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b72df4af",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[20], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m dogs \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m15\u001b[39m \u001b[38;5;66;03m# an attempt to concatenate strings and integers, which we know wont work\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mthere are \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdogs\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m dogs at the dog park.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "dogs = 15 # an attempt to concatenate strings and integers, which we know wont work\n",
    "\"there are \" + dogs + \" dogs at the dog park.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d34bb1d1-fab4-4d2f-97c3-feba690f1cac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'there are 15 dogs at the dog park.'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dogs = 15 # we can convert the integer to a string before concatenating it, which will work\n",
    "\"there are \" + str(dogs) + \" dogs at the dog park.\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98b9ac47",
   "metadata": {},
   "source": [
    "The following are done in a file, instead of the prompt. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b5fb0712",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dogs = 5 # we can make programs that include multiple lines of code\n",
    "dogs # but the output will not automatically be displayed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d8f31719",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "dogs = 5\n",
    "print(dogs) # we can use the print function to display text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b08f82cf",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[24], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m dogs \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mThere are \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mdogs\u001b[49m \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m dogs.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "dogs = 5\n",
    "print(\"There are \" + dogs + \" dogs.\") # how do we print an integer along with strings?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8721299d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 5 dogs.\n"
     ]
    }
   ],
   "source": [
    "dogs = 5\n",
    "print(\"There are \" + str(dogs) + \" dogs.\") # we need to convert the integer to a string first, before concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e1dd9fee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter something: 6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# the input function can take input from the user's keyboard. They just need to type and the press enter. \n",
    "a = input(\"Enter something: \")\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "85b0d1c4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter something: 7\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "a = input(\"Enter something: \") \n",
    "print(type(a)) # the variable type given by the input function is a string, no matter the input from the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a6e6ea9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of dogs: 8\n",
      "Enter the number of cats: 7\n",
      "There are 87 animals.\n"
     ]
    }
   ],
   "source": [
    "dogs = input(\"Enter the number of dogs: \") # we can use input statements to make our programs more dynamic\n",
    "cats = input(\"Enter the number of cats: \")\n",
    "total = dogs + cats\n",
    "print(\"There are \" + total + \" animals.\") # why doesn't this work?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "a27bd9e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of dogs: 6\n",
      "Enter the number of cats: 7\n",
      "There are 13 animals.\n"
     ]
    }
   ],
   "source": [
    "dogs = input(\"Enter the number of dogs: \") \n",
    "cats = input(\"Enter the number of cats: \")\n",
    "total = int(dogs) + int(cats) # we need to convert strings to integers before using them in calculations\n",
    "print(\"There are \" + str(total) + \" animals.\") # we need to convert them back again to a string to display them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "487e90d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of dogs: 6\n",
      "Enter the number of cats: 7\n",
      "There are 13 animals.\n"
     ]
    }
   ],
   "source": [
    "dogs = input(\"Enter the number of dogs: \") \n",
    "cats = input(\"Enter the number of cats: \")\n",
    "total = int(dogs) + int(cats)\n",
    "print(\"There are\", total, \"animals.\") # using commas in print function will automatically convert to string and add spaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "60e28471",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My age is 49'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age = 49\n",
    "print(f\"My age is {age}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4f03d252",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The sum of 10 and -2 is 8\n"
     ]
    }
   ],
   "source": [
    "a, b = 10, -2 #assignment in one line\n",
    "print(f\"The sum of {a} and {b} is {a+b}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d0013ef6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions are another type of object in python, and we can make our own\n",
    "def my_function():\n",
    "    print(\"Hello there!\")\n",
    "    answer = 1 + 1\n",
    "    print(\"I like maths! 1 + 1 is \" + str(answer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0d79b5f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there!\n",
      "I like maths! 1 + 1 is 2\n"
     ]
    }
   ],
   "source": [
    "my_function() # when i 'call' the function, it will execute those instructions (done in the prompt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f44f8929",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello there!\n",
      "I like maths! 1 + 1 is 2\n",
      "Hello there!\n",
      "I like maths! 1 + 1 is 2\n",
      "Hello there!\n",
      "I like maths! 1 + 1 is 2\n"
     ]
    }
   ],
   "source": [
    "my_function()\n",
    "my_function()\n",
    "my_function() # as many times as I like"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9e636a9-23ec-4ccb-bd1a-90fb1037a125",
   "metadata": {},
   "source": [
    "A little program. Let's put it in a function, we'll dive into functions later:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1dc3a989-1f4b-4639-9187-3aeb56f7b6b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_little_program(): #functions are defined with def\n",
    "    x_str = input(\"Give me a number:\")\n",
    "    x = int(x_str)\n",
    "    y_str = input(\"Give me another number:\")\n",
    "    y = int(y_str)\n",
    "    result = x + y\n",
    "    print(\"The sum of\", x, \"and\", y, \"is\", result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "bf6136ac-ec7c-4c87-81d6-b872963c830f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Give me a number:6\n",
      "Give me another number:7\n",
      "The sum of 6 and 7 is 13\n"
     ]
    }
   ],
   "source": [
    "my_little_program()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f068d24-ba5e-4cd1-9cfe-364e140b6fa8",
   "metadata": {},
   "source": [
    "#### Task 1.1: Run `my_little_program`. Do this both in Jupyter and Spyder. Save the code for every task in a different file named `Task1_1.py`, `Task1_2.py`, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "508f9dca-f38d-48f1-a75b-bfdf5d521000",
   "metadata": {},
   "source": [
    "#### Task 1.2: Modify the program so that it outputs not only the sum, but also the difference(s), products, and (ratios). Try to format your output as nicely as possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "5687af4f-a730-42d9-8a52-7219b3f922dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 100\n",
    "y = 20\n",
    "z = y/x # not all numbers are integers\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e6fb8ba8-87b6-4a0e-87b5-ed6b44aa9920",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(z) #Float means \"floating point\" and is an approximation of a real number (not necessarily integer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "2cf45fd8-a0a1-4ca1-9cdd-d1db397da9f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 10\n",
    "b = 5\n",
    "c = a/b # we can start off with integers\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e8321e7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c) # and end up making a float. Even if that result is still -mathematically- an integer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "5a7db75a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'int'>\n",
      "<class 'str'>\n",
      "5.0 5 5\n"
     ]
    }
   ],
   "source": [
    "print(type(5.0))\n",
    "print(type(5))\n",
    "print(type(\"5\"))\n",
    "print(5.0, 5, \"5\") # we now have three ways of representing 5 using python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "523db1b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0 <class 'float'>\n",
      "5 <class 'int'>\n",
      "5.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 5.0\n",
    "b = int(a) # we can convert from floats to ints\n",
    "c = float(b) # and back again\n",
    "print(a, type(a))\n",
    "print(b, type(b))\n",
    "print(c, type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "a192c604",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.3 <class 'float'>\n",
      "5 <class 'int'>\n",
      "5.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 5.3\n",
    "b = int(a) # how does it convert floats that aren't 'integers' to ints?\n",
    "c = float(b) # does it round to the nearest integer? How do we check?\n",
    "print(a, type(a))\n",
    "print(b, type(b))\n",
    "print(c, type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "522fb48f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.8 <class 'float'>\n",
      "5 <class 'int'>\n",
      "5.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 5.8\n",
    "b = int(a) # It does not round to the nearest integer\n",
    "c = float(b) # It just removes all the values after the decimal.\n",
    "print(a, type(a))\n",
    "print(b, type(b))\n",
    "print(c, type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "9fb23c16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-5.8 <class 'float'>\n",
      "-5 <class 'int'>\n",
      "-5.0 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = -5.8\n",
    "b = int(a) # Does this mean it rounds down always?\n",
    "c = float(b) # Not for negative numbers!\n",
    "print(a, type(a))\n",
    "print(b, type(b))\n",
    "print(c, type(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c4e08156-705c-474c-8bfe-37b4be316943",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = 2e-1 #You can also use scientific notation\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "468aae15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.5*3 # mathematics with floats works well for the most part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "72e28423",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1*3 # but not always"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7747d0f-87ec-4024-8fec-ed0089b9cc6c",
   "metadata": {},
   "source": [
    "#### Other operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "f8953d8a-1467-48e2-84d0-b3c1a7fc1e24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**10 #power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "526c11d8-f73c-4faf-bf70-e2816f4a8181",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3\n",
    "b = 2\n",
    "a**b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "3002a8cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a^b # ^ is not power! it is something else. (bitwise exclusive or)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "7c2a877a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2+3)*4 # brackets and order of operations will work mostly how you expect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "f38a8dbf-4439-458a-bd82-cd2b026dd898",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 % 3 #modulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "45aeb6b5-6d0e-49aa-ae20-c5982b0b6e9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "aaf08c8d-9015-47af-aa89-e3c48150d1c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 % -3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "83d08022-1683-4ec7-948c-126377abc853",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 // 3 #whole division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "e354c2e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = False # booleans!\n",
    "b = True # must have a capital first letter!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "ea7dd055",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "34bf2493",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a and b # and operator. works the same way as in mathematics. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "30ca0bd2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a or b # or operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "9405e5dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not b # not operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "2d2756c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a and not b # we can group these expressions like you would expect, and order of operations still works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "71544db7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not a and b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "26229a8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " 3 > 2 # greater than operator, outputs a boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "f62f8ab6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 < 2 # less than operator, outputs a boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "b7f7a89c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 > 3 # this is STRICTLY greater than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "a2904a83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 >= 3 # greater than or equal to"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "37976d36",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2 == 3 # equal to (double equals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e479fc11",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "cannot assign to expression here. Maybe you meant '==' instead of '='? (4026733151.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[72], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    1 + 2 = 3 # this is different to single equals, which is for assignment, not comparing.\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to expression here. Maybe you meant '==' instead of '='?\n"
     ]
    }
   ],
   "source": [
    "1 + 2 = 3 # this is different to single equals, which is for assignment, not comparing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "d280b9f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.0 == 3 # it can compare floats and ints by their mathematical value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "ad7f088d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"3\" == 3 # but not strings and floats or ints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "79fecd79",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1*3 == 0.3 # must be careful when comparing floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "dc82ff8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and 3 # we can use these operators with more than just booleans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "57400918",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(3) # We can convert something to a boolean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "b7304582",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(-3) # if 3 is True, what numbers are False?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "6fe6c78f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0) # zero is False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "e115e07f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\"3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "e3806c27",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "b5a922aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'True'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "fbeb88dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "b30cc471",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "cd3dc0f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "f7848b55-14c5-4a13-8c29-8bbaa0ab6e01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 % -3 # modulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "4a70aa71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.3333333333333335"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 / -3 # normal division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "0d3881a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 // -3 # whole division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "171105d4-288e-49b9-acb8-63faed23f854",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-3*(10 // -3) + (10 % -3) # This is equal to 10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b872d04-4a46-49e9-a8de-05425e3dfc1c",
   "metadata": {},
   "source": [
    "#### Task 1.3: Write a program that uses input functions to ask for two integers, and then displays True if the above relation is True, and False if it is not. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8ba5532-7f08-4602-89bc-fc9cfbd8b725",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "e0f101cc-63e9-4be0-b0d7-269a13a0dd71",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_friends = [\"Sarat\", \"Benoit\", \"Masoud\"] # a list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "6d71437d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sarat', 'Benoit', 'Masoud']"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "050723c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(my_friends)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "f44d9319-c556-4e23-a2d0-823bcee112db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_friends)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "efa06b19-ec63-403a-bd49-ea0967c00f2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sarat'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_friends[0] # start indexing at 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "c2e797e0-97d1-4673-bbe3-b357ca741c25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Benoit'"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_friends[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "1ef781f9-8cfe-4453-a338-0d7d2d91338e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Masoud'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_friends[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "a69c0715-37ab-450a-b96b-bae3ce9981f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Masoud'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_friends[-1] # negative index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "691bf94f-e919-451c-bb0f-1f41a7c19f22",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[98], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mmy_friends\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "my_friends[3] # index must be within index range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "46eda07b",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_friends[1] = \"Nicholas\" # we can change the values in a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "1959155b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sarat', 'Nicholas', 'Masoud']"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_friends"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "5ca3ee0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am going to the park with my friend Nicholas.\n"
     ]
    }
   ],
   "source": [
    "print(\"I am going to the park with my friend \" + my_friends[1] + \".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "f0a1e27b-1401-4d53-ba1a-faa92ff3eb56",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_stuff = [49, \"Yoni\", my_friends, 108.2, [\"cat\", \"dog\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "6de178fe-9637-4661-826e-3bcdeeff451f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(my_stuff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "c837d400",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[49, 'Yoni', ['Sarat', 'Nicholas', 'Masoud'], 108.2, ['cat', 'dog']]\n"
     ]
    }
   ],
   "source": [
    "print(my_stuff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "a0270d96-fd96-400e-ba47-76e9a6162719",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "108.2"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_stuff[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "2081c85f-bd88-48c3-a1eb-9051e409035b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cat', 'dog']"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_stuff[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "269cf7e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cat'"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_stuff[4][0] # double indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "4c1ff0e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = [[0,1,2],[3,4,5],[6,7,8]] # like a 2d list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "0ec8c0a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "grid[1][2] # The first number is the 'row' and the second is the 'column'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "cc5dd5d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"abcdef\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "0f75d2ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'c'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2] # we can also use indexes with strings!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "441ba30a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 6, 7]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [3, 5]\n",
    "b = [6, 7]\n",
    "a+b # we can concatenate lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "9bef5673",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefabcdefabcdef'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s*3 # we can multiply strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "599ae078",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 7, 6, 7, 6, 7]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b*3 # we can multiply lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "1800936c",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'float'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[115], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43ms\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m3.0\u001b[39;49m\n",
      "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'float'"
     ]
    }
   ],
   "source": [
    "s*3.0 # but not by floats!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "7fb29562",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[116], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43ma\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mb\u001b[49m\n",
      "\u001b[1;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'list'"
     ]
    }
   ],
   "source": [
    "a*b # cannot multiply lists together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "738985a1",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[117], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m s[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "s[0] = \"x\" # we cannot change parts of a string, unlike lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "6ddfbf76",
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = (3,6,5) # tuples are another variable type, that is some sequence of things. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "9c0e5a6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(tup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "dfd70984",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 6, 5)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "31e857ee",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[121], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m tup[\u001b[38;5;241m0\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m4\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "tup[0] = 4 # also cannot change the values in a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "bd154f16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tup[2] + 10 # but can still access them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "f23df799",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [0,1,2,3,4,5,6,7,8]\n",
    "numbers + [9,10] # as mentioned, we can add lists together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "24b176d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 10, 0, 1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[9,10] + numbers # the order does matter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "035be0ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 5, 6, 7]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[4:8] # get only a portion of a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "ca11e0c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[1:7:2] # get every second item from the first to the seventh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "86e287be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[::2] # every second item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "f4adcd32",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"abcdefg\" # every second letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "dca9cac4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aceg'"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "ab8cf69a-6174-4d42-8223-b38a27bd9007",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_list = [x for x in range(5)] #A list comprehension\n",
    "new_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "73d2d512-aea5-4c29-a6a8-c20617f0f4e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "839be77f",
   "metadata": {},
   "outputs": [],
   "source": [
    "letters = [c for c in \"Hello!\"] # works with strings as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "4dbc43ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['H', 'e', 'l', 'l', 'o', '!']"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "e838a7ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = [x**2 for x in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "ecf138a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "aedbb370-a3f1-4870-bf94-b253d48493bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = [x**2 for x in range(10**4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "86cd1805",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "38b5a3c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "new_list = [x**2 for x in range(10**4)] # how big can we make a list before it starts taking too much time?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "6d913488",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1688369824.577442\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "t = time.time()\n",
    "print(t) # seconds since jan 1st 12:00am, 1970. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "f0fce308",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The list has a length of 1000000 and it took 0.2658498287200928 seconds.\n"
     ]
    }
   ],
   "source": [
    "import time # lets measure the time it takes to do this task\n",
    "\n",
    "start = time.time()\n",
    "new_list = [x**2 for x in range(10**6)]\n",
    "end = time.time()\n",
    "\n",
    "length = len(new_list)\n",
    "time_taken = end - start\n",
    "print(\"The list has a length of\", length, \"and it took\", time_taken, \"seconds.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "f5e13cc8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# which operations take the longest?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d671b420",
   "metadata": {},
   "source": [
    "#### Task 1.4 Something to do with lists!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "477e881e-9b34-472b-a339-62428c08beed",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import * #get mathematical functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "63933313-5b33-48e0-9ae2-5e25be58a147",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "95aac8f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(1.5*pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "51484c72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.718281828459045, 3.141592653589793)"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e, pi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b18b07d2-cc7b-4aee-b887-24e7e106afa8",
   "metadata": {},
   "source": [
    "#### Task 1.5: Write a program that gets a, b, and c, for the equation\n",
    "\n",
    "$$\n",
    "a x^2 + bx + c = 0\n",
    "$$\n",
    "\n",
    "and returns any real solutions using:\n",
    "$$\n",
    "x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aac8f8a4-a782-4aea-86bb-30a5712ae6d5",
   "metadata": {},
   "source": [
    "You might notice that if $b^2 - 4ac < 0$ then there are no real solutions. What if we wanted to print something just in such a case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "4d6dba96-c6a9-455d-8452-addbf0b871ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "disc = 12.3\n",
    "if disc < 0: #A conditional statement!!!\n",
    "    print(\"Negative!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "b4ea596b-e8af-4183-917a-0d3a34ab2643",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Negative!\n"
     ]
    }
   ],
   "source": [
    "disc = -12.3\n",
    "if disc < 0:\n",
    "    print(\"Negative!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "a4fd281d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Positive!\n"
     ]
    }
   ],
   "source": [
    "disc = 12.3\n",
    "if disc < 0:\n",
    "    print(\"Negative!\")\n",
    "else:\n",
    "    print(\"Positive!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "0f799765-ecbb-4905-9b21-5edbd5b47d51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "age = int(input())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "539f5d97-8173-4f1f-a080-0ce761a71415",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Child\n"
     ]
    }
   ],
   "source": [
    "if age < 10:\n",
    "    print(\"Child\")\n",
    "elif age < 20:\n",
    "    print(\"Teenager\")\n",
    "elif age < 30:\n",
    "    print(\"In 20's\")\n",
    "else:\n",
    "    print(\"Finally an adult!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d44161a-f539-4e1c-9f6c-f0d7f3214b4b",
   "metadata": {},
   "source": [
    "#### Task 1.6: Now use conditional statements to perfect your quadratic equation solving function. Detect against single root, no real roots, not quadratic."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1563d1a-11dc-46c5-84d7-fcb6266ce04d",
   "metadata": {},
   "source": [
    "<center>\n",
    "    <h1>\n",
    "        END OF DAY 1\n",
    "    </h1>\n",
    "</center>"
   ]
  }
 ],
 "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}