Tricks_to_clean_python_coding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "541390b9",
   "metadata": {},
   "source": [
    "## 1) Iterate with enumerate() instead of range(len())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1275289",
   "metadata": {},
   "source": [
    "### for idx, num in enumerate(data): returns both the current index and the current item as a tuple. \n",
    "##### example 1.1, add more later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9689ef7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Inside the function definition, you initialize n to be the value of start and run a for loop over the sequence.\n",
    "#For each elem in sequence, you yield control back to the calling location and send back the current values of n and elem. \n",
    "#Finally, you increment n to get ready for the next iteration. \n",
    "\n",
    "def my_enumerate(sequence, start=0):\n",
    "    n = start\n",
    "    for elem in sequence:\n",
    "        yield n, elem\n",
    "        n += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "30d2e72c",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [1, 2, -3, -4]\n",
    "# weak:\n",
    "for i in range(len(data)):\n",
    "    if data[i] < 0:\n",
    "        data[i] = 0\n",
    "# better:idx:\n",
    "data = [1, 2, -3, -4]\n",
    "for idx, num in enumerate(data):\n",
    "    if num < 0:\n",
    "        data[idx] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8bf0a2c",
   "metadata": {},
   "source": [
    "## 2) Use list comprehension instead of raw for-loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "527c4fda",
   "metadata": {},
   "source": [
    "##### example 2.1， a list with all the squared numbers between 0 and 9. The tedious way would be to create an empty list, then use a for loop, do our calculation, and append it to the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fc446cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# weak:\n",
    "squares = []\n",
    "for i in range(10):\n",
    "    squares.append(i*i)\n",
    "\n",
    "#A simpler way to do this is list comprehension. Here we only need one line to achieve the same thing:\n",
    "\n",
    "# better:\n",
    "squares = [i*i for i in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d0e35b9",
   "metadata": {},
   "source": [
    "##### example 2.2，if else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "204136f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[22, 13, 45, 50, 98, 69, 43, 44, 1]\n",
      "[27, 18, 46, 51, 99, 70, 48, 49, 6]\n"
     ]
    }
   ],
   "source": [
    "l = [22, 13, 45, 50, 98, 69, 43, 44, 1]\n",
    "lnew=[x+1 if x >= 45 else x+5 for x in l]\n",
    "print(l)\n",
    "print(lnew)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fdb0261",
   "metadata": {},
   "source": [
    "#  3) Sort complex iterables with the built-in sorted() method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d49aa896",
   "metadata": {},
   "source": [
    "#### If we need to sort some iterable, e.g., a list, a tuple, or a dictionary, we don't need to implement the sorting algorithm ourselves. We can simply use the built-in sorted function. This automatically sorts the numbers in ascending order and returns a new list. If we want to have the result in descending order, we can use the argument reverse=True. As I said, this works on any iterable, so here we could also use a tuple. But note that the result is a list again!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e70ad15",
   "metadata": {},
   "source": [
    "##### example 3.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "02970499",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 9, 5, 3, 1]\n",
      "[{'name': 'Max', 'age': 6}, {'name': 'Ben', 'age': 9}, {'name': 'Lisa', 'age': 20}]\n"
     ]
    }
   ],
   "source": [
    "data = (3, 5, 1, 10, 9)\n",
    "sorted_data = sorted(data, reverse=True) # [10, 9, 5, 3, 1]\n",
    "print(sorted_data)\n",
    "\n",
    "#sort age, ascending\n",
    "data = [{\"name\": \"Max\", \"age\": 6}, \n",
    "        {\"name\": \"Lisa\", \"age\": 20}, \n",
    "        {\"name\": \"Ben\", \"age\": 9}\n",
    "        ]\n",
    "sorted_data = sorted(data, key=lambda x: x[\"age\"])\n",
    "print(sorted_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44895600",
   "metadata": {},
   "source": [
    "# 4) Store unique values with Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b8f6618",
   "metadata": {},
   "source": [
    "#### If we have a list with multiple values and need to have only unique values, a nice trick is to convert our list to a set. A Set is an unordered collection data type that has no duplicate elements, so in this case it removes all the duplicates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "4ec3ea76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7}\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3,4,5,6,7,7,7]\n",
    "my_set = set(my_list) # removes duplicates\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "758f62cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#create a set right away with curly braces\n",
    "primes = {2,3,5,7,11,13,17,19}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77ea5a03",
   "metadata": {},
   "source": [
    "# 5) Save Memory With Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e4475a",
   "metadata": {},
   "source": [
    "#### A generator computes our elements lazily, i.e., it produces only one item at a time and only when asked for it. If we calculate the sum over this generator, we see that we get the same correct result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "54646b08",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "49995000\n",
      "87616 bytes\n",
      "49995000\n",
      "112 bytes\n"
     ]
    }
   ],
   "source": [
    "import sys \n",
    "# list comprehension []\n",
    "my_list = [i for i in range(10000)]\n",
    "print(sum(my_list)) # 49995000\n",
    "print(sys.getsizeof(my_list), 'bytes') # 87616 bytes\n",
    "\n",
    "# generator comprehension ()\n",
    "my_gen = (i for i in range(10000))\n",
    "print(sum(my_gen)) # 49995000\n",
    "print(sys.getsizeof(my_gen), 'bytes') # 112 bytes\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "909fceb5",
   "metadata": {},
   "source": [
    "# 6) Define default values in Dictionaries with .get() and .setdefault(), instead of using dict['key'] to avoid keyerror, if the key does not exist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a42ee32",
   "metadata": {},
   "source": [
    "#### use the .get() method on the dictionary to return the value for the key, but it will not raise a KeyError if the key is not available. Instead it returns the default value that we specified, or None if we didn't specify it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c6e53f0",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_dict = {'item': 'football', 'price': 10.00}\n",
    "count = my_dict['count'] # KeyError!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f40ba08f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "# better:\n",
    "count = my_dict.get('count', 0) # optional default value\n",
    "print(count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6b5ceebc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "{'item': 'football', 'price': 10.0, 'count': 0}\n"
     ]
    }
   ],
   "source": [
    "#If we want to ask our dictionary for the count and we also want to update the dictionary and put the count into \n",
    "#the dictionary if it's not available, we can use the .setdefault()\n",
    "count = my_dict.setdefault('count', 0)\n",
    "print(count) # 0\n",
    "print(my_dict) # {'item': 'football', 'price': 10.00, 'count': 0}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd7ef5ac",
   "metadata": {},
   "source": [
    "# 7) Count hashable objects with collections.Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1169f35e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({9: 6, 10: 3, 5: 2, 2: 1})\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "#count the number of elements in a list\n",
    "from collections import Counter\n",
    "\n",
    "my_list = [10, 10, 10, 5, 5, 2, 9, 9, 9, 9, 9, 9]\n",
    "counter = Counter(my_list)\n",
    "\n",
    "print(counter) # Counter({9: 6, 10: 3, 5: 2, 2: 1})\n",
    "print(counter[10]) # 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74d8696e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "my_list = [10, 10, 10, 5, 5, 2, 9, 9, 9, 9, 9, 9]\n",
    "counter = Counter(my_list)\n",
    "\n",
    "most_common = counter.most_common(2)\n",
    "print(most_common) # [(9, 6), (10, 3)]\n",
    "print(most_common[0]) # (9, 6)\n",
    "print(most_common[0][0]) # 9"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c1c8492",
   "metadata": {},
   "source": [
    "# 8) Format Strings with f-Strings (Python 3.6+)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a937818",
   "metadata": {},
   "source": [
    "#### best way to format a string. use {} around the string variables, and no more '' is needed around strings apart from the ones at the beginning or at the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "03ce9051",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Alex\n",
      "10 squared is 100\n"
     ]
    }
   ],
   "source": [
    "\n",
    "name = \"Alex\"\n",
    "my_string = f\"Hello {name}\"\n",
    "print(my_string) # Hello Alex\n",
    "\n",
    "i = 10\n",
    "print(f\"{i} squared is {i*i}\") # 10 squared is 100"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "301699c0",
   "metadata": {},
   "source": [
    "# 9) Concatenate Strings with .join()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7d6c978c",
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_strings = [\"Hello\", \"my\", \"friend\"]\n",
    "\n",
    "# BAD:\n",
    "my_string = \"\"\n",
    "for i in list_of_strings:\n",
    "    my_string += i + \" \" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "48e4c34d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello my friend\n",
      "Hello_my_friend\n"
     ]
    }
   ],
   "source": [
    "# GOOD:\n",
    "list_of_strings = [\"Hello\", \"my\", \"friend\"]\n",
    "my_string = \" \".join(list_of_strings)#space as separator\n",
    "print(my_string)\n",
    "my_string = \"_\".join(list_of_strings)#space as separator\n",
    "print(my_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9071547a",
   "metadata": {},
   "source": [
    "# 10) Merge dictionaries with the double asterisk syntax ** (Python 3.5+)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0d02a8f",
   "metadata": {},
   "source": [
    "#### This syntax is new since Python 3.5. If we have two dictionaries and want to merge them, we can use curly braces and double asterisks for both dictionaries. So here dictionary 1 has a name and an age, and dictionary 2 also has the name and then the city. After merging with this concise syntax our final dictionary has all 3 keys in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0f4aaa95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Alex', 'age': 25, 'city': 'New York'}\n"
     ]
    }
   ],
   "source": [
    "d1 = {'name': 'Alex', 'age': 25}\n",
    "d2 = {'name': 'Alex', 'city': 'New York'}\n",
    "merged_dict = {**d1, **d2}\n",
    "print(merged_dict) # {'name': 'Alex', 'age': 25, 'city': 'New York'}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "135f11af",
   "metadata": {},
   "source": [
    "# 11) Simplify if-statements with if x in list instead of checking each item separately"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "86b79c47",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red is main color\n"
     ]
    }
   ],
   "source": [
    "colors = [\"red\", \"green\", \"blue\"]\n",
    "\n",
    "c = \"red\"\n",
    "\n",
    "# realy really bat cumbersome and error-prone\n",
    "if c == \"red\" or c == \"green\" or c == \"blue\":\n",
    "    print(f'{c} is main color')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7fff580d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pink is not main color\n"
     ]
    }
   ],
   "source": [
    "#better\n",
    "c = \"pink\"\n",
    "if c in colors:\n",
    "    print(f'{c} is main color')\n",
    "else:\n",
    "    print (f'{c} is not main color')"
   ]
  }
 ],
 "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
}