chapter-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 Patterns for Cleaner Python\n",
    "\n",
    "based on: Dan Bader. Python Tricks: The Book."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 Covering Your A** With Assertions\n",
    "\n",
    "### Usage of assertions\n",
    "\n",
    "- internal self-checks for impossible situations\n",
    "- inform developers about unrecoverable errors arrising due to bugs\n",
    "- **do not** use for expected runtime errors such as File-Not-Found errors\n",
    "\n",
    "$\\Longrightarrow$ Assertions are a debugging help.\n",
    "\n",
    "### Implementation\n",
    "\n",
    "```python\n",
    "assert expression1, expression2\n",
    "```\n",
    "\n",
    "becomes\n",
    "\n",
    "```python\n",
    "if __debug__:\n",
    "    if not expression1:\n",
    "        raise AssertionError(expression2)\n",
    "```\n",
    "\n",
    "`__debug__` is `True` by default and can be deactivated using `-O` and `-OO` command line switches.\n",
    "\n",
    "**Since assertions can be disabled** do not use for data validation, checking admin privileges, etc. since this can lead to security issues and severe bugs.\n",
    "\n",
    "### Syntax pitfall\n",
    "\n",
    "```python\n",
    "# DO NOT USE\n",
    "assert(\n",
    "    1 == 2,\n",
    "    'This should fail'\n",
    ")\n",
    "```\n",
    "\n",
    "This will **never** fail."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Complacent Comma Placement\n",
    "\n",
    "When declaring list/set/dict constants, end all lines with a comma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alice', 'Bob', 'Jane']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = [\n",
    "    'Alice',\n",
    "    'Bob',\n",
    "    'Jane',\n",
    "]\n",
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This helps **avoiding errors** related to removing/adding items to constance (due to Python's string literal concatenation), such as:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alice', 'Bob', 'JaneKen']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = [\n",
    "    'Alice',\n",
    "    'Bob',\n",
    "    'Jane'\n",
    "    'Ken'\n",
    "]\n",
    "names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 Context Managers and the with Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`with` simplifies exception handling for resource management and allows to get rid of `try/finally` blocks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `with` for costum objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class-based implementation of a timer object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "class Timer:\n",
    "    def __init__(self):\n",
    "        self.starts = [time.time()]\n",
    "        \n",
    "    def __enter__(self):\n",
    "        self.starts.append(time.time())\n",
    "        return self\n",
    "        \n",
    "    def __exit__(self, exc_type, exc_val, exc_tb):\n",
    "        diff = time.time() - self.starts.pop()\n",
    "        print(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0052497386932373\n",
      "4.006026983261108\n",
      "5.011268854141235\n"
     ]
    }
   ],
   "source": [
    "with Timer() as timer:\n",
    "    time.sleep(1)\n",
    "    with timer:\n",
    "        time.sleep(2)\n",
    "        with timer:\n",
    "            time.sleep(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### @contextmanager-based implementation of a timer object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from contextlib import contextmanager\n",
    "import time\n",
    "\n",
    "@contextmanager\n",
    "def timer():\n",
    "    start = time.time()\n",
    "    yield\n",
    "    diff = time.time() - start\n",
    "    print(diff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0032591819763184\n",
      "4.004321098327637\n",
      "5.008270025253296\n"
     ]
    }
   ],
   "source": [
    "with timer():\n",
    "    time.sleep(1)\n",
    "    with timer():\n",
    "        time.sleep(2)\n",
    "        with timer():\n",
    "            time.sleep(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Underscores, Dunders, and More\n",
    "\n",
    "### Single leading underscore `_var`\n",
    "\n",
    "By convention, the name is meant for internal use only.\n",
    "\n",
    "### Single trailing underscore `var_`\n",
    "\n",
    "By convention, to avoid name clashes with language keywords.\n",
    "\n",
    "### Double leading underscore (dunder) `__var`\n",
    "\n",
    "Interpreter's name mangling rewrites attribute name to create collisions.\n",
    "\n",
    "### Double learing and trailing `__var__`\n",
    "\n",
    "Prevents name mangling and have special meaning.\n",
    "\n",
    "### Single underscore `_`\n",
    "\n",
    "By convention, used for 'don't care' variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 A Shocking Truth About String Formatting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Template strings\n",
    "\n",
    "To deal with user-exposed format strings (due to security issues)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am Groot.'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from string import Template\n",
    "\n",
    "t = Template('I am $name.')\n",
    "t.substitute(name='Groot')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Literal String Interpolation (f-strings)\n",
    "\n",
    "Use this whenever available (Python 3.6+)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am Groot!'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = 'Groot'\n",
    "f'I am {name + \"!\"}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### New style string formatting \n",
    "\n",
    "Use as fall-back. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am Groot!'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'I am {name}!'.format(name=name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.6 The Zen of Python Easter Egg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  }
 ],
 "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}