general_tips.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TABLE OF CONTENTS:<a id='toc'></a>\n",
    "\n",
    "These tips are focused on general Python tips I think are good to know.\n",
    "\n",
    "Please go through official documentation if you want more thorough examples.\n",
    "\n",
    "<b>Topics:</b>\n",
    " - <b>[Additional Operators](#op)</b>\n",
    " - <b>[Global](#global)</b>\n",
    " - <b>[Comparisons](#compare)</b>\n",
    " - <b>[Enumerate](#enum)</b>\n",
    " - <b>[Comprehension](#comp)</b>\n",
    "     - [List](#list)\n",
    "     - [Set](#set)\n",
    "     - [Dict](#dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Uncomment if you want to use inline pythontutor\n",
    "\n",
    "# from IPython.display import IFrame\n",
    "\n",
    "# IFrame('http://www.pythontutor.com/visualize.html#mode=display', height=1500, width=750)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional Operators<a id=\"op\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Operators besides you typical `+`, `-`, `/`, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`~`     Inversion, is the bitwise complement operator in python which essentially calculates `-x - 1`\n",
    "\n",
    "`=`\t    Assign value of right side of expression to left side operand\t`x = y + z`\n",
    "\n",
    "`+=`\tAdd AND: Add right side operand with left side operand and then assign to left operand\t`a+=b`     `a=a+b`\n",
    "\n",
    "`-=`\tSubtract AND: Subtract right operand from left operand and then assign to left operand\t`a-=b`       `a=a-b`\n",
    "\n",
    "`*=`\tMultiply AND: Multiply right operand with left operand and then assign to left operand\t`a*=b`       `a=a*b`\n",
    "\n",
    "`/=`\tDivide AND: Divide left operand with right operand and then assign to left operand\t`a/=b`         `a=a/b`\n",
    "\n",
    "`%=`\tModulus AND: Takes modulus using left and right operands and assign result to left operand\t`a%=b`   `a=a%b`\n",
    "\n",
    "`//=`\tDivide(floor) AND: Divide left operand with right operand and then assign the value(floor) to left operand `a//=b`       `a=a//b`\n",
    "\n",
    "`**=`\tExponent AND: Calculate exponent(raise power) value using operands and assign value to left operand\t`a**=b`    `a=a**b`\n",
    "\n",
    "`&=`\tPerforms Bitwise AND on operands and assign value to left operand\t`a&=b`     `a=a&b`\n",
    "\n",
    "`|=`\tPerforms Bitwise OR on operands and assign value to left operand\t`a|=b`         `a=a|b`\n",
    "\n",
    "`^=`\tPerforms Bitwise xOR on operands and assign value to left operand\t`a^=b`       `a=a^b`\n",
    "\n",
    "`>>=`\tPerforms Bitwise right shift on operands and assign value to left operand\t`a>>=b`     `a=a>>b`\n",
    "\n",
    "`<<=`\tPerforms Bitwise left shift on operands and assign value to left operand\t`a <<= b`                    `a= a << b`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Or assignment</b>\n",
    "\n",
    "Assigning a variable based on another variable's assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "var = None\n",
    "b = None or var\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "var = 5\n",
    "b = None or var\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Global<a id=\"global\"></a>\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Global lets you access global variables. In this example the global variable `c` is outside of the functions scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# c = 1\n",
    "\n",
    "# def add():\n",
    "#     c = c + 2\n",
    "#     print(c)\n",
    "\n",
    "# add()\n",
    "\n",
    "# # UnboundLocalError: local variable 'c' referenced before assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "c = 1\n",
    "\n",
    "def add():\n",
    "    global c\n",
    "    c = c + 2\n",
    "    print(c)\n",
    "\n",
    "add()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparisons<a id=\"compare\"></a>\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Max<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "# Find the max of an array/variables/values etc.\n",
    "\n",
    "print(max(5, 2))\n",
    "\n",
    "print(max([10,11,12,13]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Min<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# Find the min of an array/variables/values etc.\n",
    "\n",
    "print(min(5, 2))\n",
    "\n",
    "print(min([10,11,12,13]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>float(\"inf\")/float(\"-inf\")<b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Setting a value to infinity or -infinity lets you have an easy comparion\n",
    "\n",
    "print(float(\"inf\") > 309840)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(float(\"-inf\") < -930984)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Enumerate<a id=\"enum\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "This lets you take the element's index and use it as a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 : apple\n",
      "1 : blueberry\n",
      "2 : lemon\n"
     ]
    }
   ],
   "source": [
    "pies = [\"apple\", \"blueberry\", \"lemon\"]\n",
    "\n",
    "for num, i in enumerate(pies):\n",
    "    print(num, \":\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pie1 : apple\n",
      "pie2 : blueberry\n",
      "pie3 : lemon\n"
     ]
    }
   ],
   "source": [
    "# For dictionaris this is what it would look like.\n",
    "\n",
    "pies = {\"pie1\":\"apple\", \"pie2\":\"blueberry\", \"pie3\":\"lemon\"}\n",
    "\n",
    "for key, value in pies.items():\n",
    "    print(key, \":\", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comprehensions<a id=\"comp\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Are a quicker way to create lists, dicts and sets, they act like for loops and can take conditions as well as if else statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>List comprehension</b><a id='list'></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n"
     ]
    }
   ],
   "source": [
    "# Manual way to make a list\n",
    "\n",
    "list_1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "list_2 = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n",
    "\n",
    "print(list_1)\n",
    "print(list_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n"
     ]
    }
   ],
   "source": [
    "# Using list()\n",
    "\n",
    "list_1_with_list = list(range(1, 11))\n",
    "list_2_with_list = list(range(11, 21))\n",
    "\n",
    "print(list_1_with_list)\n",
    "print(list_2_with_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "[11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\n"
     ]
    }
   ],
   "source": [
    "# List comprehension autogenerates the list, they function closely to for loops.\n",
    "\n",
    "list_1_with_comp = [x for x in range(1, 11)]\n",
    "list_2_with_comp = [x for x in range(11, 21)]\n",
    "\n",
    "print(list_1_with_comp)\n",
    "print(list_2_with_comp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Works with functions.\n",
    "\n",
    "def addition(x):\n",
    "    return x + x\n",
    "\n",
    "[addition(x) for x in range(0, 3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 6, 5, 8, 7, 10, 9, 12, 11]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Also works with conditions\n",
    "# The % is modulus which gives you the remainder after division.\n",
    "\n",
    "# If an number is even add 1 if it's odd add 3\n",
    "\n",
    "[x + 1 if x%2 ==0 else x + 3 for x in range(1, 11)] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 7, 9, 11]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Without an else statement if goes at the end of the statement.\n",
    "\n",
    "[x + 1 for x in range(1, 11) if x%2 ==0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "0 1\n",
      "0 2\n",
      "0 3\n",
      "0 4\n",
      "1 0\n",
      "1 1\n",
      "1 2\n",
      "1 3\n",
      "1 4\n",
      "2 0\n",
      "2 1\n",
      "2 2\n",
      "2 3\n",
      "2 4\n"
     ]
    }
   ],
   "source": [
    "# Nested loop example to show how they function like for loops.\n",
    "\n",
    "for a in range(0, 3):\n",
    "    for b in range(0, 5):\n",
    "        print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 0],\n",
       " [0, 1],\n",
       " [0, 2],\n",
       " [0, 3],\n",
       " [0, 4],\n",
       " [1, 0],\n",
       " [1, 1],\n",
       " [1, 2],\n",
       " [1, 3],\n",
       " [1, 4],\n",
       " [2, 0],\n",
       " [2, 1],\n",
       " [2, 2],\n",
       " [2, 3],\n",
       " [2, 4]]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List comp also works as a nested loop.\n",
    "\n",
    "[[a, b] for a in range(0, 3) for b in range(0, 5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Set comprehension</b><a id='set'></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set comprehension is same format as list comprehension but uses curly brackets.\n",
    "\n",
    "set_1_with_comp = {x for x in range(1, 11)}\n",
    "set_2_with_comp = {x for x in range(11, 21)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n",
      "{11, 12, 13, 14, 15, 16, 17, 18, 19, 20}\n"
     ]
    }
   ],
   "source": [
    "print(set_1_with_comp)\n",
    "print(set_2_with_comp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Dict comprehension</b><a id='dict'></a>\n",
    "\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Examples from: http://cmdlinetips.com/2018/01/5-examples-using-dict-comprehension/ (More samples there as well)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'1': 1, '2': 2, '3': 3, '4': 4, '5': 5}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dict comprehension to create dict with numbers as values\n",
    "{str(i):i for i in [1,2,3,4,5]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apple': 5, 'mango': 5, 'banana': 6, 'cherry': 6}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create list of fruits\n",
    "fruits = [\"apple\", \"mango\", \"banana\", \"cherry\"]\n",
    "\n",
    "# dict comprehension to create dict with fruit name as keys\n",
    "{f:len(f) for f in fruits}"
   ]
  }
 ],
 "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": 2
}