python_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basics\n",
    "\n",
    "## Lesson Goal\n",
    "This lesson is optional. If you already know how to write in Python go right ahead and skip it to the first real lesson. Here I'l l show you some really simple and basic concepts of Python, some of its peculiarities, and what does it  do as a programming language. I'll keep it brief, simple, and won't got into epth about any of the subjects.\n",
    "\n",
    "## Lesson Materials\n",
    "Make sure to have ```Python``` with the ```pip``` manager installed and we are good to go. If you need a refresher, there's a step-by-step tutorial for each system on the course [guide](/home/vmendes/Documentos/Coding Projects/python_math/README.md). I'd also suggest taking notes - either on notepad on your computer, Google, or with old-school pen and paper. Taking notes helps you memorizing and creating the neural paths linked to learning a new skill.\n",
    "\n",
    "## Extra Material\n",
    "If you want to learn more about Python in detail, I'd suggest Al Sweigart's book [Automating the Boring Stuff With Python](https://automatetheboringstuff.com/), you can read it for free online, under a Creative Commons license; the book also has an [Udemy](https://www.udemy.com/course/automate/) course which is dirt cheap. If I recall correctly, buying the book's second edition ebook, the Udemy course comes bundled together with it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What is Python, after all?\n",
    "Python is a interpreted, high-level, general-purpose, dynamically-typed, garbage-collected, multi-paradigmn, computer programming language. What's that? You didn't get all that tech mumbo-jumbo? Great, because I didn't as well when I started learning. So, to begin, let's explain Python as simply as we can:\n",
    "\n",
    "Python is a programming language made to be simple and to be used in any manner of applications possible - data science, backend programmin, frontend programming, creating web applications, you name it. Of course, it performs better in some areas than others - particularly, it's great at data science and data anlysis, and not so great at frontend development.\n",
    "\n",
    "Another great feature of Python is its *garbage collector*. To put it simply, it means that we don't have to worry about memory allocation, the language *interpreter* does this for us. What is an interpreter, by the way? Again, simplifying here: imagine that the interface between you and you computer is the language you're writing instructions - Python, C, Java, Ruby, etc - these can beinterpreted or compiled. Compiled languages read all the instructions at once and send them to the computer to execute; this is advantageous in terms of speed and memory saving, and can be a problem when debugging. In the other hand, compiled languages give the computer instructions piece by piece, as you instruct it. The pros are the ease of debugging and auto memory management; however, interpreted languages' code can sometimes suffer with execution problems and they consume much more memory than a compiler. This [video](https://www.youtube.com/watch?v=e4ax90XmUBc) does a better job at explaining that than I do - check it out if you want a better, more detailed explanation.\n",
    "\n",
    "Finally, the *multi-paradigm* part. Briefly, there are three schools of thought when programing:\n",
    "    \n",
    "* Procedural Porgramming - you program line by line as you go, also called imperative programming\n",
    "* Functional Programming - you create programs based on functions, and function modules, and execute them withing said functions, sometimes recursively.\n",
    "* Object Oriented Programming - you create classes of objects and program using their intereaction; objects are programatic abstractions of real life concepts and objects.\n",
    "\n",
    "Python can handle well any of those three paradigms. We will probably be doing predominantly procedural and functional, but we may dip our toes into OOP, I won't making any promises.\n",
    "\n",
    "For short, Python is a *jack of all trades* language. It excels in external package support and that's why it's so versatile. Want to plot a graph but it's too hard to do that natively with Python? No worries - we install ```matplotlib``` using ```pip``` and ```import``` the package through this very same command. Easy as that.\n",
    "\n",
    "Without further ado, let's learn that in practice:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Jupyter Notebook commands:\n",
    "\n",
    "Jupyter works by executing pieces of code as cells. Here's how you can interact with them:\n",
    "* Mouse over to highlight and left click to select a cell\n",
    "* ENTER you can start writing on the cell; ESC you exit the cell\n",
    "* \"b\" to create a new cell below\n",
    "* \"a\" to create a new cell above\n",
    "* \"dd\" (very quickly) to delete a cell\n",
    "* SHIFT + ENTER to run a cell\n",
    "* ALT + ENTER to run a cell and create a cell below\n",
    "* CRTL + z: undo ; CTRL + SHIFT + z: redo\n",
    "* While highlighting a cell, you can press \"m\" to change it to *markdown* type, press \"y\" to change it to *code* mode.\n",
    "\n",
    "These are the most important ones; I forget these commandas often enough that I keep a cheatsheet handy. Here's [one](https://towardsdatascience.com/jypyter-notebook-shortcuts-bf0101a98330) for you to use, just in case.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerical Expressions\n",
    "\n",
    "You can basically write down any numerical expressions directly. Python executes lines left to write, and top to bottom, line-be-line.\n",
    "The operator symbols are:\n",
    "\n",
    "* ```+``` $\\rightarrow$ sum\n",
    "* ```-``` $\\rightarrow$ subtraction\n",
    "* ```*``` $\\rightarrow$ multiplication\n",
    "* ```/``` $\\rightarrow$ total division\n",
    "* ```//``` $\\rightarrow$ floor division\n",
    "* ```%``` $\\rightarrow$ modulus division\n",
    "* ```**``` $\\rightarrow$ for exponentials\n",
    "Let's see an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2498"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 4 * 5 ** 4 - (8 - 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 + 2 - 6 * 4 / 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, Python follows a **PEMDAS** order of operations:\n",
    "\n",
    "- P – Parentheses\n",
    "- E – Exponentiation\n",
    "- M – Multiplication\n",
    "- D – Division\n",
    "- A – Addition\n",
    "- S – Subtraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python alo suses logical operators, such as:\n",
    "\n",
    "-  ```>``` $\\rightarrow$ Greater than\n",
    "-  ```>=``` $\\rightarrow$ Greater or equal to \n",
    "-  ```<``` $\\rightarrow$ Less than \n",
    "-  ```<=``` $\\rightarrow$ Less or equal to \n",
    "-  ```==``` $\\rightarrow$ Equal to \n",
    "-  ```!= ``` $\\rightarrow$ Not equal to"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instead of returning a number, they return a ```bool``` (from boolean) value - these can be ```True``` or ```False```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(4 > 5)\n",
    "print(5 < 7)\n",
    "print(8 == 0)\n",
    "print(3 != 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you saw it, whenever we want to show more than one result in the Jpuyter cell, we nee to put it into the ```print()``` function. This is the most common function in Python, and it prints a ```string``` that you pass as argument. More on that later."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nStart with three simple quotation marks, write whatever you want and then close with another triple quotation marks.\\nThese are useul for long observations and to describe functions and classes. We probably won't use these so much, but it's good to know.\\n\""
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This is a comment, start it by puttin a # at the beginning\n",
    "# Add this whevener you need to explain something or add an observation into your code\n",
    "# Nothing after the # will be read as code\n",
    "# If you need to write a bigger comment, use the docstring type of comment as follows:\n",
    "\n",
    "'''\n",
    "Start with three simple quotation marks, write whatever you want and then close with another triple quotation marks.\n",
    "These are useul for long observations and to describe functions and classes. We probably won't use these so much, but it's good to know.\n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "The symbol ```==```, written that way, with double marks, represents equality between things. However, we only use it as a logical operator. The symbol ```=``` is used to declare **variables**. Variables are a little bit different than in math - we are not solving for x here, not yet at least; think abouyt variables in Python (and in basically any other computer language) as small boxes where you store something: a value, a function, a data structure, anything that a programming language supports. Think about putting stuff into boxes and labling said boxes with names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "    <img src=\"project_images/boxes.png\" style=\"width:60%%\"/>\n",
    "    <figcaption>Visualizing how variables work in progamming languages</figcaption>\n",
    "</figure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As said before, you can store anything you want and that a language supports in a variable. Python has the following kinds of **Data Types**:\n",
    "\n",
    "- Text type:\n",
    "    - ```str```\n",
    "\n",
    "- Numeric type:\n",
    "    - ```int``` for interger numbers\n",
    "    - ```float``` for real numbers\n",
    "    - ```complex``` for complex numbers\n",
    "\n",
    "- Boolean type:\n",
    "    - ```bool``` for ```True``` or ```False``` values\n",
    "\n",
    "- Sequence types:\n",
    "    - ```list``` for lists\n",
    "    - ```tuple``` for tuples\n",
    "\n",
    "- Mapping type\n",
    "    -```dict``` for dictionaries\n",
    "\n",
    "We won't be touching on dictionaries for now and there's a spacial data type called an *array* that we will see when dealing with the ```numpy```library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's see some examples of variable operations:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create some variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 5\n",
    "c = 3.14\n",
    "d = 4 + 2j\n",
    "e = True\n",
    "f = 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can change the value of a varible by simplying equating it to anothe value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or equating it to another variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "99"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = f\n",
    "\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also perate directly between variables, since they're just representations of the values we stored in memory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "104\n",
      "1.0\n",
      "9801\n"
     ]
    }
   ],
   "source": [
    "print(a * b)\n",
    "print(c + b)\n",
    "print(a / a)\n",
    "print(f ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the ```type()``` function, we can check that variable's type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important feature is that we can operate with ```str``` type variables. We can do ```+``` and ```*```. To create a string, you can put any characters between simple ```'``` or double ```\"``` quotes, even numbers, but they won't be ```int``` or ```float``` types - you can think as a number in a ```str``` format as yourself writing the name \"five\" instead of the value of 5. Let's see some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "spam = 'ham'\n",
    "bacon = 'eggs'\n",
    "toast = 'beans'\n",
    "ni = '5'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hameggs'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam + bacon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'55555'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ni * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'beansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeansbeans'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "toast * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hamhamhamhamhameggs'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spam * b + bacon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mixing two different data types, such as ```str``` and ```float``` types raises an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/home/vmendes/Documentos/Coding Projects/python_math/python_basics.ipynb Cell 33'\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/vmendes/Documentos/Coding%20Projects/python_math/python_basics.ipynb#ch0000037?line=0'>1</a>\u001b[0m spam \u001b[39m+\u001b[39;49m \u001b[39m4\u001b[39;49m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "spam + 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same thing if you forget to close the ```str``` - in this case, it's a syntax error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unterminated string literal (detected at line 1) (1555805337.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Input \u001b[0;32mIn [30]\u001b[0;36m\u001b[0m\n\u001b[0;31m    foo = 'bar\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unterminated string literal (detected at line 1)\n"
     ]
    }
   ],
   "source": [
    "foo = 'bar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don't worry about mistakes - the interpreter returns what kind of mistake you made and where it's located. For ```Python 3.10```, it even suggests what kind of mistakes you probably made and corrections. Mistakers are a part of learning - if you're not making any mistakes, you're either a genious or a clairvoyant.\n",
    "Jokes aside, you **WILL** make an oopsie here and there while programming, but don't worry, even senior software engineers make them on a daily basis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists, Tuples, Dictionaries, and Arrays\n",
    "\n",
    "These three data types are what we call *collections* of data, because they can store more than one element, or variables. Here are their charcteristics:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "##### Lists\n",
    "\n",
    "A list is an *ordered* and *changeable* collection of elements. It can recieve any type of element, from a ```float``` to a ```bool```, and even another list. It's *ordered* because every element has an index, starting from the number 0 for the first element, and *changeable* because you can add, remove, append, and slice the list as much as you want. For now, it's useful to know that they exist and how to create a list. They'll be important later on when dealing with vectors and matrices for linear algebra, and we may go more in depth and do a refresher about lists then."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initializing a list\n",
    "my_first_list = [1, 2, 3.14, 4.20, 'five', a, ['a', 'b', 'c']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting the first element. Keep in mind, it starts at 0\n",
    "my_first_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'five'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_first_list[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Accessing an element of a list inside our list. Neat, huh?\n",
    "my_first_list[6][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Slicing the string to just get some elements. \n",
    "my_first_list[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3.14, 4.2, 'five', 10, ['a', 'b', 'c'], 'mozarella']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Adding an element to a list with the .append() method\n",
    "# Whenever you use this method you put the element at the end of the list\n",
    "pizza = 'mozarella'\n",
    "my_first_list.append(pizza)\n",
    "\n",
    "my_first_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Look closely, you'll see that the third element of the list does not go to the solution. This is a quirk of the syntax - [0:2] means \"go from the first element up to the second\"; so remember this when slicing lists or any other sliceable element in Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Tuples\n",
    "\n",
    "Tuples are exactly like lists but they aren't *changeable*, in other words, they are an *immutable* element. They exist because their memory allocation is more efficient than lists, so if you need to read a fized size set of elements, it's better to choose tuples. Otherwise, they function basically the same as lists. Oh, to differentiate the two, instad of using square brackets [] as we use on lists, we use parenthesis () for tuples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initializing a tuple\n",
    "my_first_tuple = (1, 2, 3.14, 4.20, 'five', a, ['a', 'b', 'c'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting the first element. Again it starts at 0\n",
    "my_first_tuple[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Same neat thing we did on lists\n",
    "my_first_list[6][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can slice tuples, as long as we don't change them\n",
    "my_first_tuple[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m/home/vmendes/Documentos/Coding Projects/python_math/python_basics.ipynb Cell 53'\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/vmendes/Documentos/Coding%20Projects/python_math/python_basics.ipynb#ch0000059?line=0'>1</a>\u001b[0m \u001b[39m# If we try to change our tuple, we get an error, since it's an immutable element\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/vmendes/Documentos/Coding%20Projects/python_math/python_basics.ipynb#ch0000059?line=2'>3</a>\u001b[0m pizza \u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39mmozarella\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/vmendes/Documentos/Coding%20Projects/python_math/python_basics.ipynb#ch0000059?line=3'>4</a>\u001b[0m my_first_tuple\u001b[39m.\u001b[39;49mappend(pizza)\n\u001b[1;32m      <a href='vscode-notebook-cell:/home/vmendes/Documentos/Coding%20Projects/python_math/python_basics.ipynb#ch0000059?line=5'>6</a>\u001b[0m my_first_tuple\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "# If we try to change our tuple, we get an error, since it's an immutable element\n",
    "\n",
    "pizza = 'mozarella'\n",
    "my_first_tuple.append(pizza)\n",
    "\n",
    "my_first_tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Dictionaries\n",
    "\n",
    "Dictionaries are a data container that is *unordered* and *mutable* that stores mappings of unique keys to values. Just like a (shocker) dictionary IRL. They are an easy solution to store and access data rather easily, if compared to other structures. I'm not sure if we'll see dictionaries along the course studies, but, as always, it's good to know what are them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a dictionary\n",
    "student_info = {\n",
    "    \"ID\": 118922, \n",
    "    \"Name\": \"Xerxes\", \n",
    "    \"DOB\": 1993, \n",
    "    \"Institute\": \"Geosciences Institute\", \n",
    "    \"Favorite Food\": \"Fried Chicken\"\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "118922\n",
      "Xerxes\n"
     ]
    }
   ],
   "source": [
    "# Accessing data\n",
    "print(merriam_webster[\"ID\"])\n",
    "print(student_info[\"Name\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'new_value'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Adding data to the dictionary\n",
    "student_info[\"New_key\"] = \"new_value\"\n",
    "student_info[\"New_key\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Easy right?\n",
    "There's really nothing more to it now, if we happen to need anything more regarding dicitonaries, we'll do a refresher before. But, as you can see, dictionaries are like the \"embryo\" of working with data in Python, all steming from the implications that you can use dictionaries as the value of a key-value pair."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Arrays\n",
    "\n",
    "Arrays are similar to lists but they usually only recieve numbers and numbers only. They work like vectors in data analysis, and we can't really make an array with the built-in Python functions. We have to import the ```numpy``` library, and use its functions to create them. So, we'll kill to birds with one stone (sorry birds): we'll see how to import<sup>1</sup> packages and how to create an array:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Importing the package and giving it an alias\n",
    "# An alias is important as to not write the name of tha package every time as you write its functions\n",
    "import numpy as np\n",
    "\n",
    "a1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])\n",
    "\n",
    "a1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can do the same things as we did before (operations, slicing, etc):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 0.5       , 0.33333333, 0.25      , 0.2       ,\n",
       "       0.16666667, 0.14285714, 0.125     , 0.11111111, 0.1       ])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/a1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting\n",
    "\n",
    "Finally, we'll just step a little into plotting graphs - something we inveitably and certainly will do along the math and science lessons.\n",
    "In my experience, I like to plot with an external library - especialy ```matplotlib```. I really don't remember, neither do I think there is, a built-in Python plotting library. It doesn't matter, really, because matplotlib covers basically everything possible that we can do, so, that's great.\n",
    "Let's see some plotting examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Creating the variables\n",
    "x = np.linspace(0, 1, 100) # I'm basically creating a pseudorandom array of numbers going from 0 to 1 in 100 steps\n",
    "y = x ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Exponential curve f(x²)')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAoPklEQVR4nO3deXhU9b3H8feXbKwhQNh3ZEdBJCKuxe2KW7VWve7FBcStrV20tbX11mvVWmtr1SIqIiKidYN6VdRatS4IYSesIQqEQAhbCEsSknzvHzP2GWOAAXIymczn9TzzmDPnnJnvz4TzOef3O4u5OyIikrgaxboAERGJLQWBiEiCUxCIiCQ4BYGISIJTEIiIJDgFgYhIglMQiByAme00s15RLNfDzNzMkuuirtpiZv9rZpvNbGPEe5+a2dBD/Lw/mdm42qtQgqYgkMNiZl+Z2Z7wxvLr12OxrutQmdmHZnZD5Hvu3tzd82JVU5DMrCvwU2Cgu3cIv3c+UOLu86NYf5KZvWZmn5hZn/DbDwG/MrPUwAqXWqUgkNpwfnhj+fXr1lgX1FBZSG3+u+0ObHH3TRHvjQOej3L9a939ImAGMArA3TcAy4Hv1mKdEiAFgQTGzP5mZq9ETD9oZv8Mb8xGmlm+md0V7pb4ysyujFi2pZlNNrMiM1tjZr/+egNoZqPDe6B/NLNtZvalmZ1dbd1nzGyDma0Pd30kHWhdM7sPOBl4LPLIJtzd0zv887lmNt/MdpjZOjO75yD+f3QN7z0XmdmWiM+/x8ymRCz3jS6m8FHKfWb2KbAbuMvMsqt99u1mNiP8c1q4fWvNrNDMxptZkxrqOQN4D+gUbu+k8F78acBHEcu9ZWYPR0y/ZGYTAdzdzawHcC4wOeLjPwy/J/HA3fXS65BfwFfAGfuY1xRYCYwmtIHdDHQJzxsJVAB/AtKA7wC7gH7h+ZOB6UALoEf4c64PzxsN7AXGAEnATUABYOH5bwBPAs2AdsBs4MYo1/0QuKFaOxzoHVH3UYR2ogYDhcCF4Xk9wssm1/D/IglYCDwSrqsxcFJ43j3AlIhlv/E54ZrWAoOAZKAlUAL0iVhnDnBZ+Oc/E9pDbx3+//cP4P59/I5GAvkR04OAXdWW6QBsIhQQVwJ5QIvwvH7AO0DXautcBMyL9d+nXlH+O451AXrF94tQEOwEtke8xkTMHw5sBdYAl0e8P5JQEDSLeO9l4O7wRrOMUL/11/NuBD4M/zwayI2Y1zS84ewAtA+v2yRi/uXAvw60bnj6Q/YTBDW0/8/AI+Gf9xcExwNF+5gXTRD8rto6U4DfhH/uEw6GpoARCtQjqn33l/uov3oQnAhsrGG5i4B1hML8pIj384FPgTeBH0S8fyaQF+u/T72ie8XV2Q1Sb13o7u/XNMPdZ5tZHqE985erzd7m7rsiptcAnYBMIDU8HTmvc8T0f85wcffdZgbQnNBecAqwIfwehPbe10Wx7gGZ2XHAA8CR4RrTgL9HsWpXYI27V0TzPTVYV216KvAw8DvgCuCNcFvaEQqEuRHtN0LhGo1thI4iqnsTeAxY4e6ffP2mu3fZx+e0ILRTIHFAYwQSKDO7hdDGsgC4o9rsVmbWLGK6W3i5zYS6b7pXm7c+iq9cR+iIINPdM8KvdHcfFGXJB7od71RC3S5d3b0lMJ7Qhjaaurrt49TSXYQ23l/rEEVd7wKZZnY0oSOeqeH3NwN7gEER7W/p7lEFHbCK0Jh052rv3wcsAzqa2eVRfM4AQl1hEgcUBBIYM+sL/C9wFXA1cEd4wxXpf8ws1cxOBs4D/u7ulYSOHu4zsxZm1h34CaHukP3y0Bkr7wIPm1m6mTUysyPM7DtRll0I7O+agRbAVncvNbPhhPbGozEb2AA8YGbNzKyxmZ0YnrcAOMXMuplZS+CXB/qw8JHFK4RO1WxNaNAXd68CngIeCR8dYGadzeysaIp0973A+4TGbAivfwpwLXBN+PXXGoKiuu8Ab0fznRJ7CgKpDf+wb15H8Hp4z3cK8KC7L3T3VcBdwPNmlhZebyOhrogC4AVgnLsvD8+7jdCech7wCaE93olR1nMNoW6bpeHPfwXoGOW6fwEuDp9R9GgN828GfmdmJcBv+HZ3V43C4XY+0JvQwG8+8N/hee8BLwGLgLmEumGiMRU4g1B4RnY53QnkArPMbAehDXu/KD8TQgPtVwOYWTqhgftb3X19uFvoGeBZi+h7imRmHYGBhAbtJQ58faaESJ0ys5GEBkj31ccsMWRmnwC3eRQXldWw7sPAand/ovYrkyBosFhEvsXdTzqMdX9am7VI8NQ1JCKS4NQ1JCKS4HREICKS4OJujCAzM9N79OgR6zJEROLK3LlzN7t725rmxV0Q9OjRg+zs7AMvKCIi/2Fma/Y1T11DIiIJTkEgIpLgFAQiIglOQSAikuAUBCIiCS6wIDCziWa2ycyW7GO+mdmjZpZrZovM7JigahERkX0L8ohgEuGHWe/D2YSerNQHGAv8LcBaRERkHwILAnf/mNAjCvflAmCyh8wCMsK3rxURkWr+8v4qcgqKA/nsWF5Q1plvPn4vP/zehuoLmtlYQkcNdOvWrU6KExGpL16Zm88j76+kvLKSQZ1a1vrnx3KwuKaHWtR4Bzx3n+DuWe6e1bZtjVdIi4g0SEsLdvCr1xdzfK823H5G30C+I5ZBkE/ogd5f60LoSVUiIgLsKN3LzS/MJaNpCo9ePpTkpGA22bEMghnANeGzh0YAxeHnzYqIJDx352cvLyR/2x4ev+IY2rZIO/BKhyiwMQIzexEYCWSaWT7wWyAFwN3HA28B5xB6tupuQg/HFhERYPxHeby7tJC7zxtIVo/WgX5XYEHg7pcfYL4DtwT1/SIi8erT3M08NHM55w3uyHUn9gj8+3RlsYhIPbJ++x5ue3E+vds158HvD8aspvNqapeCQESkniirqOTmKXMpr6hi/FXDaJZWN2f4x92DaUREGqp7ZuSwML+Y8VcNo1fb5nX2vToiEBGpB16cvZYXZ6/jllOPYNSRHer0uxUEIiIxtmDddn47PYeT+2TykzP71fn3KwhERGJo884ybpoyl3bpaTx62VCSGgU/OFydxghERGJkb2UVN78wj227y3ll3Am0apYakzoUBCIiMXLf/y1j9pdb+ctlR3Nk59q/mVy01DUkIhIDr87NZ9JnX3H9ST254OjOMa1FQSAiUscW5xdz1+uLGdGrNb88u3+sy1EQiIjUpaKSMsY+n01m8zQev+KYwO4oejA0RiAiUkfKK6q4JWJwuE3z4O4oejAUBCIideTeN5cy+6vYDw5XF/tjEhGRBDBt9lqen7WGG0/pFfPB4eoUBCIiAZvz1Vbunr6EU/q25Y5RsR8crk5BICISoPXb93DTlLl0adWUv8boyuED0RiBiEhA9pRXMnZyNmV7q5g2NouWTVNiXVKNFAQiIgFwd37+ykKWbtjB09dk0btd3d1W+mCpa0hEJACPfZDLm4s2cMdZ/Tl9QPtYl7NfCgIRkVr2zpKNPPzeSr43tDPjvtMr1uUckIJARKQWLduwg5+8vIAhXTO4/6Kj6uSZw4dLQSAiUks27yzjhueyadE4mQlXD6NxSlKsS4qKBotFRGpBWUUl456fy5ZdZbx84/G0T28c65KipiAQETlM7s5dry0he802HrtiKIO7ZMS6pIOiriERkcP05Md5vDovnx+f0YfzBneKdTkHTUEgInIYZuZs5MF3lnPu4I786PQ+sS7nkCgIREQO0ZL1xfx42gIGd8ng4UuGxMUZQjVREIiIHILCHaXc8Fw2rZqm8NQ18XOGUE00WCwicpB2l1cwZnI2O0r38sq4E2jXIn7OEKqJjghERA5CVZVz+0sLWLK+mEcvG8rATumxLumwKQhERA7CgzOXMzOnkF+dO5AzBtbvewhFK9AgMLNRZrbCzHLN7Bc1zG9pZv8ws4VmlmNm1wZZj4jI4Zg2ey1PfpTHVSO6cd2JPWJdTq0JLAjMLAl4HDgbGAhcbmYDqy12C7DU3YcAI4GHzSw1qJpERA7Vv1cV8as3lnByn0zuOX9Q3J4hVJMgjwiGA7nunufu5cA04IJqyzjQwkL/R5sDW4GKAGsSETloKzaWcPOUefRp15wnrjyG5KSG1aseZGs6A+sipvPD70V6DBgAFACLgR+5e1X1DzKzsWaWbWbZRUVFQdUrIvItm0pKuW7SHBqnJvHM6GNp0bh+PmXscAQZBDUdN3m16bOABUAn4GjgMTP71hC8u09w9yx3z2rbtm1t1ykiUqPd5RXc8Fw2W3eVM/EHx9I5o0msSwpEkEGQD3SNmO5CaM8/0rXAax6SC3wJ9A+wJhGRqFRWOT98cT5L1hfz18uHclSXlrEuKTBBBsEcoI+Z9QwPAF8GzKi2zFrgdAAzaw/0A/ICrElE5IDcnf/5Rw7vL9vEPd8d1GBOE92XwK4sdvcKM7sVmAkkARPdPcfMxoXnjwfuBSaZ2WJCXUl3uvvmoGoSEYnG0//+ksmfr2HMyT255vgesS4ncIHeYsLd3wLeqvbe+IifC4D/CrIGEZGD8eaiAu57axnnHNWBX549INbl1ImGdQ6UiMhh+CJvCz95aSHH9mjFny49mkaNGs61AvujIBARAXI3lTBmcjZdWjfhqWuy4vpuogdLQSAiCW/TjlJ+MHEOqclJPHftcDKaJtYNDhQEIpLQSkr3MvrZOWzbXc6zo4+la+umsS6pzikIRCRhlVdUcdOUeawsLOGJK49p0NcK7I8eTCMiCamqyrnz1UV8kruZP14yhJH92sW6pJjREYGIJKQH3lnO6/PX87P/6svFw7rEupyYUhCISMJ56uM8JnycxzXHd+eWU3vHupyYUxCISEJ5fX7+fy4Y+20De67AoVIQiEjC+HDFJn7+90WM6NWaP116NEkJcsHYgSgIRCQhzF+7jZumzKNv+xZMSLALxg5EQSAiDV7uphKunTSHti3SmHTdsaQ3wIfLHA4FgYg0aAXb93DNM7NJbtSI568fTrsWjWNdUr2jIBCRBmvrrnKufuYLSkoreO66Y+neplmsS6qXdEGZiDRIO8sqGP3sbPK37eH5649jUKfEvGo4GgoCEWlwyioqGTs5m5yCHUy4ehjDe7aOdUn1mrqGRKRBqais4rap8/ls9RYeungwpw9o2I+ZrA0KAhFpMKqqnDteXcS7Swu55/yBXHRMYt86IloKAhFpENyd3725lNfmrecnZ/Zl9Ik9Y11S3FAQiEiD8Mh7K5n02Vdcf1JPbjtN9w86GAoCEYl7T360mkc/yOXSrC78+twBun/QQVIQiEhcmzJrDfe/vZzzBnfk/osGKwQOgYJAROLW6/PzuXv6Ek7v345H/ls3kTtUCgIRiUtvLd7AT19eyPG92vD4lceQkqTN2aHS/zkRiTsfLC/khy/OZ2i3VjylO4keNgWBiMSVT3M3M27KPAZ0TOfZa4+lWZpukHC4FAQiEje+yNvC9c/NoWebZky+brhuJ11LFAQiEhfmrtnGdZPm0DmjCS+MOY5WzVJjXVKDoSAQkXpvcX4xoyfOpm2LNKaOGUFm87RYl9SgKAhEpF5bsr6Yq575gpZNU5g6ZgTt0/VgmdoWaBCY2SgzW2FmuWb2i30sM9LMFphZjpl9FGQ9IhJflhbs4KpnvqB5WjIvjhlBp4wmsS6pQQpsuN3MkoDHgTOBfGCOmc1w96URy2QATwCj3H2tmbULqh4RiS8rNpZw1TNf0CQlialjjqNr66axLqnBCvKIYDiQ6+557l4OTAMuqLbMFcBr7r4WwN03BViPiMSJlYUlXPHULFKSjKljRugRkwELMgg6A+sipvPD70XqC7Qysw/NbK6ZXVPTB5nZWDPLNrPsoqKigMoVkfpgVTgEkhoZL44ZQc9MhUDQggyCmm764dWmk4FhwLnAWcDdZtb3Wyu5T3D3LHfPatu2be1XKiL1wqrCEi5/ahaNzHhx7Ah6tW0e65ISQpCX5OUDXSOmuwAFNSyz2d13AbvM7GNgCLAywLpEpB76ujvIwiFwhEKgzgR5RDAH6GNmPc0sFbgMmFFtmenAyWaWbGZNgeOAZQHWJCL10PKNO7h8QuhIYJpCoM4FdkTg7hVmdiswE0gCJrp7jpmNC88f7+7LzOwdYBFQBTzt7kuCqklE6p9lG3Zw5dNfkJIUGhNQd1DdM/fq3fb1W1ZWlmdnZ8e6DBGpBV9fLNY4OYkXx2pgOEhmNtfds2qapyuLRSQmFq7bzhVPzaJZajIv3agQiCXdv1VE6tzcNdsYPXE2LZum8OKYEbpYLMYUBCJSp2blbeH6SXPIbJGm20bUE+oaEpE68/HKIkY/O5sOLRvz8o3HKwTqCR0RiEid+OeyQm6aMo9ebZsx5YbjdCvpekRBICKBe3NRAT+etoABHdN5/vrhZDTVQ2XqE3UNiUigXs5eF37QfAYvjDlOIVAP6YhARALz3Gdf8dsZOZzcJ5Mnrx5G01Rtcuoj/VZEpNa5O098uJqHZq7gzIHt+evlQ2mckhTrsmQfFAQiUqvcnQfeWc6TH+Vx4dGdeOiSIaQkqRe6PlMQiEitqaxy7p6+hKlfrOWqEd343XePpFGjmu5IL/WJgkBEakV5RRW3v7yA/1u0gZtGHsEdZ/XDTCEQDxQEInLYdpdXcOPzc/n3qs3cdU5/xp5yRKxLkoNwwI47M7vVzFrVRTEiEn+27y7nyqe/4NPczfzh4sEKgTgUzQhOB2COmb1sZqNMx3oiEraheA+XjP+cnIIdPHHlMC7N6nrglaTeOWAQuPuvgT7AM8BoYJWZ/d7MFPsiCSx3Uwnff+IzNhaX8ty1wxl1ZIdYlySHKKpzujz09JqN4VcF0Ap4xcz+EGBtIlJPzVu7jUvGf055pTPtxhEcf0SbWJckh+GAg8Vm9kPgB8Bm4Gng5+6+18waAauAO4ItUUTqkw+WF3LzC/Non96YydcNp3sbPVAm3kVz1lAmcJG7r4l8092rzOy8YMoSkfro5Tnr+OXrixnYMZ2Jo4+lbQvdQbQhOGAQuPtv9jNvWe2WIyL1kbvz2Ae5PPzeSk7uk8nfrhpG8zSdfd5Q6DcpIvtVUVnF3dNzeHH2Wr43tDMPfn8wqcm6ZURDoiAQkX3aXV7BbVPn88/lm7h55BH8XFcLN0gKAhGp0aaSUm54Lpsl64u598IjuXpE91iXJAFREIjIt+RuKmH0s3PYsrOcCVdnccbA9rEuSQKkIBCRb5iVt4Ubn59LSlIjXrpxBIO7ZMS6JAmYgkBE/uO1efnc+eoiurVuyqRrh9O1ddNYlyR1QEEgIrg7j7y/ikf/uYoTjmjD364cRsumKbEuS+qIgkAkwZXureTOVxcxfUEBlwzrwn3fO0qnhyYYBYFIAtu8s4wbn5/L3DXb+PlZ/bh55BE6PTQBKQhEEtTKwhKumzSHzTvLeOLKYzjnqI6xLkliREEgkoD+tXwTt704nyapSbw09niGdM2IdUkSQ4F2BIYfZLPCzHLN7Bf7We5YM6s0s4uDrEck0bk7T/87j+ufm0P3Nk2ZceuJCgEJ7ojAzJKAx4EzgXxCTzmb4e5La1juQWBmULWICJRVVHL3G0t4OTufs4/swMOXDqFpqjoFJNiuoeFArrvnAZjZNOACYGm15W4DXgWODbAWkYRWVFLGuCmhQeHbTuvN7Wf0pVEjDQpLSJBB0BlYFzGdDxwXuYCZdQa+B5zGfoLAzMYCYwG6detW64WKNGRL1hczZnI223aX89gVQzlvcKdYlyT1TJBjBDXtbni16T8Dd7p75f4+yN0nuHuWu2e1bdu2tuoTafCmL1jPxeM/w4BXxp2gEJAaBXlEkA90jZjuAhRUWyYLmBY+bzkTOMfMKtz9jQDrEmnwKqucP7yznCc/zmN4j9Y8fuUxepqY7FOQQTAH6GNmPYH1wGXAFZELuHvPr382s0nAmwoBkcOzfXc5P5y2gI9XFnH1iO7cfd5AXSks+xVYELh7hZndSuhsoCRgorvnmNm48PzxQX23SKJaWrCDG6dkU1hcxv0XHcXlwzWmJgcW6Llj7v4W8Fa192oMAHcfHWQtIg3d9AXrufPVRWQ0SeWlG0cwtFurWJckcUInEYvEufKKKn7/1jImffaVxgPkkCgIROJY4Y5SbnlhHtlrtnH9ST35xdn9SUnSeIAcHAWBSJz6fPUWbntxPrvLK3R9gBwWBYFInKmqcsZ/vJo/zlxBz8xmTB1zHH3bt4h1WRLHFAQicWT77nJ+9veFvL9sE+cN7sgD3x9M8zT9M5bDo78gkTgxf+02bp06n00lpdxz/kB+cEIPPURGaoWCQKSec3cmfvoVD7y9jPbpjXll3Am6dbTUKgWBSD22fXc5P39lEe8tLeTMge3548VD9FB5qXUKApF6au6ardw2dT5FO8v4zXkDufZEdQVJMBQEIvVMZZUz/qPV/Om9lXTOaMKrN53A4C4ZsS5LGjAFgUg9UrijlNtfWsBnq7dw3uCO/P6io0hvrK4gCZaCQKSeeH9pIXe8uog95ZX84fuDuSSri7qCpE4oCERibE95Jfe9tZQps9YyoGM6f738aHq30wViUncUBCIxtLRgBz+aNp9Vm3Yy5uSe/OysfqQlJ8W6LEkwCgKRGKiqcp76dx5/fHcFrZqm8vz1wzm5jx7DKrGhIBCpY+u37+GnLy9gVt5WRg3qwP0XHUWrZqmxLksSmIJApI64O6/NW889M3KocucPFw/mkmEaEJbYUxCI1IEtO8u46/XFzMwpZHiP1jx86RC6tm4a67JEAAWBSODeXryBX7+xhJLSCu46pz/Xn9SLpEY6CpD6Q0EgEpDtu8v57Ywcpi8o4MjO6Uy95Gj6ddBpoVL/KAhEAjAzZyO/en0J23eXc/sZfbn51CP0CEmptxQEIrVo665y7pmRw4yFBQzsmM5z1x3LoE4tY12WyH4pCERqgbvz5qIN3DMjhx2le/nJmX25aaSOAiQ+KAhEDtPG4lJ+/cYS3l9WyJAuLXnw4uPo3yE91mWJRE1BIHKIqqqcF2av5Q9vL2dvVRW/OmcA153UU2cESdxREIgcgtxNJfzi1cVkr9nGib3bcN+FR9Ejs1msyxI5JAoCkYNQureSx/+Vy/iPVtMsLZmHLh7Mxbo6WOKcgkAkSp+s2syv31jMV1t2c9HQztx17gAym6fFuiyRw6YgEDmAwh2l3PvmUt5ctIEebZrywg3HcWLvzFiXJVJrFAQi+1BRWcXkz9fwp/dWUl5ZxY/P6MO47xxB4xQ9L0AalkCDwMxGAX8BkoCn3f2BavOvBO4MT+4EbnL3hUHWJBKNL/K28JvpOawoLOGUvm353XcHaTBYGqzAgsDMkoDHgTOBfGCOmc1w96URi30JfMfdt5nZ2cAE4LigahI5kI3Fpdz/9jKmLyigc0YTxl81jLMGtddgsDRoQR4RDAdy3T0PwMymARcA/wkCd/8sYvlZQJcA6xHZp9K9lTzzyZc8/q9cKqqc207rzc0je9MkVd1A0vAFGQSdgXUR0/nsf2//euDtmmaY2VhgLEC3bt1qqz4R3J2ZOYX8/q1lrN26m/8a2J5fnzuQbm30rABJHEEGQU3H0l7jgmanEgqCk2qa7+4TCHUbkZWVVeNniBysnIJi7n1zKbPyttK3fXM9N1gSVpBBkA90jZjuAhRUX8jMBgNPA2e7+5YA6xEBQqeD/nHmCl6Zl09GkxTuvfBILj+2K8m6QZwkqCCDYA7Qx8x6AuuBy4ArIhcws27Aa8DV7r4ywFpE2FVWwYSP85jwcR6VVc4NJ/Xk1tP60LJJSqxLE4mpwILA3SvM7FZgJqHTRye6e46ZjQvPHw/8BmgDPBE+K6PC3bOCqkkS097KKl6as44/v7+KzTvLOPeojtw5qr/GAUTCzD2+utyzsrI8Ozs71mVIHHB33lmykYfeXUFe0S6G92jNL87pzzHdWsW6NJE6Z2Zz97WjrSuLpUH6NHczD76znEX5xfRu15ynr8ni9AHtdD2ASA0UBNKgzF2zjYffXcFnq7fQqWVjHrp4MBcd00XPCBDZDwWBNAhL1hfzp/dW8sHyTWQ2T+Xu8wZy5XHddF8gkSgoCCSu5RQU8+f3V/He0kJaNknhjlH9+MHxPWiWpj9tkWjpX4vEpSXri/nrB6uYmVNIi8bJ3H5GX649qQfpjXUqqMjBUhBIXFmwbjuPfbCK95dtokXjZH54eh+uP6mnrgUQOQwKAqn33J1ZeVt5/F+5fJK7mZZNUvjpmX35wYk6AhCpDQoCqbeqqpz3lxUy/qPVzFu7nczmafzy7P5cOaI7zTUGIFJr9K9J6p2yikqmzy/gyY9Xs7poF11aNeF3Fwzi0qyuOgtIJAAKAqk3tu8u54Uv1jLps68oKiljQMd0/nLZ0Zx7VEfdEE4kQAoCibnVRTt59tMveXXuevbsreSUvm155NJenNi7ja4EFqkDCgKJiaoq5+NVRTz32Vf8a0URqcmNuPDoTlx7Yk8GdEyPdXkiCUVBIHWqeM9eXpuXz+TP1/Dl5l1kNk/jx2f04aoR3clsnhbr8kQSkoJA6kROQTFTZq3hjfkF7NlbydFdM/jLZUdz9pEdSU1W/79ILCkIJDC7yip4c1EBU2evY+G67TROacR3h3TiqhHdGdwlI9bliUiYgkBqlbuzML+Yl+as4x8LC9hZVkGfds357fkDuWhoF1o21QVgIvWNgkBqxaaSUqbPL+CVufmsKCyhcUojzj2qE5cP78qw7q109o9IPaYgkENWureS95cV8vq89Xy4sojKKmdI1wzu+96RnD+kk27/IBInFARyUCqrnFl5W5i+YD1vL95ISVkF7dPTGHNyLy4e1pne7VrEukQROUgKAjmgqipn/rpt/GPhBv5v8QaKSspolprEqCM7ctExnRnRq42eACYSxxQEUqOqKmfe2m28tXgjby/ZwIbiUlKTG3Fav3Z89+hOnNa/ne77I9JAKAjkP8orqpiVt4WZORt5d2khRSVlpCY14pS+bblzVH9OH9COFur3F2lwFAQJbvvucj5aWcR7Swv5aEURJWUVNElJ4tT+bTlrUAdO7d9Og74iDZyCIMG4O0s37ODDFUV8uGITc9dso8ohs3kq5xzVkTMHtuekPpnq9hFJIAqCBLCppJRPczfz71WhV1FJGQCDOqVz66m9OW1AewZ3bkkjDfiKJCQFQQO0fXc5X3y5lc9Xb+Hz1VtYUVgCQKumKZzYO5OR/dpxSp9M2qU3jnGlIlIfKAgagMIdpWR/tY3ZX27hiy+3sqKwBHdonNKIY3u05sKhnTm5TyYDO6Zrr19EvkVBEGfKK6pYumEHC9ZuY/667WR/tY312/cA0CQliWHdW3HOUR0Z0asNQ7q2JC1Zff0isn8KgnqsrKKSVYU7ySkoZvH6YhbnF7NsQwnllVUAtGuRxrDurbj2xB5k9WjNoE7ppOiRjiJykBQE9YC7s3FHKSsLd7Ji4w6Wbyxh2YYScjeVsLfSAWiRlsyRnVsy+sQeHN01g6HdMujYskmMKxeRhkBBUId2lVWwZstu1mzZRd7mXawu2kle0S5yN+1kZ1nFf5brkN6Yfh1aMLJfWwZ1Smdgx3R6tGmm/n0RCUSgQWBmo4C/AEnA0+7+QLX5Fp5/DrAbGO3u84KsKShVVc623eVs3FHKxuJSNhSXUrB9D/nb9pC/bTdrt+5h886yb6zTPj2NXpnN+f4xnendvgV92jWnf4cWZDRNjVErRCQRBRYEZpYEPA6cCeQDc8xshrsvjVjsbKBP+HUc8Lfwf2OmorKK3Xsr2V1Wya7yCnaWVlBSWkFJ6V6279nLtt3lFO/ey5Zd5WzZWcbWXeVsKimjqKSMiir/xmelJBmdMprQOaMJp/VvS/c2zejepik92jSjZ2YzmqXpgExEYi/ILdFwINfd8wDMbBpwARAZBBcAk93dgVlmlmFmHd19Q20X89HKIu59cylV7rhDlTsVlc7eyioqqpyyvZWUVVR9a2Nek9TkRrRplkqb5qm0bpbGEe2a0z69Me1apNE+vTEdWzamU0YTMpun6a6cIlLvBRkEnYF1EdP5fHtvv6ZlOgPfCAIzGwuMBejWrdshFdM8LZl+7VtgBo3MMIPkRo1ISTKSk4y05CTSkhuRlpxEs7QkmqYm0zQ1ieZpyaQ3SaFF42RaNkmhVdNUGqc00hO3RKTBCDIIatpSVt/djmYZ3H0CMAEgKyvrwLvsNRjWvRXDurc6lFVFRBq0IE86zwe6Rkx3AQoOYRkREQlQkEEwB+hjZj3NLBW4DJhRbZkZwDUWMgIoDmJ8QERE9i2wriF3rzCzW4GZhE4fnejuOWY2Ljx/PPAWoVNHcwmdPnptUPWIiEjNAj1/0d3fIrSxj3xvfMTPDtwSZA0iIrJ/ujGNiEiCUxCIiCQ4BYGISIJTEIiIJDgLjdfGDzMrAtYc4uqZwOZaLCceqM2JQW1ODIfT5u7u3ramGXEXBIfDzLLdPSvWddQltTkxqM2JIag2q2tIRCTBKQhERBJcogXBhFgXEANqc2JQmxNDIG1OqDECERH5tkQ7IhARkWoUBCIiCa5BBoGZjTKzFWaWa2a/qGG+mdmj4fmLzOyYWNRZm6Jo85Xhti4ys8/MbEgs6qxNB2pzxHLHmlmlmV1cl/UFIZo2m9lIM1tgZjlm9lFd11jbovjbbmlm/zCzheE2x/VdjM1sopltMrMl+5hf+9svd29QL0K3vF4N9AJSgYXAwGrLnAO8TegJaSOAL2Jddx20+QSgVfjnsxOhzRHLfUDoLrgXx7ruOvg9ZxB6Lni38HS7WNddB22+C3gw/HNbYCuQGuvaD6PNpwDHAEv2Mb/Wt18N8YhgOJDr7nnuXg5MAy6otswFwGQPmQVkmFnHui60Fh2wze7+mbtvC0/OIvQ0uHgWze8Z4DbgVWBTXRYXkGjafAXwmruvBXD3eG93NG12oIWFHiTenFAQVNRtmbXH3T8m1IZ9qfXtV0MMgs7Auojp/PB7B7tMPDnY9lxPaI8inh2wzWbWGfgeMJ6GIZrfc1+glZl9aGZzzeyaOqsuGNG0+TFgAKHH3C4GfuTuVXVTXkzU+vYr0AfTxIjV8F71c2SjWSaeRN0eMzuVUBCcFGhFwYumzX8G7nT3ytDOYtyLps3JwDDgdKAJ8LmZzXL3lUEXF5Bo2nwWsAA4DTgCeM/M/u3uOwKuLVZqffvVEIMgH+gaMd2F0J7CwS4TT6Jqj5kNBp4Gznb3LXVUW1CiaXMWMC0cApnAOWZW4e5v1EmFtS/av+3N7r4L2GVmHwNDgHgNgmjafC3wgIc60HPN7EugPzC7bkqsc7W+/WqIXUNzgD5m1tPMUoHLgBnVlpkBXBMefR8BFLv7hroutBYdsM1m1g14Dbg6jvcOIx2wze7e0917uHsP4BXg5jgOAYjub3s6cLKZJZtZU+A4YFkd11mbomnzWkJHQJhZe6AfkFenVdatWt9+NbgjAnevMLNbgZmEzjiY6O45ZjYuPH88oTNIzgFygd2E9ijiVpRt/g3QBngivIdc4XF858Yo29ygRNNmd19mZu8Ai4Aq4Gl3r/E0xHgQ5e/5XmCSmS0m1G1yp7vH7e2pzexFYCSQaWb5wG+BFAhu+6VbTIiIJLiG2DUkIiIHQUEgIpLgFAQiIglOQSAikuAUBCIiCU5BICKS4BQEIiIJTkEgcpjCzztYZGaNzaxZ+J74R8a6LpFo6YIykVpgZv8LNCZ0o7d8d78/xiWJRE1BIFILwvfBmQOUAie4e2WMSxKJmrqGRGpHa0IPRWlB6MhAJG7oiECkFpjZDEJPz+oJdHT3W2NckkjUGtzdR0XqWvgpYBXuPtXMkoDPzOw0d/8g1rWJRENHBCIiCU5jBCIiCU5BICKS4BQEIiIJTkEgIpLgFAQiIglOQSAikuAUBCIiCe7/Af563wUDeG+NAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creating the plot\n",
    "plt.plot(x, y)\n",
    "\n",
    "plt.xlabel('x') # Chosing the name of the X axis\n",
    "plt.ylabel('y') # Chosing the name of the Y axis\n",
    "plt.title('Exponential curve f(x²)') # Chosing a title\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neat, huh? I wish I was this savvy with programming during college, it would've saved me a lot of time and, honestly, plotting on MS Excel makes me wanna puke. Sorry Excel, you suck.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Thoughts\n",
    "\n",
    "Python is an awesome, and versatile programming language. It can help you with the simplest calculations to the hardest data-driven analysis... and we pretty much covered all of its basics! Isn't this awesome?\n",
    "Actually, there a few little things that I intentionally left, such as loops and conditional statements. They are really useful and important but, as we are going to work mostly with procedural and simple, brief statements along with sympy, we aren't in imediate need to tackle tose. [Here](https://www.geeksforgeeks.org/loops-in-python/) are some extra materials talking about loops in Python, and [this](https://www.w3schools.com/python/python_conditions.asp) extra material talks about conditional statements.\n",
    "\n",
    "If the need to use such tools rises, I'll certainly release a pre-class appendix going through them."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References\n",
    "\n",
    "Sweigart, A. (2015). Automate the boring stuff with python: practical programming for total beginners. San Francisco: No Starch Press.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Appendix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] - Make sure you've installed Numpy and Matplotlib with !pip install before importing them, or else they'r enot gonna work.\n"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "5c0b7bc5c9bd6ed585469f2a782f7628ddbec92332ffb1d6ec4da7072157ae71"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}