23_tricks_for_writing_idiomatic-python_code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tricks for writing idiomatic Python code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Indexing and looping through a list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using the enumerate() function you can easily get the index of an item and the item itself of a list (or any iterable) in pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: a\n",
      "1: b\n",
      "2: c\n",
      "3: d\n"
     ]
    }
   ],
   "source": [
    "some_list = ['a', 'b', 'c', 'd']\n",
    "for i, alphabet in enumerate(some_list):\n",
    "    print('{0}: {1}'.format(i, alphabet))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Using the “zip” function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If you ever need to pair the corresponding elements of two list, then you can use the zip function to easily do so.\n",
    "- Just make sure that both the lists are of same length to retrieve all the pair items from both the lists.\n",
    "    - You can try yourself to see the result if you zip two lists with different lengths."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 1), ('b', 2), ('c', 3)]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_list = ['a', 'b', 'c']\n",
    "second_list = [1, 2, 3]\n",
    "list(zip(first_list, second_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Swapping variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Although this might seem trivial in Python, it can be beneficial specifically when you are trying to shorten your code.\n",
    "- You can swap two variables in Python in just one line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 1)\n"
     ]
    }
   ],
   "source": [
    "a, b = 1, 10\n",
    "a, b = b, a\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Dictionary Lookups"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- If you are ever retrieving a value for a key from a dictionary, and you want to avoid a KeyError, then this might come in handy\n",
    "- This helps you retrieve the value for a key if it is present in the dictionary. Otherwise, you can assign a default value in case the key is not present."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {'a': 1, 'b': 2}\n",
    "x.get('a', 'Key Not Present')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Key Not Present'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {'a': 1, 'b': 2}\n",
    "x.get('c', 'Key Not Present')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Merging Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Merging two dictionaries is very simple in Python3. You can accomplish this in just a single command.\n",
    "- This is a very handy trick to make your code look idiomatic and beautiful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = {'a': 1}\n",
    "y = {'b': 2}\n",
    "{**x, **y}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Check if a string contains an integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Most of the times, you receive integer ids from form-data in the form of strings, and you may need to check if the data you received is actually an integer id or not.\n",
    "- In such cases, you can implement the following two techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# First technique (Only works for positive integers)\n",
    "string_int = '32'\n",
    "string_int.isdigit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Second method (Works for all integers)\n",
    "def is_integer(some_integer_in_string):\n",
    "    try:\n",
    "        int(some_integer_in_string)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "    \n",
    "is_integer('-32')\n",
    "#is_integer('49')\n",
    "#is_integer('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Reverse a list or string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- You can easily reverse a list or string or any iterable that supports slicing in one line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2, 1]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reversing a list\n",
    "original_list = [1, 2, 3, 4]\n",
    "reversed_list = original_list[::-1]\n",
    "reversed_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'gnirts a si sihT'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reversing a string\n",
    "some_string = 'This is a string'\n",
    "reversed_string = some_string[::-1]\n",
    "reversed_string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Function argument unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In python you can assign dynamic arguments while making a function call\n",
    "- There are ways through which you can send any number of argument values to a user-defined function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "def some_function(x, y, z):\n",
    "    print(x, y, z)\n",
    "    \n",
    "some_function(*[1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "some_function(**{'x': 1, 'y': 2, 'z': 3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, {'a': 1, 'b': 2}, (1, 2))\n",
      "{'y': 2, 'x': 1}\n"
     ]
    }
   ],
   "source": [
    "# Another way\n",
    "def another_function(*args, **kwargs):\n",
    "    print(args)\n",
    "    print(kwargs)\n",
    "    \n",
    "another_function(1, 2, 3, {'a': 1, 'b': 2}, (1, 2), **{'x': 1, 'y': 2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}