Chapter8_Python_productivity_techniques.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "little-heating",
   "metadata": {},
   "source": [
    "# Chapter 8 - Pythonic Productivity Techniques"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hazardous-therapy",
   "metadata": {},
   "source": [
    "___\n",
    "## 8.1 Exploring Python modules and objects\n",
    "\n",
    "You can interactively explore modules and objects directly from the\n",
    "Python interpreter. This is an underrated feature that’s easy to overlook, especially if you’re switching to Python from another language.\n",
    "Many programming languages make it difficult to inspect a package or\n",
    "class without consulting online documentation or learning interface\n",
    "definitions by heart.\n",
    "\n",
    "Python is different—an effective developer will spend quite a bit of\n",
    "time in REPL sessions working interactively with the Python interpreter. For example, I often do this to work out little snippets of code\n",
    "and logic that I then copy and paste into a Python file I’m working on\n",
    "in my editor.\n",
    "\n",
    "### Summary\n",
    "* Use the built-in ```dir()``` function to interactively explore Python\n",
    "modules and classes from an interpreter session.\n",
    "* The ```help()``` built-in lets you browse through the documentation right from your interpreter (hit q to exit.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "expired-gamma",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['MAXYEAR',\n",
       " 'MINYEAR',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'date',\n",
       " 'datetime',\n",
       " 'datetime_CAPI',\n",
       " 'sys',\n",
       " 'time',\n",
       " 'timedelta',\n",
       " 'timezone',\n",
       " 'tzinfo']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datetime\n",
    "dir(datetime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "finished-entrance",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['date', 'datetime', 'datetime_CAPI']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# filtering the dir result\n",
    "[_ for _ in dir(datetime) if 'date' in _.lower()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "empty-vehicle",
   "metadata": {},
   "outputs": [],
   "source": [
    "# using the help function\n",
    "# help(datetime)\n",
    "# help(datetime.date)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "finnish-grave",
   "metadata": {},
   "source": [
    "___\n",
    "## 8.2 Isolating Project Dependencies with Virtualenv\n",
    "\n",
    "### Summary\n",
    "* Virtual environments keep your project dependencies separated. They help you **avoid version conflicts** between packages and different versions of the Python runtime.\n",
    "* As a **best practice**, all of your Python projects should use virtual\n",
    "environments to store their dependencies. **This will help avoid\n",
    "headaches**.\n",
    "\n",
    "Working with multiple projects that require different versions of the same package requires isolated virtual environments. \n",
    "\n",
    "When you install packages **globally there can be only one version** of a\n",
    "Python library across all of your programs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "governing-involvement",
   "metadata": {},
   "source": [
    "### Virtual Environments \n",
    "\n",
    "Separate python environments with isolated virtual environments. Physically,\n",
    "it lives inside a folder containing all the packages and other dependencies, like native-code libraries and the interpreter runtime, that\n",
    "a Python project needs.\n",
    "\n",
    "### Example virtual environment install\n",
    "1. Find the path to the pip package manager. It's usually a good idea to put the **virtual environments into the project folders**\n",
    "2.```$ python -m venv ./venv``` .This will take a moment and will create a new venv folder in the current directory and seed it with a baseline Python 3 environment.\n",
    "3. ```Path\\venv\\Scripts\\activate.bat```. Running the **activate command** configures your current shell session to use the Python and pip commands from the virtual environment instead.  \n",
    "4. You should see something like ```(venv) $ pip list```\n",
    "5. Install packages into this environment ```(venv) $ pip install schedule```\n",
    "6. ```(venv) $ deactivate```\n",
    "Therefore, your project dependencies will be physically separated\n",
    "from all other Python environments on your system, including the global one. In effect, you get a clone of the Python runtime that’s **dedicated to one project only**\n",
    "\n",
    "Reference: https://realpython.com/products/managing-python-dependencies/"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "promising-package",
   "metadata": {},
   "source": [
    "___\n",
    "## 8.3 Peeking behind the Bytecode curtain\n",
    "\n",
    "### Summary \n",
    "* CPython executes programs by first **translating them into an intermediate bytecode** and then running the bytecode on a **stackbased virtual machine**.\n",
    "* You can use the built-in ```dis``` module to peek behind the scenes\n",
    "and **inspect the bytecode**.\n",
    "* Study up on virtual machines—it’s worth it\n",
    "\n",
    "When the CPython interpreter executes your program, it first translates it into a sequence of bytecode instructions. Bytecode is an intermediate language for the Python virtual machine that’s used as a\n",
    "performance optimization.\n",
    "\n",
    "Instead of directly executing the human-readable source code, compact numeric codes, constants, and references are used that represent\n",
    "the result of compiler parsing and semantic analysis.\n",
    "\n",
    "**Reference for further reading** : Compiler Design: Virtual Machines by Wilhelm\n",
    "and Seidl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "sensitive-passport",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, Guido!'"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def greet(name):\n",
    "    return 'Hello, ' + name + '!'\n",
    "\n",
    "greet('Guido')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "adaptive-ottawa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'd\\x01|\\x00\\x17\\x00d\\x02\\x17\\x00S\\x00'"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet.__code__.co_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "known-hours",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(None, 'Hello, ', '!')"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet.__code__.co_consts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "banned-witch",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('name',)"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet.__code__.co_varnames"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "respiratory-nashville",
   "metadata": {},
   "source": [
    "The stack is the data structure used as internal working storage for the\n",
    "virtual machine. There are different classes of virtual machines and\n",
    "one of them is called a stack machine. CPython’s virtual machine is an\n",
    "implementation of such a stack machine. If the whole thing is named\n",
    "after the stack, you can imagine what a central role this data structure\n",
    "plays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "applied-adult",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  2           0 LOAD_CONST               1 ('Hello, ')\n",
      "              2 LOAD_FAST                0 (name)\n",
      "              4 BINARY_ADD\n",
      "              6 LOAD_CONST               2 ('!')\n",
      "              8 BINARY_ADD\n",
      "             10 RETURN_VALUE\n"
     ]
    }
   ],
   "source": [
    "import dis\n",
    "dis.dis(greet)"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}