0. Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What is Python?\n",
    "\n",
    "[Python](www.python.org) is a modern, general-purpose, object-oriented, high-level programming language.\n",
    "\n",
    "General characteristics of Python:\n",
    "\n",
    "* *clean and simple language*: easy to read code, easy to learn syntax, maintainability scales well with size of projects.\n",
    "* *expressive language*: fewer lines of code, fewer bugs, easier to maintain.\n",
    "\n",
    "Technical details:\n",
    "\n",
    "* *dynamically typed*: no need to define the type of variables, function arguments or return types.\n",
    "* *automatic memory management*: no need to explicitly allocate and deallocate memory for variables and data arrays.\n",
    "* *interpreted*: no need to compile the code, the Python interpreter reads and executes the python code directly.\n",
    "\n",
    "Advantages:\n",
    "\n",
    "* Ease of programming, minimizing the time required to develop, debug and maintain the code.\n",
    "* Well designed language that encourage many good programming practices:\n",
    "  * Modular and object-oriented programming, good system for packaging and re-use of code.\n",
    "  * Documentation tightly integrated with the code.\n",
    "* A large standard library, and a large collection of add-on packages.\n",
    "\n",
    "Disadvantages:\n",
    "\n",
    "* Since Python is an interpreted and dynamically typed programming language, the execution of python code can be slow compared to compiled statically typed programming languages, such as C/C++.\n",
    "* Somewhat decentralized, with different environment, packages and documentation spread out at different places.\n",
    "\n",
    "Python is not only a programming language, but often also refers to the standard implementation of the interpreter (technically referred to as [CPython](http://en.wikipedia.org/wiki/CPython)) that actually runs the Python code on a computer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Interpretation versus compilation\n",
    "\n",
    "The are two different types of computer languages: **compiled** languages and **interpreted** languages. Roughly speaking, programs written with *compiled languages* are first translated (**compiled**) into a form (**binary code**) that the computer hardware understands, and then run. Porgrams written with an **interpreted language** are translated step bt step by a special computer program, called **interpreter**. \n",
    "\n",
    "The *interpreter* is a computer program that directly executes instructions written in a interpreted language, without requiring them previously to have been compiled into a binary code.\n",
    "\n",
    "Typical compliled languages are C++ and Go. Python is an interpreted language, like Perl and Javascript.\n",
    "\n",
    "To create and execute a compiled program, a programmer must:\n",
    "\n",
    "* Create the program source code.\n",
    "* Parse or analyses all of the language statements in the source code for correctness. If incorrect, throws an error.\n",
    "* Convert source code to machine code.\n",
    "* Link different code files into a runnable program.\n",
    "* Run the program.\n",
    "\n",
    "To create and execute an interpreted program, a programmer must:\n",
    "\n",
    "* Create the program source code.\n",
    "* Run the program.\n",
    "\n",
    "The is no linking of files or machine code generation. Source statements are analysed and executed line by line **during** execution.\n",
    "\n",
    "![Compiler vs interpreter](images/053018_0616_CompilervsI1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python environments\n",
    "\n",
    "There are many different *environments* through which the Python *interpreter* can be used. Each environment has different advantages and is suitable for different workflows. One strength of Python is that it is versatile and can be used in complementary ways, but it can be confusing for beginners so we will start with a brief survey of python environments.\n",
    "\n",
    "## Python interpreter\n",
    "\n",
    "The standard way to use the Python programming language is to use the Python interpreter to run Python code. The Python interpreter is a program that reads and execute the python code in files passed to it as arguments. At the command prompt, the command `python` is used to invoke the Python interpreter.\n",
    "For example, to run a file `my-program.py` that contains Python code from the command prompt, use:\n",
    "\n",
    "```shell\n",
    "$ python my-program.py\n",
    "```\n",
    "\n",
    "> The **$** symbol in the command line instructions denotes the prompt, so it must not be copy-pasted.\n",
    "\n",
    "We can also start the interpreter by simply typing `python` at the command line, and interactively type Python code into the interpreter (press `Ctrl+D` or type `exit()` to exit):\n",
    "\n",
    "![python-shell.jpg](images/python-shell.jpg)\n",
    "\n",
    "The `>>>` symbols represent the *prompt* where you will type code expressions. The interpreter awaits our instructions step by step. This is often how we want to work when quick testing small portions of code, or when doing small calculations. \n",
    "\n",
    "\n",
    "While some Python programmers execute all of their Python code in this way, those doing data analysis or scientific computing make use of IPython, an enhanced Python interpreter, or Jupyter notebooks, web-based code notebooks originally created within the IPython project.\n",
    "\n",
    "## IPython\n",
    "\n",
    "We can start IPython by simply typing `ipython` at the command (press `Ctrl+D` or type `exit()` to exit):\n",
    "\n",
    "![ipython.jpg](images/ipython.jpg)\n",
    "\n",
    "The default IPython prompt adopts the numbered `In [1]:` style compared with the standard `>>> prompt.\n",
    "You can execute arbitrary Python statements by typing them in and pressing Return (or Enter). When you type just a variable into IPython, it renders a string representa‐ tion of the object.\n",
    "\n",
    "## Jupyter notebook\n",
    "\n",
    "Jupyter notebook is an HTML-based notebook environment for Python, similar to Mathematica or Matlab. It is based on the IPython shell, but provides a cell-based environment with great interactivity, where calculations can be organized and documented in a structured way.  \n",
    "Although using a web browser as graphical interface, Jupyter notebooks are usually run locally, from the same computer that runs the browser. To start a new Jupyter notebook session, run the following command:\n",
    "\n",
    "```shell\n",
    "$ jupyter notebook\n",
    "```\n",
    "\n",
    "from a directory where you want the notebooks to be stored. This will open a new browser window (or a new tab in an existing window) with an index page where existing notebooks are shown and from which new notebooks can be created.\n",
    "\n",
    "![jupyter-home.png](images/jupyter-home.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Versions of Python\n",
    "\n",
    "There are currently two versions of python: Python 2 and Python 3. Python 3 will eventually supercede Python 2, but it is not backward-compatible with Python 2. We will use Python 3.\n",
    "\n",
    "To see which version of Python you have, run:\n",
    "```shell\n",
    "$ python --version\n",
    "Python 3.7.6\n",
    "$ python3 --version\n",
    "Python 3.7.6\n",
    "$ python2 --version\n",
    "Python 2.7.16\n",
    "```\n",
    "\n",
    "Several versions of Python can be installed in parallel, with different commands."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Installation of Python\n",
    "\n",
    "There are different options to install Python and other Python packages. We will use Python 3. Note that Python 2 is not compatible with Python 3.\n",
    "\n",
    "Python 3 can be obtained from the Python Software Foundation [website](https://www.python.org/). Typically, that involves downloading the appropriate **installer** for your operating system and running it on your machine.\n",
    "\n",
    "To install the Python 3 interpreter on specific OSes, these are the most common ways:\n",
    "* On Windows, the best way to install Python 3 is to install a specific **package manager** called [Anaconda](https://www.anaconda.com/). Anaconda works for Linux and MacOS as well, and provides both graphical and command-line installers.\n",
    "* Linux-based OSes already provide a **package manager** such as [apt](https://tracker.debian.org/pkg/apt)  that can be run to install Python 3.\n",
    "* On macOS, the best way to install Python 3 involves installing a **package manager** called [Homebrew](https://brew.sh/).\n",
    "\n",
    "Anaconda is highly recommended for new users. In the following, we will see how to install Python 3 on a Linux-based Ubuntu machine from the command line.\n",
    "\n",
    "## Python 3 on Ubuntu\n",
    "\n",
    "To install [Python 3](https://www.python.org/) use the following commands:\n",
    "\n",
    "```bash\n",
    "$ sudo apt-get update\n",
    "$ sudo apt-get install python3\n",
    "```\n",
    "\n",
    "Create a `python` alias to the `python3` command using the following command:\n",
    "\n",
    "```bash\n",
    "$ sudo update-alternatives --install /usr/bin/python python /usr/bin/python3 10\n",
    "```\n",
    "\n",
    "Now you can use `python` and `python3` commands interchangebly in any shell.\n",
    "\n",
    "Check that everything is correctly installed.\n",
    "\n",
    "```bash\n",
    "$ python3 --version\n",
    "Python 3.6.9\n",
    "$ python --version\n",
    "Python 3.6.9\n",
    "```\n",
    "\n",
    "The output numbers may be different, but the first number must be 3.\n",
    "\n",
    "To start a Python shell, use the command `python`:\n",
    "```bash\n",
    "$ python\n",
    "Python 3.6.9 (default, Nov  7 2019, 10:44:02)\n",
    "[GCC 8.3.0] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```\n",
    "To exit from a Python shell, press `Ctrl + D` or use the `exit()` shell command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules and packages\n",
    "\n",
    "In programming, a module is a piece of software that has a specific functionality. A module contains everything necessary to execute only one aspect of the specific functionality. In Java, the term *package* is often used as a synonym of module. In Python, a *package* is a collection of modules.\n",
    "\n",
    "The recommended tool for installing Python packages is [Pip](https://pip.pypa.io/en/stable/). Pip is a de facto standard package-management system used to install and manage software packages written in Python.  \n",
    "Most distributions of Python come with Pip preinstalled. Python 2.7.9 and later, and Python 3.4 and later include the `pip` utility (`pip3` for Python 3) by default.\n",
    "\n",
    "The Pip and Python versions must match, so we install Pip 3 using the following command:\n",
    "```bash\n",
    "$ sudo apt install python3-pip\n",
    "```\n",
    "Create a `pip` alias to the `pip3` command using the following command:\n",
    "\n",
    "```bash\n",
    "$ sudo update-alternatives --install /usr/bin/pip pip /usr/bin/pip3 10\n",
    "```\n",
    "Now you can use `pip` and `pip3` commands interchangebly in any shell.\n",
    "\n",
    "Check that everything is correctly installed.\n",
    "```bash\n",
    "$ pip3 --version\n",
    "pip 9.0.1 from /usr/lib/python3/dist-packages (python 3.6)\n",
    "$ pip --version\n",
    "pip 9.0.1 from /usr/lib/python3/dist-packages (python 3.6)\n",
    "```\n",
    "\n",
    "To upgrade Pip to the latest version use the following command:\n",
    "```bash\n",
    "$ pip install -U pip\n",
    "```\n",
    "\n",
    "The `pip` command can be run from the command prompt as follows:\n",
    "```bash\n",
    "$ pip <pip arguments>\n",
    "```\n",
    "The most common scenarios are the following:\n",
    "*  Install a package:\n",
    "\n",
    "    ```bash\n",
    "    $ pip install [package name]\n",
    "    ```\n",
    "\n",
    "*  Uninstall a package:\n",
    "\n",
    "    ```bash\n",
    "    $ pip uninstall [package name]\n",
    "    ```\n",
    "\n",
    "*  List the installed packages:\n",
    "\n",
    "    ```bash\n",
    "    $ pip list\n",
    "    ```\n",
    "\n",
    "*  Upgrade a package:\n",
    "    ```bash\n",
    "    $ pip install --upgrade [package name]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running Python programs\n",
    "\n",
    "Open a text editor (on UNIX systems you can use the `nano` or `vi` command-line editors) and create a file called `helloworld.py`, with the following content:\n",
    "\n",
    "```python\n",
    "# My first Python program\n",
    "print(\"Hello, World!\")\n",
    "```\n",
    "\n",
    "Python code is usually stored in text files with the file ending \"`.py`\".\n",
    "\n",
    "Every line in a Python program file is assumed to be a Python statement, or part thereof.\n",
    "The only exception is *comment lines*, which start with the character `#` (optionally preceded by an arbitrary number of white-space characters, i.e., tabs or spaces). Comment lines are usually ignored by the Python interpreter.\n",
    "\n",
    "To run a Python program from the command line use:\n",
    "\n",
    "```bash\n",
    "$ python helloworld.py\n",
    "```\n",
    "\n",
    "On UNIX systems it is common to define the path to the interpreter on the first line of the program (note that this is a comment line as far as the Python interpreter is concerned):\n",
    "\n",
    "```python\n",
    "#!/usr/bin/env python\n",
    "\n",
    "# My first Python program\n",
    "print(\"Hello, World!\")\n",
    "```\n",
    "\n",
    "If we do, and if we additionally set the file script to be executable (on UNIX system, run `chmod a+x helloworld.py`), we can run the program like this:\n",
    "\n",
    "```shell\n",
    "$ helloworld.py\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter Notebook\n",
    "\n",
    "[Jupyter Notebook](http://jupyter.org/) is an open-source web application that lets you create and share interactive code, visualizations, and more.\n",
    "\n",
    "The Jupyter notebook is a web-based application. This means that you run a notebook server (the default is for this to be on your local machine), connect to it using your web browser, and all the functionality is accessible via mouse and keyboard input through your browser.\n",
    "\n",
    "Jupyter notebooks are particularly useful as scientific lab books when you are doing lots of data analysis using computational tools. This is because, with Jupyter notebooks, you can:\n",
    "* Record the code you write in a notebook as you manipulate your data. This is useful to remember what you've done, repeat it if necessary, etc.\n",
    "* Graphs and other figures are rendered directly in the notebook so there's no more printing to paper, cutting and pasting as you would have with paper notebooks or copying and pasting as you would have with other electronic notebooks.\n",
    "* You can update the notebook (or parts thereof) with new data by re-running cells. You could also copy the cell and re-run the copy only if you want to retain a record of the previous attempt.\n",
    "\n",
    "## Installation\n",
    "\n",
    "Install Jupyter with the local instance of pip, as follows.\n",
    "```bash\n",
    "$ pip3 install jupyter\n",
    "```\n",
    "That installed the executables into `~/.local/bin/`, which then needs to be added to the execution path.\n",
    "```bash\n",
    "$ export PATH=$PATH:~/.local/bin/\n",
    "```\n",
    "It's a good idea to add that to one of your startup scripts, probably `.bashrc`.<br>\n",
    "At this point, you have successfully installed all the software needed to run Jupyter.\n",
    "\n",
    "## Usage\n",
    "\n",
    "To start a Jupyter notebook server, navigate to a suitable working directory and type the following command:\n",
    "```bash\n",
    "$ jupyter notebook\n",
    "```\n",
    "\n",
    "This starts a Jupyter notebook server and automatically opens it in the browser. You should get something like this:\n",
    "\n",
    "![jupyter-home.png](images/jupyter-home.png)\n",
    "\n",
    "Here's a quick list of the main functionalities in Jupyter notebooks:\n",
    "* Start a new notebook clicking `New` in the top-right corner\n",
    "* Type in some Python code in a **cell** and press `Shift` + `Enter` to execute.\n",
    "* Change the cell type from `Code` to `Markdown` using the drop-down box (top-middle) to write explanatory text. Markdown guidance is available [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet%20%22Markdown%20cheat-sheet%20on%20GitHub).\n",
    "* Add new cells using the `+` button (top-left).\n",
    "* Save the notebook using the disk button (top-left).\n",
    "* Run cells in various ways (run all, run selection, run all above, run all below, etc.) using the options in the `Cell` menu.\n",
    "* Interrupt the kernel, restart it, clear all output, etc. using the options in the `Kernel` menu.\n",
    "* Download as Python script, HTML, LaTeX, etc. using the options under `File > Download as`.\n",
    "\n",
    "An open notebook has exactly one interactive session connected to a kernel which will execute code sent by the user and communicate back results. **This kernel remains active if the web browser window is closed**, and reopening the same notebook from the dashboard will reconnect the web application to the same kernel. This means that notebooks are an interface to kernel, the kernel executes your code and outputs back to you through the notebook. The kernel is essentially our programming language we wish to interface with.\n",
    "\n",
    "## Configuration\n",
    "\n",
    "> This part contains advanced configuration options and can be skipped\n",
    "\n",
    "The Jupyter notebook server can be run with a variety of command line options.\n",
    "Defaults for these options can also be set by creating a file named `jupyter_notebook_config.py` in your Jupyter folder. The Jupyter folder is in your home directory, `~/.jupyter`.<br>\n",
    "\n",
    "To create a `jupyter_notebook_config.py` file, with all the defaults commented out, you can use the following command line:\n",
    "```bash\n",
    "$ jupyter notebook --generate-config\n",
    "```\n",
    "By default, the Jupyter notebook server will run locally and listening on port 8888, i.e., you need to open locally a browser and use the address `http://localhost:8888` using a random session token provided from the command line.\n",
    "\n",
    "Since on your virtual machine there is no browser, we will change some configuration options in the `jupyter_notebook_config.py` file to allow access to the Jupyter notebook server from your local machine without a token id.\n",
    "\n",
    "To allow remote connections from all IP addresses, uncomment the option `c.NotebookApp.ip` in the `jupyter_notebook_config.py` file and set it to `'0.0.0.0'`.\n",
    "\n",
    "In order to protect your Jupyter notebook server, you can set a login password with the following command:\n",
    "```bash\n",
    "$ jupyter notebook password\n",
    "Enter password:\n",
    "Verify password:\n",
    "[NotebookPasswordApp] Wrote hashed password to ~/.jupyter/jupyter_notebook_config.json\n",
    "```\n",
    "\n",
    "A hash of the password is stored in the file listed above. Restart the server and notice that the URL provided no longer contains a random session token to be used for login.\n",
    "\n",
    "Now you can run the Jupyter notebook server on your virtual machine:\n",
    "```bash\n",
    "$ jupyter notebook --no-browser\n",
    "```\n",
    "and connect to it from your local browser using the following address\n",
    "```\n",
    "http://<machine IP address>:8888/\n",
    "```\n",
    "The notebook dashboard, which is the landing page with an overview of the notebooks in your working directory, is typically found and accessed at the default URL you just used.\n",
    "\n",
    "In the non-root user's terminal, press `Ctrl + C` to stop the running Jupyter notebook server.\n",
    "\n",
    "Navigate to the provided address to access your Jupyter notebook server. If you find yourself in the homepage without entering a password, click on the logout button and try again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Virtual Environments\n",
    "\n",
    "Python has its own unique way of downloading, storing, and locating packages (or modules). There are a few different locations where these packages can be installed on your system. \n",
    "\n",
    "Most **system packages**, i.e., packages that are part of the standard Python library, are stored in a child directory of the path stored in `sys.prefix`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-14T09:37:05.714312Z",
     "start_time": "2020-07-14T09:37:05.703400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "print(sys.prefix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Third party packages, or **site packages**, installed using `pip` are typically placed in one of the directories pointed to by `site.getsitepackages`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-14T09:38:08.140606Z",
     "start_time": "2020-07-14T09:38:08.113511Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['/usr/local/Cellar/python/3.7.7/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages']\n"
     ]
    }
   ],
   "source": [
    "import site\n",
    "\n",
    "print(site.getsitepackages())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, every project on your system will use these same directories to store and retrieve site packages. \n",
    "Site packages are stored according to just their name, there is no differentiation between versions.\n",
    "\n",
    "Consider the following scenario where you have two projects: *ProjectA* and *ProjectB*, both of which have a dependency on the same package, *ProjectC*. Both projects, *ProjectA* and *ProjectB*, would be required to use the same version, which is unacceptable in many cases.\n",
    "For example, *ProjectA* needs *ProjectC* `v1.0.0`, while *ProjectB* requires the newer *ProjectC* `v2.0.0`, for example.\n",
    "\n",
    "This is a real problem for Python since it can’t differentiate between versions in the `site-packages` directory. So both `v1.0.0` and `v2.0.0` would reside in the same directory with the same name.\n",
    "\n",
    "Python's **virtual environments**, and the `venv` tool, allow to create an isolated environment for Python projects. This means that each project can have its own dependencies, regardless of what dependencies every other project has.\n",
    "\n",
    "In our example, we would just need to create a separate virtual environment for both *ProjectA* and *ProjectB*,  Each environment, in turn, would be able to depend on whatever version of *ProjectC* they choose, independent of the other.\n",
    "\n",
    "Practically, virtual environments are just directories containing a few scripts.\n",
    "\n",
    "## Creating a virtual environment\n",
    "\n",
    "Start by making a new directory to work with:\n",
    "\n",
    "```bash\n",
    "$ mkdir python-virtual-environments\n",
    "$ cd python-virtual-environments\n",
    "```\n",
    "\n",
    "Create a new virtual environment inside the directory:\n",
    "```bash\n",
    "$ python3 -m venv env\n",
    "```\n",
    "\n",
    "**By default, this will not include any of your existing site packages.**\n",
    "\n",
    "In the above example, this command creates a directory called `env`, which contains a directory structure similar to this:\n",
    "\n",
    "```\n",
    "env\n",
    "├── bin\n",
    "│   ├── Activate.ps1\n",
    "│   ├── activate\n",
    "│   ├── activate.csh\n",
    "│   ├── activate.fish\n",
    "│   ├── easy_install\n",
    "│   ├── easy_install-3.8\n",
    "│   ├── pip\n",
    "│   ├── pip3\n",
    "│   ├── pip3.8\n",
    "│   ├── python -> python3\n",
    "│   └── python3 -> /usr/local/Cellar/python@3.8/3.8.2/bin/python3\n",
    "├── include\n",
    "├── lib\n",
    "│   └── python3.8\n",
    "│       └── site-packages\n",
    "...\n",
    "└── pyvenv.cfg\n",
    "```\n",
    "\n",
    "where the folders contain:\n",
    "\n",
    "* `bin`: the files that interact with the virtual environment\n",
    "* `include`: the C headers that compile the Python packages\n",
    "* `lib`: a copy of the Python version along with a site-packages folder where each dependency is installed\n",
    "\n",
    "In the `bin`folder there are copies of, or symlinks to, a few different Python tools as well as to the Python executables themselves. These files are used to ensure that all Python code and commands are executed within the context of the current environment, which is how the isolation from the global environment is achieved. The *activate scripts* are used to set up your shell to use the environment’s Python executable and its site-packages by default.\n",
    "\n",
    "## Using a virtual environment\n",
    "\n",
    "In order to use this environment’s packages/resources in isolation, you need to “activate” it. To do this, just run the following:\n",
    "\n",
    "```bash\n",
    "$ source env/bin/activate\n",
    "(env) $\n",
    "```\n",
    "\n",
    "Notice how your prompt is now prefixed with the name of your environment (`env`, in our case). This is the indicator that `env` is currently active, which means the `python` executable will only use this environment’s packages and settings.\n",
    "\n",
    "To show the package isolation in action, we can use the `bcrypt` module as an example. Let’s say we have `bcrypt` installed system-wide but not in our virtual environment.\n",
    "\n",
    "Before we test this, we need to go back to the “system” context by executing deactivate:\n",
    "\n",
    "```bash\n",
    "(env) $ deactivate\n",
    "$\n",
    "```\n",
    "\n",
    "Now your shell session is back to normal, and the `python` command refers to the global Python install. \n",
    "\n",
    "Now, install `bcrypt` and use it to hash a password:\n",
    "\n",
    "```bash\n",
    "$ pip -q install bcrypt\n",
    "$ python -c \"import bcrypt; print(bcrypt.hashpw('password'.encode('utf-8'), bcrypt.gensalt()))\"\n",
    "b'$2b$12$G5bwXFWYvvu3lSchR6taFeaBHehPRbQH4OFcIhCTZ1weEngWl5tz6'\n",
    "```\n",
    "\n",
    "Here’s what happens if we try the same command when the virtual environment is activated:\n",
    "\n",
    "```bash\n",
    "$ source env/bin/activate\n",
    "(env) $ python -c \"import bcrypt; print(bcrypt.hashpw('password'.encode('utf-8'), bcrypt.gensalt()))\"\n",
    "Traceback (most recent call last):\n",
    "  File \"<string>\", line 1, in <module>\n",
    "ImportError: No module named 'bcrypt'\n",
    "```\n",
    "As you can see, the behavior of the `python -c \"import bcrypt...\"` command changes after the `source env/bin/activate` call.\n",
    "\n",
    "In one instance, we have `bcrypt` available to us, and in the next we don’t. This is the kind of separation we’re looking to achieve with virtual environments, which is now easily achieved.\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}