01-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Course Hero](images/hero.png)\n",
    "\n",
    "# Session 1 - Python, the Zen of Python and Virtual Environments\n",
    "\n",
    "## What is Python?\n",
    "\n",
    "Python is a programming language. <https://www.python.org>\n",
    "\n",
    "* Created by [**Guido van Rossum**](https://en.wikipedia.org/wiki/Guido_van_Rossum) in 1991.\n",
    "* General Purpose, **easy** to read, easy to learn, and high level.\n",
    "* **Interpreted**, not typed, single threaded.\n",
    "\n",
    "![Guido van Rossum](images/guido-van-rossum.jpeg)\n",
    "\n",
    "## Hello World\n",
    "\n",
    "The first step in a programming language is to make a \"Hello World\" program. In python that is really easy.\n",
    "\n",
    "The next \"cell\" is a **code cell**, meaning you can execute it inside of the document (Sweet, isn't it?). To execute it and print \"Hello World\" you need to select the cell and press `shift-enter` or press the run ( `▶️` ) button."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print constant strings is not funny (well, most of the time). To make dynamic programs we use **variables**, \"named boxes\" where we store information that we can change.\n",
    "\n",
    "![Variable Diagram](images/variable.png)\n",
    "\n",
    "The variables have a **type**, depending on the type of information they contain, but Python is not very strict over it. You don't need to declare or restrict the type, and you can change the type of information a variable uses. But the type lets the language know what we can do with the variable.\n",
    "\n",
    "> **Warning!** - That means you can program \"on the fly\" very quickly, and don't need to plan everything ahead of time. But it allows a lot of bad \"professional programming\" practices. We can make very \"messy\" programs with Python, and that can helps us develop faster. But it will make our code harder to maintain in the long run.\n",
    "\n",
    "The following code cell defines three variables of different types. One string variable for our name (change the code so instead of `David` is has your name), one integer variable for our age (change `50` for your age - no one will see it, so you don't need to lie), and the last one a boolean to say if we are married or not.\n",
    "\n",
    "Run the cell (yes, I know it has an error and will fail, we will talk about it in a second)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strings\n",
    "my_name = \"David\"\n",
    "\n",
    "# Numbers\n",
    "my_age = 50\n",
    "\n",
    "# Booleans\n",
    "am_i_married = true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**There was an error while running the cell!**\n",
    "\n",
    "> `NameError: name 'true' is not defined`\n",
    "\n",
    "Turns out boolean variables use the values `True` and `False`, with the first letter in caps, so the program failed in the 8th line because it didn't recognize the `true` (in lowercase) value.\n",
    "\n",
    "That shows us how an **interpreted language** works. It reads a line, interprets it, executes it, and if everything when ok it moves to the next one, until it finishes with all the lines. That has several disadvantages:\n",
    "\n",
    "- Every time the programs runs needs to be interpreted line by line again. That makes it **slow**.\n",
    "- If the program has a syntax error **we don't notice it until the program runs**.\n",
    "- If the program **runs \"halfway\"** some actions take place, but the ones after the error doesn't.\n",
    "\n",
    "In the next code cell we will see which variables got defined.\n",
    "\n",
    "<a id=\"printcell\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_name)\n",
    "print(my_age)\n",
    "print(am_i_married)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `my_name` and `my_age` variables got created and can be used, but the `am_i_married` variable didn't, and doesn't \"exists\" yet.\n",
    "\n",
    "Let's create the variable, correctly this time, in the next code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's do it right this time around, with True as the value\n",
    "am_i_married = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Now go \"back\" to the cell where we print the three variables](#printcell), and run it again. It should finish correctly, and display the three variable values. The return to the next cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### First run the cell with the three \"prints\" that failed the first time around.\n",
    "\n",
    "> **Warning!** - That shows us something we can do in Jupyter Notebooks like this one. We can run code \"out of order\". We will talk more about it when we discuss Jupyter Notebooks. As with the \"interpreted\" nature of Python, that can help us sometimes, but if we are not careful we can make a huge mess of our Notebooks.\n",
    "\n",
    "We can do operations on our variables. Modify them, join them, separate them, you say it!\n",
    "\n",
    "One of the simplest ways is to concatenate them so we can print them all together. We cannot concatenate strings and integer an booleans, so we first need to **convert** them to character variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The str function changes a number to a corresponding string\n",
    "my_age_string = str(my_age)\n",
    "print(my_age)\n",
    "print(my_age_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even if the printed values look the same, their **type** is different. The first one is an integer, the second one a string. The `type` functions shows you what type a variable has."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(my_age))\n",
    "print(type(my_age_string))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We do the same for the `am_i_married` variable, but with an if-statement, so we can choose which string to use.\n",
    "\n",
    "Notice how the **indentation**, the number of spaces before the first command, defines what is and what isn't included in the if and else statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We create a string depending on the married status\n",
    "if am_i_married:\n",
    "    am_i_married_string = \"married.\"\n",
    "else:\n",
    "    am_i_married_string = \"not married.\"\n",
    "\n",
    "print(am_i_married)\n",
    "print(am_i_married_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With all the conversions in place we can **concatenate** a full string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"I am \" + my_name + \", I have \" + str(my_age) + \" years old, and I am \" + am_i_married_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But there is more! In Python (almost) everything is an **Object**. That means that each variable has a `state` (it's values) and it's `behavior` (functions that operate on the state).\n",
    "\n",
    "For example we can see the functions of a string object, with the function `dir()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(my_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are a lot of them!\n",
    "\n",
    "The functions that start and end with double underscore `__` are called **dunder or magic methods**. They are used by Python to perform common operations. The other are methods more oriented to us, the programmers.\n",
    "\n",
    "For example the `upper` method let us convert the string to uppercase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_name.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depending on the type of a variable is the functions it has."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_age.bit_length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The tale of two Pythons.\n",
    "\n",
    "We have to be careful with Python versions. In 2008 Python 3 was released, but it took until 2020 for Python 2 to be deprecated to force everyone to move to Python 3.\n",
    "\n",
    "**Python 2**\n",
    "\n",
    "```python\n",
    "print \"Hello World\"\n",
    "```\n",
    "\n",
    "**Python 3**\n",
    "\n",
    "```python\n",
    "print(\"Hello World\")\n",
    "```\n",
    "\n",
    "There are some programs that **need** Python 2 to run. Unless that is explicitly the case, and there is no option to migrate, we should use only Python 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## So why is Python so popular?\n",
    "\n",
    "![Python Logo](images/python-logo.png)\n",
    "\n",
    "We saw Python has several drawbacks.\n",
    "\n",
    "So why it is so popular?\n",
    "\n",
    "- Python is very easy to learn **and to understand**. The value of having code that is easy to understand allow us to lower the cost of maintain it, making us as programmers very productive.\n",
    "- The syntax errors, variable types and code style can be controlled by **tools**. Even if Python doesn't do it by itself, there is a huge ecosystem of great tools that reduce/eliminate those drawbacks.\n",
    "- There are other more \"elegant\" languages (Clojure, Rust, or Go), performant (C) or domain-specific (Lisp, R), Python hits a **\"sweet spot\"** where is general enough for many uses, performant enough for most of them, and lets you do many different types of programming is you want (structured, object-oriented, functional, and others) without forcing you.\n",
    "- Even if the Python code is \"slow\", **we can use libraries** written in other languages and compiled to be very efficient and call them from Python, getting the best of each one, without forcing you to learn a complicated language.\n",
    "- Normally containers run in single-threaded mode, as well as Function-as-a-service solutions (AWS Lambda or GCP Cloud Run), or web server processes. So we don't lose anything because of Python being single-threaded. **The platform where our code runs takes care of the concurrency**, which is much easier as a developer.\n",
    "- As the language has to be interpreted, it is **portable**. It can run in a lot of platforms, from IoT to supercomputers, from the cloud to satellites, with no modification.\n",
    "- It is **free** (as in free lunch) and open source, no licenses attached.\n",
    "- Thousands of modules for **anything** you can think of."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Modules\n",
    "\n",
    "Python is known as a **batteries-included** language. Out of the box lets you do a lot of things.\n",
    "\n",
    "To use those modules we need:\n",
    "\n",
    "- If they are part of the **Standard Library** we just need to ``import`` them.\n",
    "- If they are **external modules**, we need to ``install`` them with ``pip`` (or ``conda``)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Antigravity](images/antigravity.png)\n",
    "\n",
    "> Yes, that is an **\"easter egg\"** in the language."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "\n",
    "# Today's date\n",
    "today = datetime.datetime.now()\n",
    "# My birthday (or anniversary, or other date), the parameters are year, month, day, hours, minutes\n",
    "my_birthday = datetime.datetime(1972, 3, 9)\n",
    "# Calculate the difference\n",
    "difference = today - my_birthday\n",
    "print(type(difference))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the difference\n",
    "print(\"Difference in days: \", difference)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can use f-strings\n",
    "print(f\"Difference in days: {difference.days:,}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the emoji library we need to install it. The `%` at the start of the command tells Jupyter to run the command against the Notebook Kernel (it's \"running environment\")."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install emoji"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import emoji\n",
    "\n",
    "print(emoji.emojize(\"There was a :man: and a :woman: that fell in love, and they became a :family:\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install art"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import art\n",
    "\n",
    "art.tprint(\"I Love Python!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(art.text2art(\"DSL\", font=\"block\", chr_ignore=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Each run will be different\n",
    "art.tprint(\"DSL\", \"rnd-xlarge\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install PyPDF2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import PyPDF2\n",
    "\n",
    "reader = PyPDF2.PdfReader(\"zen.pdf\")\n",
    "number_of_pages = len(reader.pages)\n",
    "page = reader.pages[0]\n",
    "text = page.extract_text()\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install geopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from geopy.geocoders import Nominatim\n",
    "\n",
    "geolocator = Nominatim(user_agent=\"ML Course\")\n",
    "\n",
    "location = geolocator.geocode(\"Amado Nervo 2200 Zapopan Jalisco México\")\n",
    "print(location.address)\n",
    "print((location.latitude, location.longitude))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "location = geolocator.reverse(\"20.6432019, -103.416706\")\n",
    "print(location.address)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install pandas plotly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import plotly.express as px\n",
    "import pandas as pd\n",
    "\n",
    "data = {\n",
    "    \"Programming\": 90,\n",
    "    \"Design\": 60,\n",
    "    \"Architecture\": 40,\n",
    "    \"Testing\": 75,\n",
    "}\n",
    "\n",
    "dataframe = pd.DataFrame(data.items(), columns=[\"Subject\", \"Percentage\"])\n",
    "\n",
    "figure = px.line_polar(dataframe, \n",
    "    r=\"Percentage\", \n",
    "    theta=\"Subject\", \n",
    "    line_close=True, \n",
    "    range_r=(0,100),\n",
    ")\n",
    "figure.update_traces(fill=\"toself\")\n",
    "figure.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = px.bar(dataframe,\n",
    "    x='Subject',\n",
    "    y='Percentage', \n",
    "    title=\"Subject Areas Comparison\", \n",
    "    color=\"Subject\",\n",
    "    color_discrete_sequence=px.colors.qualitative.Vivid,\n",
    "    text_auto=True\n",
    ")\n",
    "fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "px.colors.qualitative.swatches()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = px.data.gapminder()\n",
    "px.scatter(df, x=\"gdpPercap\", y=\"lifeExp\", animation_frame=\"year\", animation_group=\"country\",\n",
    "           size=\"pop\", color=\"continent\", hover_name=\"country\",\n",
    "           log_x=True, size_max=55, range_x=[100,100000], range_y=[25,90])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install pillow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image, ImageFilter\n",
    "\n",
    "img = Image.open(\"images/python-logo.png\",mode=\"r\")\n",
    "img"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img.filter(ImageFilter.CONTOUR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img.rotate(-45, Image.Resampling.NEAREST)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img.convert(\"L\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img.thumbnail((100,100))\n",
    "img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Virtual Environments\n",
    "\n",
    "In cloud environments like Binder, Containers or Cloud Functions we can install the required libraries without any issue.\n",
    "\n",
    "But when we are using our computer **we can need different libraries versions for different projects**. Also, our own computer Operating System can use specific Python and libraries versions that we don't want to \"conflict\" with the Python or library versions of our projects.\n",
    "\n",
    "**We need to isolate** out own computer environment from the projects'. For that we use **Python Virtual Environments** (or Containers for Development).\n",
    "\n",
    "The important thing to remember is to **avoid using the Operating System Python Environment** for our project work.\n",
    "\n",
    "> **Warning!** - If we are not careful we can install invalid Python or Libraries versions over the Operating System's one, and cause issues in the computer performance or stability."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Zen of Python\n",
    "\n",
    "How do we know if a program is **Pythonic**?\n",
    "\n",
    "There is a ``Python Enhancement Proposal``, [PEP 8](https://peps.python.org/pep-0008/) which talks about the **style** for Python programs, meaning how the code should look.\n",
    "\n",
    "But we are talking about how the code should be. The **\"spirit\"** of Python.\n",
    "\n",
    "It was defined in the [PEP 20](https://peps.python.org/pep-0020/), **The Zen of Python**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can download an PDF with the Zen of Python [**HERE**](zen.pdf)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Feedback\n",
    "\n",
    "![Your Feedback Matters](images/feedback.png)\n",
    "\n",
    "Please helps us filling up the **[Feedback Form](https://docs.google.com/forms/d/e/1FAIpQLSf-yrrCkg66KFFimIk62me8jkSybb9wY1tdqhuRNKG1pchk5w/viewform)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Next session\n",
    "\n",
    "We will make sure Python and Jupyter are installed in your computers.\n",
    "\n",
    "**Homework:** Ask a mentor about how can you use Python in your daily work."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('base')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "3067ead486e059ec00ffe7555bdb889e6e264a24dc711bf108106cc7baee8d5d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}