ep_chapter_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Effective Python - Version 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Chapter 1. Pythonic Thinking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### String formatting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "key = 'my_var'\n",
    "value = 1.234"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_string = f'{key:<10} = {value:.2f}'\n",
    "\n",
    "str_args = '{:<10} = {:.2f}'.format(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_var     = 1.23\n",
      "my_var     = 1.23\n"
     ]
    }
   ],
   "source": [
    "print(f_string)\n",
    "print(str_args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert f_string == str_args, \"Not equal\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Helper Functions instead of Complex Expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from urllib.parse import parse_qs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'red': ['5'], 'blue': ['0'], 'green': ['']}\n",
      "{'red': ['5'], 'blue': ['0'], 'green': ['']}\n"
     ]
    }
   ],
   "source": [
    "my_values = parse_qs('red=5&blue=0&green=',\n",
    "                     keep_blank_values=True)\n",
    "print(my_values)\n",
    "print(repr(my_values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['5']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_values.get('red')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['5']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_values.get('red', [''])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_values.get('red', [''])[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_values.get('red')[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Zero and blanks will default to False, so here the 0 will print after the 'or' clause\n",
    "my_values.get('blue')[0] or 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The [''] within the get statement is the default value to return if the key does not exist\n",
    "#Since the key does not exist here, we default to empty string which defaults back to zero\n",
    "my_values.get('orange',[''])[0] or 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_first_int(values, key, default = 0):\n",
    "    found = values.get(key, [''])\n",
    "    \n",
    "    if found[0]:\n",
    "        return int(found[0])\n",
    "    return default"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_first_int(my_values, 'red')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Multiple assignment unpacking is better than indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('chips', 140), ('popcorn', 80), ('nuts', 90))\n"
     ]
    }
   ],
   "source": [
    "snack_calories = {\n",
    "    'chips': 140,\n",
    "    'popcorn': 80,\n",
    "    'nuts' :90\n",
    "}\n",
    "\n",
    "snacks = tuple(snack_calories.items())\n",
    "print(snacks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('popcorn', 80)\n",
      "80\n"
     ]
    }
   ],
   "source": [
    "print(snacks[1])\n",
    "print(snacks[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = ('pb', 'jelly')\n",
    "first, second = items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#You can swap values in-place with unpacking!\n",
    "#a[i-1], a[i] = a[i], a[i-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, ('chips', 140))\n",
      "(2, ('popcorn', 80))\n",
      "(3, ('nuts', 90))\n"
     ]
    }
   ],
   "source": [
    "for i in enumerate(snacks, start = 1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ('chips', 140)\n",
      "2 ('popcorn', 80)\n",
      "3 ('nuts', 90)\n"
     ]
    }
   ],
   "source": [
    "for i,j in enumerate(snacks, start = 1):\n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: chips has 140 calories\n",
      "#2: popcorn has 80 calories\n",
      "#3: nuts has 90 calories\n"
     ]
    }
   ],
   "source": [
    "for rank, (name, calories) in enumerate(snacks, 1):\n",
    "    print(f'#{rank}: {name} has {calories} calories')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Enumerate is preferred over range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vanilla is delicious\n",
      "chocolate is delicious\n",
      "strawberry is delicious\n"
     ]
    }
   ],
   "source": [
    "#Range should be used for a list of integers\n",
    "#Enumerate should be used for data structures\n",
    "\n",
    "flavors = ['vanilla', 'chocolate', 'strawberry']\n",
    "\n",
    "for flavor in flavors:\n",
    "    print(f'{flavor} is delicious')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#1: vanilla is yummy!\n",
      "#2: chocolate is yummy!\n",
      "#3: strawberry is yummy!\n"
     ]
    }
   ],
   "source": [
    "#If we want to access the index from a loop as well, use enumerate\n",
    "for i, flavor in enumerate(flavors, 1):\n",
    "    print(f'#{i}: {flavor} is yummy!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Use zip to process iterators in parallel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "counts = [len(n) for n in flavors]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 9, 10]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10   strawberry\n"
     ]
    }
   ],
   "source": [
    "longest_flavor = None\n",
    "max_count = 0\n",
    "\n",
    "for i, name in enumerate(flavors):\n",
    "    count = counts[i]\n",
    "    if count > max_count:\n",
    "        longest_flavor = name\n",
    "        max_count = count\n",
    "\n",
    "print(max_count, ' ', longest_flavor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10   strawberry\n"
     ]
    }
   ],
   "source": [
    "#Use zip to apply things to two or more iterators\n",
    "#Make sure your iterators are of the same length if doing this\n",
    "longest_flavor = None\n",
    "max_count = 0\n",
    "\n",
    "for name, count in zip(flavors, counts):\n",
    "    if count > max_count:\n",
    "        longest_flavor = name\n",
    "        max_count = count\n",
    "        \n",
    "print(max_count, ' ', longest_flavor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vanilla with count 7\n",
      "chocolate with count 9\n",
      "strawberry with count 10\n",
      "hersheyschocolate with count None\n"
     ]
    }
   ],
   "source": [
    "#If you want to use zip on mismatched length iterators, use zip_longest\n",
    "import itertools\n",
    "\n",
    "flavors.append('hersheyschocolate')\n",
    "longest_flavor = None\n",
    "max_count = 0\n",
    "\n",
    "for name, count in itertools.zip_longest(flavors, counts):\n",
    "    print(f'{name} with count {count}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Assignment Expressions (walrus operator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit = {\n",
    "    'apple': 10,\n",
    "    'banana': 8,\n",
    "    'lemon': 5\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nif count := fruit.get('lemon', 0):\\n        print('lemonade made')\\nelse:\\n    print('no lemonade')\\n\""
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Walrus operator only works in python > 3.9. We're running 3.7.3\n",
    "'''\n",
    "if count := fruit.get('lemon', 0):\n",
    "        print('lemonade made')\n",
    "else:\n",
    "    print('no lemonade')\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\nif (count := fruit.get('lemon', 0)) >= 4:\\n        print('lemonade made')\\nelse:\\n    print('no lemonade')\\n\""
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Walrus operator only works in python > 3.9. We're running 3.7.3\n",
    "\n",
    "'''\n",
    "if (count := fruit.get('lemon', 0)) >= 4:\n",
    "        print('lemonade made')\n",
    "else:\n",
    "    print('no lemonade')\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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}