PYCS.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Interactive Python Cheatsheet**<br>in Jupiter notebook format\n",
    "\n",
    "You can download [IPYCS Jupiter notebook](https://github.com/amaargiru/ipycs/blob/main/PYCS.ipynb) with code cells that allows you to edit and write new code, with full syntax highlighting. The results that are returned from this computation are then displayed in the notebook as the cell’s output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data structures\n",
    "\n",
    "### List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 50] [30, 40, 60]\n",
      "Add: [10, 20, 50, 30, 40, 60]\n",
      "Reverse: [60, 40, 30, 50, 20, 10], [60, 40, 30, 50, 20, 10]\n",
      "Sort: [10, 20, 30, 40, 50, 60], [10, 20, 30, 40, 50, 60]\n",
      "['A', ' ', 'w', 'h', 'o', 'l', 'e', ' ', 's', 't', 'r', 'i', 'n', 'g']\n",
      "['A', 'whole', 'string']\n",
      "2\n",
      "['A', ' ', 'h', 'o', 'l', 'e', ' ', 's', 't', 'i', 'n', 'g'] r\n"
     ]
    }
   ],
   "source": [
    "a = []  # Empty list\n",
    "\n",
    "a: list[int] = [10, 20]\n",
    "b: list[int] = [30, 40]\n",
    "a.append(50)  # Add item\n",
    "b.insert(2, 60)  # Inserts item at index\n",
    "print(a, b)\n",
    "\n",
    "a += b\n",
    "print(f\"Add: {a}\")\n",
    "\n",
    "b = list(reversed(a))  # reversed() returns reversed iterator, not list\n",
    "a.reverse()\n",
    "print(f\"Reverse: {a}, {b}\")\n",
    "\n",
    "b = sorted(a)  # Returns a new sorted list\n",
    "a.sort()  # Modifies the list in-place and has no return value\n",
    "print(f\"Sort: {a}, {b}\")\n",
    "\n",
    "s: str = \"A whole string\"\n",
    "list_of_chars: list = list(s)\n",
    "print(list_of_chars)\n",
    "list_of_words: list = s.split()\n",
    "print(list_of_words)\n",
    "\n",
    "i: int = list_of_chars.index(\"w\")  # Returns index of the first occurrence or raises ValueError\n",
    "print(i)\n",
    "list_of_chars.remove(\"w\")  # Removes first occurrence of the item or raises ValueError\n",
    "e = list_of_chars.pop(9)  # Removes and returns item at index or from the end. pop() removes and returns the last value from the list\n",
    "print(list_of_chars, e)\n",
    "a.clear()  # Removes all items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Italy': 'Pizza', 'US': 'Hot-Dog', 'China': 'Dim Sum'}\n",
      "dict_keys(['Italy', 'US', 'China'])\n",
      "dict_values(['Pizza', 'Hot-Dog', 'Dim Sum'])\n",
      "dict_items([('Italy', 'Pizza'), ('US', 'Hot-Dog'), ('China', 'Dim Sum')])\n",
      "Mapping: Pizza\n",
      "Replace item: {'Italy': 'Pizza', 'US': 'Hot-Dog', 'China': 'Dumplings'}\n",
      "Read item: Dumplings\n",
      "Dictionary key doesn't exist\n",
      "{'Italy': 'Pizza', 'China': 'Dumplings'}\n",
      "{'US': 'Hot-Dog', 'China': 'Dumplings'}\n"
     ]
    }
   ],
   "source": [
    "d = {}  # Empty dictionary\n",
    "\n",
    "d: dict[str, str] = {\"Italy\": \"Pizza\", \"US\": \"Hot-Dog\", \"China\": \"Dim Sum\"}  # Creates a dictionary\n",
    "\n",
    "k = [\"Italy\", \"US\", \"China\"]  # Creates a dictionary from two collections\n",
    "v = [\"Pizza\", \"Hot-Dog\", \"Dim Sum\"]\n",
    "d = dict(zip(k, v))\n",
    "\n",
    "k = d.keys()  # Collection of keys that reflects changes\n",
    "v = d.values()  # Collection of values that reflects changes\n",
    "k_v = d.items()  # Collection of key-value tuples that reflects changes\n",
    "\n",
    "print(d)\n",
    "print(k)\n",
    "print(v)\n",
    "print(k_v)\n",
    "\n",
    "print(f\"Mapping: {k.mapping['Italy']}\")\n",
    "\n",
    "d.update({\"China\": \"Dumplings\"})  # Adds item or replace one with matching keys\n",
    "print(f\"Replace item: {d}\")\n",
    "\n",
    "c = d[\"China\"]  # Read value\n",
    "print(f\"Read item: {c}\")\n",
    "\n",
    "try:\n",
    "    v = d.pop(\"Spain\")  # Removes item or raises KeyError\n",
    "except KeyError:\n",
    "    print(\"Dictionary key doesn't exist\")\n",
    "\n",
    "b = {k: v for k, v in d.items() if \"a\" in k}  # Returns a dictionary, filtered by keys\n",
    "print(b)\n",
    "c = {k: v for k, v in d.items() if len(v) >= 7}  # Returns a dictionary, filtered by values\n",
    "print(c)\n",
    "\n",
    "d.clear() # Removes all items"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### defaultdict\n",
    "\n",
    "The *defaultdict* will create any items that you try to access (provided of course they do not exist yet) without throws a KeyError."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "dd = defaultdict(int)  # defaultdict\n",
    "print(dd[10])  # print int(), thus 0\n",
    "\n",
    "dd = {}  # \"Regular\" dictionary\n",
    "# print(dd[10])  # throws KeyError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counter\n",
    "\n",
    "A Counter is a dict subclass for counting hashable objects, it is a collection where elements are stored as dictionary keys and their counts are stored as dictionary values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'white': 3, 'black': 2, 'red': 1, 'blue': 1})\n",
      "After shopping: Counter({'white': 3, 'blue': 2, 'black': 2, 'red': 1})\n",
      "defaultdict(<class 'int'>, {'red': 1, 'white': 3, 'blue': 2, 'black': 2})\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "shirts_colors = [\"red\", \"white\", \"blue\", \"white\", \"white\", \"black\", \"black\"]\n",
    "c = Counter(shirts_colors)\n",
    "print(c)\n",
    "\n",
    "c[\"blue\"] += 1\n",
    "print(f\"After shopping: {c}\")\n",
    "\n",
    "# We can explain how Counter() works with defaultdict():\n",
    "from collections import defaultdict\n",
    "\n",
    "d = defaultdict(int)\n",
    "for shirt in shirts_colors:\n",
    "    d[shirt] += 1\n",
    "d[\"blue\"] += 1\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ottawa', 'Los Angeles', 'Sydney', 'New-York'} {'New-York', 'Salt Lake City', 'Los Angeles', 'Seattle', 'Chicago'}\n",
      "{'Salt Lake City', 'New-York', 'Chicago', 'Sydney', 'Ottawa', 'Los Angeles', 'Seattle'}\n",
      "{'Los Angeles', 'New-York'}\n",
      "{'Ottawa', 'Sydney'}\n",
      "{'Sydney', 'Salt Lake City', 'Ottawa', 'Seattle', 'Chicago'}\n",
      "True False\n"
     ]
    }
   ],
   "source": [
    "big_cities: set[\"str\"] = {\"New-York\", \"Los Angeles\", \"Ottawa\"}\n",
    "american_cities: set[\"str\"] = {\"Chicago\", \"New-York\", \"Los Angeles\"}\n",
    "\n",
    "big_cities |= {\"Sydney\"}  # Add item (or you can use add())\n",
    "american_cities |= {\"Salt Lake City\", \"Seattle\"}  # Add set (or you can use update())\n",
    "\n",
    "print(big_cities, american_cities)\n",
    "\n",
    "union_cities: set[\"str\"] = big_cities | american_cities  # Or union()\n",
    "intersected_cities: set[\"str\"] = big_cities & american_cities  # Or intersection()\n",
    "dif_cities: set[\"str\"] = big_cities - american_cities  # Or difference()\n",
    "symdif_cities: set[\"str\"] = big_cities ^ american_cities  # Or symmetric_difference()\n",
    "\n",
    "issub: bool = big_cities <= union_cities  # Or issubset()\n",
    "issuper: bool = american_cities >= dif_cities  # Or issuperset()\n",
    "\n",
    "print(union_cities)\n",
    "print(intersected_cities)\n",
    "print(dif_cities)\n",
    "print(symdif_cities)\n",
    "\n",
    "print(issub, issuper)\n",
    "\n",
    "big_cities.add(\"London\")  # Add items\n",
    "\n",
    "big_cities.remove(\"Ottawa\")  # Removes an item from the set if it is present or raises KeyError\n",
    "big_cities.discard(\"Los Angeles\")  # Remove an item from the set if it is present without raising KeyError\n",
    "big_cities.pop()  # Remove and return a random item from the set or raises KeyError\n",
    "big_cities.clear()  # Removes all items from the set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frozen Set\n",
    "\n",
    "Frozen set is just an immutable and hashable version of a set object. Frozen set can be used as key in Dictionary or as element of another set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = frozenset({\"New-York\", \"Los Angeles\", \"Ottawa\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple  \n",
    "Tuple is an immutable and hashable list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3) ('Boson', 'Higgs', 1.56e-22)\n"
     ]
    }
   ],
   "source": [
    "a = (2, 3)\n",
    "b = (\"Boson\", \"Higgs\", 1.56e-22)\n",
    "\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Named Tuple\n",
    "Subclass of tuple with named elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rectangle(length=1, width=2)\n",
      "1\n",
      "2\n",
      "('length', 'width')\n"
     ]
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "rectangle = namedtuple('rectangle', 'length width')\n",
    "r = rectangle(length = 1, width = 2)\n",
    "\n",
    "print(r)\n",
    "print(r.length)\n",
    "print(r.width)\n",
    "print(r._fields)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Currency.us_dollar\n",
      "Currency.us_dollar\n",
      "Currency.us_dollar\n",
      "us_dollar\n",
      "2\n",
      "[<Currency.euro: 1>, <Currency.us_dollar: 2>, <Currency.yuan: 3>] \n",
      " ['euro', 'us_dollar', 'yuan'] \n",
      " [1, 2, 3] \n",
      " Currency.us_dollar\n"
     ]
    }
   ],
   "source": [
    "from enum import Enum, auto\n",
    "import random\n",
    "\n",
    "class Currency(Enum):\n",
    "    euro = 1\n",
    "    us_dollar = 2\n",
    "    yuan = auto()\n",
    "\n",
    "# If there are no numeric values before auto(), it returns 1, otherwise it returns an increment of the last numeric value\n",
    "\n",
    "local_currency = Currency.us_dollar  # Returns a member\n",
    "print(local_currency)\n",
    "\n",
    "local_currency = Currency[\"us_dollar\"]  # Returns a member or raises KeyError\n",
    "print(local_currency)\n",
    "\n",
    "local_currency = Currency(2)  # Returns a member or raises ValueError\n",
    "print(local_currency)\n",
    "\n",
    "print(local_currency.name)\n",
    "print(local_currency.value)\n",
    "\n",
    "list_of_members = list(Currency)\n",
    "member_names    = [e.name for e in Currency]\n",
    "member_values   = [e.value for e in Currency]\n",
    "random_member   = random.choice(list(Currency))\n",
    "\n",
    "print(list_of_members, \"\\n\",\n",
    "      member_names, \"\\n\",\n",
    "      member_values, \"\\n\",\n",
    "      random_member)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To exclusive: 0 1 2 3 4 5 6 7 8 9 10 \n",
      "From inclusive to exclusive: 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \n",
      "From inclusive to exclusive with step: 20 18 16 14 12 10 \n",
      "From = 20\n",
      "To = 9\n"
     ]
    }
   ],
   "source": [
    "\n",
    "r1: range = range(11)  # Creates a sequence of numbers from 0 to 10\n",
    "r2: range = range(5, 21) # Creates a sequence of numbers from 5 to 20\n",
    "r3: range = range(20, 9, -2)  # Creates a sequence of numbers from 20 to 10 with step 2\n",
    "\n",
    "print(\"To exclusive: \", end=\"\")\n",
    "for i in r1:\n",
    "  print(f\"{i} \", end=\"\")\n",
    "\n",
    "print(\"\\nFrom inclusive to exclusive: \", end=\"\")\n",
    "for i in r2:\n",
    "  print(f\"{i} \", end=\"\")\n",
    "\n",
    "print(\"\\nFrom inclusive to exclusive with step: \", end=\"\")\n",
    "for i in r3:\n",
    "  print(f\"{i} \", end=\"\")\n",
    "\n",
    "print(f\"\\nFrom = {r3.start}\")\n",
    "print(f\"To = {r3.stop}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataclass  \n",
    "Decorator that automatically generates init(), repr() and eq() special methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transaction(value=1000000, issuer='Deutsche Bank', dt=datetime.datetime(2022, 1, 1, 12, 0))\n",
      "Transaction(value=1000, issuer='Default Bank', dt=datetime.datetime(2022, 7, 18, 15, 12, 0, 119907))\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import dataclass\n",
    "from decimal import *\n",
    "from datetime import datetime\n",
    "\n",
    "@dataclass\n",
    "class Transaction:\n",
    "    value: Decimal\n",
    "    issuer: str = \"Default Bank\"\n",
    "    dt: datetime = datetime.now()\n",
    "\n",
    "t1 = Transaction(value=1000_000, issuer=\"Deutsche Bank\", dt = datetime(2022, 1, 1, 12))\n",
    "t2 = Transaction(1000)\n",
    "\n",
    "print(t1)\n",
    "print(t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Objects can be made immutable with *frozen=True*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass(frozen=True)\n",
    "class User:\n",
    "    name: str\n",
    "    account: int\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deque\n",
    "\n",
    "A thread-safe list with efficient appends and pops from either side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque([-2, -1, 0, 1, 2, 3, 4, 5, 6, 7], maxlen=1000)\n",
      "7 -2\n",
      "deque([-1, 0, 1, 2, 3, 4, 5, 6], maxlen=1000)\n"
     ]
    }
   ],
   "source": [
    "from collections import deque\n",
    "d = deque([1, 2, 3, 4], maxlen=1000)\n",
    "\n",
    "d.append(5)  # Add element to the right side of the deque\n",
    "d.appendleft(0)  # Add element to the left side of the deque by appending elements from iterable\n",
    "\n",
    "d.extend([6, 7])  # Extend the right side of the deque\n",
    "d.extendleft([-1, -2])  # Extend the left side of the deque\n",
    "print(d)\n",
    "\n",
    "a = d.pop()  # Remove and return an element from the right side of the deque. Can raise an IndexError\n",
    "b = d.popleft()  # Remove and return an element from the left side of the deque. Can raise an IndexError\n",
    "print(a, b)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Queue\n",
    "\n",
    "The queue module implements multi-producer, multi-consumer FIFO queues. It is especially useful in threaded programming when information must be exchanged safely between multiple threads. For LIFO queue use LifoQueue. For a priority queue use PriorityQueue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deque(['eat', 'sleep', 'code', 'repeat'])\n",
      "eat sleep code deque(['repeat'])\n"
     ]
    }
   ],
   "source": [
    "from queue import Queue\n",
    "q = Queue(maxsize=1000)\n",
    "\n",
    "q.put(\"eat\", block=True, timeout=10)  # Put an element to the queue with 10 seconds timeuot, block if necessary until a free slot is available\n",
    "q.put(\"sleep\")  # Default values block=True, timeout=None\n",
    "q.put(\"code\")\n",
    "q.put_nowait(\"repeat\")  # Equivalent to put(\"repeat\", block=False). Put an element on the queue if a free slot is immediately available, else raise the queue.Full exception\n",
    "print(q.queue)\n",
    "\n",
    "a = q.get(block=True, timeout=10)  # Remove and return an item from the queue\n",
    "b = q.get()  # Default values block=True, timeout=None\n",
    "c = q.get_nowait()  # Equivalent to get(False)\n",
    "print(a, b, c, q.queue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array  \n",
    "Object type that can only hold numbers of a predefined type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array('l', [1, 2, 3, -4])\n",
      "49\n",
      "b'1234567890'\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "from array import array\n",
    "\n",
    "a1 = array(\"l\", [1, 2, 3, -4])  # Array from collection of numbers\n",
    "a2 = array(\"b\", b\"1234567890\")  # Array from bytes object\n",
    "b = bytes(a2)\n",
    "\n",
    "print(a1)\n",
    "print(a2[0])\n",
    "print(b)\n",
    "\n",
    "print(a1.index(-4))  # Returns an index of a member or raises ValueError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generator\n",
    "\n",
    "Any function that contains a yield statement returns a generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "110\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "def count(start, step):\n",
    "    current = start\n",
    "    while True:\n",
    "        yield current\n",
    "        current += step\n",
    "\n",
    "c = count(100, 10)\n",
    "\n",
    "print(next(c))\n",
    "print(next(c))\n",
    "print(next(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Joined string: Follow the white rabbit\n",
      "is_contains = True, is_startswith = True, is_endswith = True\n",
      "After replace: Follow the white sheep\n",
      "Start index of 'rabbit' is -1, start index of 'sheep' is 17\n",
      "Translate string: xyz\n",
      "Reverse string: tibbar etihw eht wolloF\n"
     ]
    }
   ],
   "source": [
    "se: str = \"\"  # Empty string\n",
    "si: str = str(12345)  # Creates the string from int\n",
    "sj: str = \" \".join([\"Follow\", \"the\", \"white\", \"rabbit\"])  # Joins items using string as a separator\n",
    "print(f\"Joined string: {sj}\")\n",
    "\n",
    "is_contains: bool = \"rabbit\" in sj  # Checks if string contains a substring\n",
    "is_startswith = sj.startswith(\"Foll\")\n",
    "is_endswith = sj.endswith(\"bbit\")\n",
    "print(f\"is_contains = {is_contains}, is_startswith = {is_startswith}, is_endswith = {is_endswith}\")\n",
    "\n",
    "sr: str  = sj.replace(\"rabbit\", \"sheep\")  # Replaces substrings. Also you can use times:  sr: str  = sj.replace(\"rabbit\", \"sheep\", times)\n",
    "print(f\"After replace: {sr}\")\n",
    "\n",
    "i1 = sr.find(\"rabbit\")  # Returns start index of the first match or -1. Also rfind()\n",
    "i2 = sr.index(\"sheep\")  #  Returns start index of the first match or raises ValueError. Also rindex()   \n",
    "print(f\"Start index of 'rabbit' is {i1}, start index of 'sheep' is {i2}\")\n",
    "\n",
    "d = str.maketrans({\"a\" : \"x\", \"b\" : \"y\", \"c\" : \"z\"})\n",
    "st  = \"abc\".translate(d)\n",
    "print(f\"Translate string: {st}\")\n",
    "\n",
    "sr = sj[::-1]  # Reverse (Explanation: stackoverflow.com/questions/931092/reverse-a-string-in-python)\n",
    "print(f\"Reverse string: {sr}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### lower(), upper(), capitalize() and title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "camelcase string\n",
      "CAMELCASE STRING\n",
      "Camelcase string\n",
      "Camelcase String\n"
     ]
    }
   ],
   "source": [
    "s: str = \"camelCase string\"\n",
    "\n",
    "print(s.lower())\n",
    "print(s.upper())\n",
    "print(s.capitalize())\n",
    "print(s.title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Property Methods\n",
    "\n",
    "```text\n",
    "+---------------+----------+----------+----------+----------+----------+\n",
    "|               | [ !#$%…] | [a-zA-Z] |  [½¼¾]   |  [²³¹]   |  [0-9]   |\n",
    "+---------------+----------+----------+----------+----------+----------+\n",
    "| isprintable() |   yes    |   yes    |   yes    |   yes    |   yes    |\n",
    "| isalnum()     |          |   yes    |   yes    |   yes    |   yes    |\n",
    "| isnumeric()   |          |          |   yes    |   yes    |   yes    |\n",
    "| isdigit()     |          |          |          |   yes    |   yes    |\n",
    "| isdecimal()   |          |          |          |          |   yes    |\n",
    "+---------------+----------+----------+----------+----------+----------+\n",
    "```\n",
    "\n",
    "*isspace()* checks for *[ \\t\\n\\r\\f\\v\\x1c-\\x1f\\x85…]*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "~~##A big blahblahblah##~~\n",
      "A big blahblahblah\n",
      "big blahblahblah\n",
      "big \n"
     ]
    }
   ],
   "source": [
    "s: str = \"  ~~##A big blahblahblah##~~  \"\n",
    "\n",
    "s = s.strip()  # Strips all whitespace characters from both ends\n",
    "print(s)\n",
    "\n",
    "s = s.strip(\"~#\")  # Strips all passed characters from both ends\n",
    "print(s)\n",
    "\n",
    "s = s.lstrip(\" A\")  # Strips all passed characters from left end\n",
    "print(s)\n",
    "\n",
    "s = s.rstrip(\"habl\")  # Strips all passed characters from right end\n",
    "print(s)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Follow', 'the', 'white', 'rabbit,', 'Neo']\n",
      "['Follow the white rabbit', 'Neo']\n",
      "['Beware the Jabberwock, my son!', ' The jaws that bite, the claws that catch!']\n",
      "['Beware', 'the', 'Jabberwock, my son!\\n The jaws that bite, the claws that catch!'] ['Beware the Jabberwock, my son!\\n The jaws that bite, the claws', 'that', 'catch!']\n"
     ]
    }
   ],
   "source": [
    "s1: str = \"Follow the white rabbit, Neo\"\n",
    "\n",
    "c1 = s1.split()  # Splits on one or more whitespace characters\n",
    "print(c1)\n",
    "\n",
    "c2 = s1.split(sep=\", \", maxsplit=1)  # Splits on \"sep\" str at most \"maxsplit\" times\n",
    "print(c2)\n",
    "\n",
    "s2: str = \"Beware the Jabberwock, my son!\\n The jaws that bite, the claws that catch!\"\n",
    "\n",
    "c3 = s2.splitlines(keepends=False)  # On [\\n\\r\\f\\v\\x1c-\\x1e\\x85\\u2028\\u2029] and \\r\\n.\n",
    "print(c3)\n",
    "\n",
    "# split() vs rsplit()\n",
    "\n",
    "c4 = s2.split(maxsplit=2)\n",
    "c5 = s2.rsplit(maxsplit=2)\n",
    "\n",
    "print(c4, c5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ord(), chr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a -> 97\n",
      "b -> 98\n",
      "c -> 99\n",
      "A -> 65\n",
      "B -> 66\n",
      "C -> 67\n",
      "! -> 33\n",
      "72 -> H\n",
      "101 -> e\n",
      "108 -> l\n",
      "108 -> l\n",
      "111 -> o\n",
      "33 -> !\n"
     ]
    }
   ],
   "source": [
    "s1: str = \"abcABC!\"\n",
    "\n",
    "for ch in s1:\n",
    "    print(f\"{ch} -> {ord(ch)}\")  # Returns an integer representing the Unicode character\n",
    "\n",
    "nums = [72, 101, 108, 108, 111, 33]\n",
    "\n",
    "for num in nums:\n",
    "    print(f\"{num} -> {chr(num)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regex\n",
    "\n",
    "Argument flags=re.IGNORECASE can be used with all functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(4, 5), match='a'>\n",
      "a\n",
      "None\n",
      "['a', 'A']\n",
      "234 bcd BCD 567\n",
      "['', '', '', ' abc ABC ', '', '', '']\n",
      " abc ABC "
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "s1: str = \"123 abc ABC 456\"\n",
    "\n",
    "m1 = re.search(\"[aA]\", s1)  # Searches for first occurrence of the pattern; search() return None if it can't find a match\n",
    "print(m1)\n",
    "print(m1.group(0))\n",
    "\n",
    "m2 = re.match(\"[aA]\", s1)  # Searches at the beginning of the text; match() return None if it can't find a match\n",
    "print(m2)\n",
    "\n",
    "c1: list = re.findall(\"[aA]\", s1)  # Returns all occurrences as strings\n",
    "print(c1)\n",
    "\n",
    "def replacer(s):  # replacer() can be a function that accepts a match object and returns a string\n",
    "    return chr(ord(s[0]) + 1)  # Next symbol in alphabet\n",
    "\n",
    "s2 = re.sub(\"\\w\", replacer, s1)  # Substitutes all occurrences with 'replacer'\n",
    "print(s2)\n",
    "\n",
    "c2 = re.split(\"\\d\", s1)\n",
    "print(c2)\n",
    "\n",
    "iter = re.finditer(\"\\D\", s1)  # Returns all occurrences as match objects\n",
    "\n",
    "for ch in iter:\n",
    "    print(ch.group(0), end= \"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Match Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John Connor\n",
      " John\n",
      " ('John', 'Connor')\n",
      " 0\n",
      " 11\n",
      " (0, 11)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "\n",
    "m3 = re.match(r\"(\\w+) (\\w+)\", \"John Connor, leader of the Resistance\")\n",
    "\n",
    "s3: str = m3.group(0)  # Returns the whole match\n",
    "s4: str = m3.group(1)  # Returns part in the first bracket\n",
    "t1: tuple = m3.groups()  # Returns all bracketed parts\n",
    "start: int = m3.start()  # Returns start index of the match\n",
    "end: int = m3.end()  # Returns exclusive end index of the match\n",
    "t2: tuple[int, int] = m3.span()  # Return the 2-tuple (start, end)\n",
    "\n",
    "print (f\"{s3}\\n {s4}\\n {t1}\\n {start}\\n {end}\\n {t2}\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### JSON\n",
    "\n",
    "Human-readable text format to store and transmit data objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"1\": \"Lemon\",\n",
      "  \"2\": \"Apple\",\n",
      "  \"3\": \"Banana!\"\n",
      "}\n",
      "{'1': 'Lemon', '2': 'Apple', '3': 'Banana!'}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "d: dict = {1: \"Lemon\", 2: \"Apple\", 3: \"Banana!\"}\n",
    "\n",
    "object_as_string: str = json.dumps(d, indent=2)\n",
    "print(object_as_string)\n",
    "\n",
    "restored_object = json.loads(object_as_string)\n",
    "\n",
    "# Write object to JSON file\n",
    "with open(\"1.json\", 'w', encoding='utf-8') as file:\n",
    "    json.dump(d, file, indent=2)\n",
    "\n",
    "# Read object from JSON file\n",
    "with open(\"1.json\", encoding='utf-8') as file:\n",
    "    restored_from_file = json.load(file)\n",
    "    \n",
    "print(restored_from_file)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pickle\n",
    "\n",
    "Binary file format to store and transmit data objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'Lemon', 2: 'Apple', 3: 'Banana!'}\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "\n",
    "d: dict = {1: \"Lemon\", 2: \"Apple\", 3: \"Banana!\"}\n",
    "\n",
    "# Write object to binary file\n",
    "with open(\"1.bin\", \"wb\") as file:\n",
    "    pickle.dump(d, file)\n",
    "\n",
    "# Read object from file\n",
    "with open(\"1.bin\", \"rb\") as file:\n",
    "    restored_from_file = pickle.load(file)\n",
    "\n",
    "print(restored_from_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bytes\n",
    "\n",
    "Bytes object is an immutable sequence of single bytes. Mutable version is called bytearray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'\\x01\\x02\\x03\\x04' b'The String' b'\\xff\\xff\\xfc\\x00' b'\\xfe\\xad\\xca' b'\\n\\x0c\\x0e\\x10\\x12\\x14\\x16\\x18\\x1a\\x1c'\n",
      "[252, 0, 0, 0, 0, 1] The String 64512 fc 00 00 00 00 01\n",
      "b'\\x01\\x02\\x03\\x04'\n"
     ]
    }
   ],
   "source": [
    "\n",
    "### Encode\n",
    "b1 = bytes([1, 2, 3, 4])  # Ints must be in range from 0 to 255\n",
    "b2 = \"The String\".encode('utf-8')\n",
    "b3 = (-1024).to_bytes(4, byteorder='big', signed=True)  # byteorder=\"big\"/\"little\"/\"sys.byteorder\", signed=False/True\n",
    "b4 = bytes.fromhex('FEADCA')  # Hex pairs can be separated by spaces\n",
    "b5 = bytes(range(10,30,2))\n",
    "\n",
    "print(b1, b2, b3, b4, b5)\n",
    "\n",
    "### Decode\n",
    "c: list = list(b\"\\xfc\\x00\\x00\\x00\\x00\\x01\")  # Returns ints in range from 0 to 255\n",
    "s: str = b'The String'.decode(\"utf-8\")\n",
    "b: int = int.from_bytes(b\"\\xfc\\x00\", byteorder='big', signed=False)  # byteorder=\"big\"/\"little\"/\"sys.byteorder\", signed=False/True\n",
    "s2: str = b\"\\xfc\\x00\\x00\\x00\\x00\\x01\".hex(\" \")  # Returns a string of hexadecimal pairs, hex pairs can be separated by spaces\n",
    "\n",
    "print(c, s, b, s2)\n",
    "\n",
    "with open(\"1.bin\", \"wb\") as file:  # Write bytes to file\n",
    "    file.write(b1)\n",
    "\n",
    "with open(\"1.bin\", \"rb\") as file:  # Read bytes from file\n",
    "    b6 = file.read()\n",
    "\n",
    "print(b6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Struct\n",
    "\n",
    "Module that performs conversions between a sequence of numbers and a bytes object. System’s type sizes and byte order are used by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'\\x00\\x01\\x00\\x02\\x00\\x00\\x00\\x03\\x00\\x00\\x00\\x04'\n",
      "(1, 2, 3, 4)\n",
      "b'\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x02\\x00\\x00\\x00'\n",
      "[(1, 2), (1, 2), (1, 2), (1, 2), (1, 2)]\n"
     ]
    }
   ],
   "source": [
    "from struct import pack, unpack, iter_unpack\n",
    "\n",
    "b = pack(\">hhll\", 1, 2, 3, 4)\n",
    "print(b)\n",
    "\n",
    "t = unpack(\">hhll\", b)\n",
    "print(t)\n",
    "\n",
    "i = pack(\"ii\", 1, 2) * 5\n",
    "print(i)\n",
    "\n",
    "print(list(iter_unpack('ii', i)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datetime\n",
    "\n",
    "Module *datetime* provides *date*, *time*, *datetime* and *timedelta*. All are immutable and hashable\n",
    "\n",
    "### Constructors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1964-09-02\n",
      " 12:30:00\n",
      " 1964-09-02 10:30:00\n",
      " 8 days, 12:13:14\n"
     ]
    }
   ],
   "source": [
    "from datetime import date, time, datetime, timedelta\n",
    "\n",
    "d: date = date(year=1964, month=9, day=2)\n",
    "t: time  = time(hour=12, minute=30, second=0, microsecond=0, tzinfo=None, fold=0)\n",
    "dt: datetime = datetime(year=1964, month=9, day=2, hour=10, minute=30, second=0)\n",
    "td: timedelta = timedelta(weeks=1, days=1, hours=12, minutes=13, seconds=14)\n",
    "\n",
    "print (f\"{d}\\n {t}\\n {dt}\\n {td}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-07-18\n",
      " 2022-07-18 15:12:01.398441\n",
      " 2022-07-18 10:12:01.398441\n",
      " 2022-07-18 03:12:01.513608-07:00\n"
     ]
    }
   ],
   "source": [
    "from datetime import date, time, datetime\n",
    "import pytz\n",
    "\n",
    "d: date  = date.today()\n",
    "dt1: datetime = datetime.today()\n",
    "dt2: datetime = datetime.utcnow()\n",
    "dt3: datetime = datetime.now(pytz.timezone('US/Pacific'))\n",
    "\n",
    "print (f\"{d}\\n {dt1}\\n {dt2}\\n {dt3}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Timezone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tzutc()\n",
      " tzlocal()\n",
      " tzlocal()\n",
      " tzfile('US/Central')\n",
      " 2022-07-18 15:12:01.677577\n",
      " 2022-07-18 10:12:01.677577+00:00\n"
     ]
    }
   ],
   "source": [
    "from datetime import date, time, datetime, timedelta, tzinfo\n",
    "from dateutil.tz import UTC, tzlocal, gettz, datetime_exists, resolve_imaginary\n",
    "\n",
    "tz1: tzinfo = UTC  # UTC timezone\n",
    "\n",
    "tz2: tzinfo = tzlocal()  # Local timezone\n",
    "tz3: tzinfo = gettz()  # Local timezone\n",
    "\n",
    "tz4: tzinfo = gettz(\"America/Chicago\")  # \"Asia/Kolkata\" etc. See full list at en.wikipedia.org/wiki/List_of_tz_database_time_zones\n",
    "\n",
    "local_dt = datetime.today()\n",
    "utc_dt = local_dt.astimezone(UTC)  # Convert local datetime to UTC datetime\n",
    "\n",
    "print (f\"{tz1}\\n {tz2}\\n {tz3}\\n {tz4}\\n {local_dt}\\n {utc_dt}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encode\n",
    "\n",
    "Python uses the Unix Epoch: \"1970-01-01 00:00 UTC\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-10-04 00:05:23.555000+00:00\n",
      " 2004-10-21 17:30:00\n",
      " 0274-10-16 00:00:00\n",
      " 1970-08-20 16:33:20.010000\n",
      " 1979-07-05 10:20:00+05:00\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "from dateutil.tz import tzlocal\n",
    "\n",
    "dt1: datetime = datetime.fromisoformat(\"2021-10-04 00:05:23.555+00:00\")  # Raises ValueError\n",
    "dt2: datetime = datetime.strptime(\"21/10/04 17:30\", \"%d/%m/%y %H:%M\")   # Datetime from str, according to format (https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes)\n",
    "dt3: datetime = datetime.fromordinal(100000)  # 100000th day after 1.1.0001\n",
    "dt4: datetime = datetime.fromtimestamp(20_000_000.01)  # Local datetime from seconds since the Epoch\n",
    "\n",
    "tz2: tzinfo = tzlocal()\n",
    "dt5: datetime = datetime.fromtimestamp(300_000_000, tz2)  # Aware datetime from seconds since the Epoch\n",
    "\n",
    "print (f\"{dt1}\\n {dt2}\\n {dt3}\\n {dt4}\\n {dt5}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-07-18 15:12:01.783993\n",
      " 2022-07-18T15:12:01.783993\n",
      " 18/07/22 15:12\n",
      " 738354\n",
      " 1658139121.783993\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "dt1: datetime = datetime.today()\n",
    "\n",
    "s1: str = dt1.isoformat()\n",
    "s2: str = dt1.strftime(\"%d/%m/%y %H:%M\")  # Outputting datetime object to string (format: https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes)\n",
    "i: int = dt1.toordinal()  # Days since Gregorian NYE 1, ignoring time and tz\n",
    "a: float = dt1.timestamp()  # Seconds since the Epoch\n",
    "\n",
    "print (f\"{dt1}\\n {s1}\\n {s2}\\n {i}\\n {a}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022-07-23\n",
      " 2022-07-13 15:12:01.841575\n",
      " 14838 days, 15:12:01.841575\n",
      " 50 days, 0:00:00\n",
      " 5.0\n"
     ]
    }
   ],
   "source": [
    "from datetime import date, time, datetime, timedelta\n",
    "from dateutil.tz import UTC, tzlocal, gettz, datetime_exists, resolve_imaginary\n",
    "\n",
    "d: date  = date.today()\n",
    "dt1: datetime = datetime.today()\n",
    "dt2: datetime = datetime(year=1981, month=12, day=2)\n",
    "td1: timedelta = timedelta(days=5)\n",
    "td2: timedelta = timedelta(days=1)\n",
    "\n",
    "d = d + td1  # date = date ± timedelta\n",
    "dt3 = dt1 - td1  # datetime = datetime ± timedelta\n",
    "\n",
    "td3 = dt1 - dt2  # timedelta = datetime - datetime\n",
    "\n",
    "td4 = 10 * td1  # timedelta = const * timedelta\n",
    "c: float = td1/td2  # timedelta/timedelta\n",
    "\n",
    "print (f\"{d}\\n {dt3}\\n {td3}\\n {td4}\\n {c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## File\n",
    "\n",
    "### Open\n",
    "\n",
    "Open the file and return a corresponding file object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from file!\n"
     ]
    }
   ],
   "source": [
    "f = open(\"f.txt\", mode='r', encoding=\"utf-8\", newline=None)\n",
    "\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "*encoding=None* means that the default encoding is used, which is platform dependent. Best practice is to use *encoding=\"utf-8\"* whenever possible.  \n",
    "*newline=None* means all different end of line combinations are converted to '\\n' on read, while on write all '\\n' characters are converted to system's default line separator.  \n",
    "*newline=\"\"* means no conversions take place, but input is still broken into chunks by readline() and readlines() on every \"\\n\", \"\\r\" and \"\\r\\n\".  \n",
    "\n",
    "### Modes\n",
    "\n",
    "\"r\" - Read (default)  \n",
    "\"w\" - Write (truncate)  \n",
    "\"x\" - Write or fail if the file already exists  \n",
    "\"a\" - Append  \n",
    "\"w+\" - Read and write (truncate)  \n",
    "\"r+\" - Read and write from the start  \n",
    "\"a+\" - Read and write from the end  \n",
    "\"t\" - Text mode (default)  \n",
    "\"b\" - Binary mode (`'br'`, `'bw'`, `'bx'`, …)  \n",
    "\n",
    "### Exceptions\n",
    "\n",
    "*FileNotFoundError* can be raised when reading with \"r\" or \"r+\".  \n",
    "*FileExistsError* can be raised when writing with \"x\".  \n",
    "*IsADirectoryError* and *PermissionError* can be raised by any.  \n",
    "*OSError* is the parent class of all listed exceptions.  \n",
    "\n",
    "### Read from file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "['Hello from file!']\n"
     ]
    }
   ],
   "source": [
    "with open(\"f.txt\", encoding=\"utf-8\") as f:\n",
    "    chars = f.read(5)  # Reads chars/bytes or until EOF\n",
    "    print(chars)\n",
    "\n",
    "    f.seek(0)  # Moves to the start of the file. Also seek(offset) and seek(±offset, anchor), where anchor is 0 for start, 1 for current position and 2 for end\n",
    "\n",
    "    lines: list[str] = f.readlines()  # Also readline()\n",
    "    print(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write to file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"f.txt\", \"w\", encoding=\"utf-8\") as f:\n",
    "    f.write(\"Hello from file!\")  # Also f.writelines(<collection>)\n",
    "    # f.flush() for flushes write buffer; runs every 4096/8192 B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Paths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\\Works\\amaargiru\\ipycs\n",
      "c:\\Works\\amaargiru\\ipycs\\f.txt\n",
      "f.txt c:\\Works\\amaargiru\\ipycs ('c:\\\\Works\\\\amaargiru\\\\ipycs\\\\f', '.txt')\n",
      "os.stat_result(st_mode=33206, st_ino=25051272927278718, st_dev=3628794147, st_nlink=1, st_uid=0, st_gid=0, st_size=16, st_atime=1658139122, st_mtime=1658139122, st_ctime=1654437943)\n",
      "True True False\n",
      "['.git', '.gitignore', '1.bin', '1.json', 'convert_nb_to_md.bat', 'f.txt', 'LICENSE', 'pycallgraph3.png', 'PYCS.ipynb', 'README.md']\n",
      "f .txt ('c:\\\\', 'Works', 'amaargiru', 'ipycs', 'f.txt')\n"
     ]
    }
   ],
   "source": [
    "from os import getcwd, path, listdir\n",
    "from pathlib import Path\n",
    "\n",
    "s1: str = getcwd()  # Returns the current working directory\n",
    "print(s1)\n",
    "\n",
    "s2: str = path.abspath(\"f.txt\")  # Returns absolute path\n",
    "print(s2)\n",
    "\n",
    "s3: str = path.basename(s2)  # Returns final component of the path\n",
    "s4: str = path.dirname(s2)  # Returns path without the final component\n",
    "t1: tuple = path.splitext(s2)  # Splits on last period of the final component\n",
    "print(s3, s4, t1)\n",
    "\n",
    "p = Path(s2)\n",
    "st = p.stat()\n",
    "print(st)\n",
    "\n",
    "b1: bool = p.exists()\n",
    "b2: bool = p.is_file()\n",
    "b3: bool = p.is_dir()\n",
    "print(b1, b2, b3)\n",
    "\n",
    "c: list = listdir(path=s1)  # Returns filenames located at path\n",
    "print(c)\n",
    "\n",
    "s5: str = p.stem  # Returns final component without extension\n",
    "s6: str  = p.suffix  # Returns final component's extension\n",
    "t2: tuple = p.parts  # Returns all components as strings\n",
    "print(s5, s6, t2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data querying"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sum, Count, Min, Max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19\n",
      "3\n",
      "1\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a: list[int] = [1, 2, 3, 4, 5, 2, 2]\n",
    "\n",
    "s = sum(a)\n",
    "print(s)\n",
    "\n",
    "c = a.count(2)  # Returns number of occurrences\n",
    "print(c)\n",
    "\n",
    "mn = min(a)\n",
    "print(mn)\n",
    "\n",
    "mx = max(a)\n",
    "print(mx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehension\n",
    "An elegant approach to create a new list based on the values of an existing list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Lemon', 'Apple', 'Watermelon', 'Pear']\n",
      "['LEMON', 'APPLE', 'BANANA', 'KIWI', 'WATERMELON', 'PEAR']\n",
      "[['Lemon', 'Apple'], ['Banana', 'Kiwi'], ['Watermelon', 'Pear']]\n"
     ]
    }
   ],
   "source": [
    "# new_list = [expression for member in iterable (if conditional)]\n",
    "\n",
    "fruits: list = [\"Lemon\", \"Apple\", \"Banana\", \"Kiwi\", \"Watermelon\", \"Pear\"]\n",
    "\n",
    "e_fruits = [fruit for fruit in fruits if \"e\" in fruit]\n",
    "#                                     ☝ if conditional\n",
    "print(e_fruits)\n",
    "\n",
    "upper_fruits = [fruit.upper() for fruit in fruits]\n",
    "#                     ☝ expression\n",
    "print(upper_fruits)\n",
    "\n",
    "# Split a list into equal sized chunks\n",
    "chunk_len = 2\n",
    "chunk_fruits = [fruits[i:i + chunk_len] for i in range(0, len(fruits), chunk_len)]\n",
    "print(chunk_fruits)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary comprehension\n",
    "Creating new dictionaries from existing dictionaries and iterables. A dictionary comprehension is very much like a list comprehension, but we get a dictionary at the end of it, so we need to be assigning key value pairs instead of only values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Italy': 'Pizza', 'China': 'Dim Sum', 'South Korea': 'Kimchi'}\n"
     ]
    }
   ],
   "source": [
    "# new_dict = {expression for member in iterable (if conditional)}\n",
    "\n",
    "d: dict[str, str] = {\"Italy\": \"Pizza\", \"US\": \"Hot-Dog\", \"China\": \"Dim Sum\", \"South Korea\": \"Kimchi\"}  # Create a dictionary\n",
    "\n",
    "d2: dict[str, str] = {k: v for k, v in d.items() if \"i\" in v}  ## Select only elements that contain a letter \"i\" in value\n",
    "print(d2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### bisect and binary search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted: [1, 6, 8, 12, 19, 33]\n",
      "5\n",
      "[1, 6, 8, 12, 15, 19, 33]\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "import bisect\n",
    "\n",
    "a: list[int] = [12, 6, 8, 19, 1, 33]\n",
    "\n",
    "a.sort()\n",
    "print(f\"Sorted: {a}\")\n",
    "\n",
    "print(bisect.bisect(a, 19))  # Locate the insertion point for value in a list to maintain sorted order\n",
    "\n",
    "bisect.insort(a, 15)  # Insert value in a list in sorted order\n",
    "print(a)\n",
    "\n",
    "# Binary search\n",
    "\n",
    "from bisect import bisect_left\n",
    "\n",
    "def binary_search(a, x, lo=0, hi=None):\n",
    "    if hi is None:\n",
    "        hi = len(a)\n",
    "\n",
    "    pos = bisect_left(a, x, lo, hi)\n",
    "    return pos if pos != hi and a[pos] == x else -1\n",
    "\n",
    "print(binary_search(a, 15))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pairwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2), (2, 3), (3, 4), (4, 5)]\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "\n",
    "a = [1, 2, 3, 4, 5]\n",
    "p = itertools.pairwise(a)  # Returns successive overlapping pairs\n",
    "\n",
    "print(list(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encryption and Decryption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original message: b'A am the Message'\n",
      "Encrypted message: b'\\xdf\\xb9j:\\xb8;%\\xe9\\xae\\xfe\\xd2 \\x81w%\"\\x88[\\x9e*\\xd4\\x8e\\x1b\\xa5K)\\x19\\xce]\\xd7\\x1e]\\xb0\\x10\\x84\\x18\\x1fOn\\xdd\\xe3\\xf9}\\x92F\\xc1DB'\n",
      "Decrypted message: b'A am the Message'\n"
     ]
    }
   ],
   "source": [
    "# pip install pycryptodomex\n",
    "import hashlib\n",
    "\n",
    "from Cryptodome import Random\n",
    "from Cryptodome.Cipher import AES\n",
    "from Cryptodome.Util.Padding import pad\n",
    "from Cryptodome.Util.Padding import unpad\n",
    "\n",
    "def encrypt_data(password: str, raw_data: bytes) -> bytes:\n",
    "    res = bytes()\n",
    "    try:\n",
    "        key = hashlib.sha256(password.encode()).digest()\n",
    "        align_raw = pad(raw_data, AES.block_size)\n",
    "        iv = Random.new().read(AES.block_size)\n",
    "        cipher = AES.new(key, AES.MODE_CBC, iv)\n",
    "        ciphered_data = cipher.encrypt(align_raw)\n",
    "        res = iv + ciphered_data\n",
    "    except Exception as e:\n",
    "        print(f\"Encrypt error: {str(e)}\")\n",
    "    return res\n",
    "\n",
    "def decrypt_data(password: str, encrypted_data: bytes) -> bytes:\n",
    "    res = bytes()\n",
    "    try:\n",
    "        key = hashlib.sha256(password.encode()).digest()\n",
    "        iv = encrypted_data[:AES.block_size]\n",
    "        ciphered_data = encrypted_data[AES.block_size:]\n",
    "        cipher = AES.new(key, AES.MODE_CBC, iv)\n",
    "        decrypt_data = cipher.decrypt(ciphered_data)\n",
    "        res = unpad(decrypt_data, AES.block_size)\n",
    "    except Exception as e:\n",
    "        print(f\"Decrypt error: {str(e)}\")\n",
    "    return res\n",
    "\n",
    "def encrypt_file(src_file: str, dst_file: str, password: str) -> bool:\n",
    "    try:\n",
    "        with open(src_file, \"rb\") as reader, open(dst_file, \"wb\") as writer:\n",
    "            data = reader.read()\n",
    "            data_enc = encrypt_data(password, data)\n",
    "            writer.write(data_enc)\n",
    "            writer.flush()\n",
    "            print(f\"{src_file} encrypted into {dst_file}\")\n",
    "        return True\n",
    "    except Exception as e:\n",
    "        print(f\"Encrypt_file error: {str(e)}\")\n",
    "        return False\n",
    "\n",
    "def decrypt_file(src_file: str, dst_file: str, password: str) -> bool:\n",
    "    try:\n",
    "        with open(src_file, \"rb\") as reader, open(dst_file, \"wb\") as writer:\n",
    "            data = reader.read()\n",
    "            data_decrypt = decrypt_data(password, data)\n",
    "            writer.write(data_decrypt)\n",
    "            writer.flush()\n",
    "            print(f\"{src_file} decrypted into {dst_file}\")\n",
    "        return True\n",
    "    except Exception as e:\n",
    "        print(f\"Decrypt file error: {str(e)}\")\n",
    "        return False\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    mes: bytes = bytes(\"A am the Message\", \"utf-8\")\n",
    "    passw: str = \"h3AC3TsU8TECvyCqd5Q5WUag5uXLjct2\"\n",
    "    print(f\"Original message: {mes}\")\n",
    "\n",
    "    # Encrypt message\n",
    "    enc: bytes = encrypt_data(passw, mes)\n",
    "    print(f\"Encrypted message: {enc}\")\n",
    "\n",
    "    # Decrypt message\n",
    "    dec: bytes = decrypt_data(passw, enc)\n",
    "    print(f\"Decrypted message: {dec}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exceptions\n",
    "\n",
    "### Catching exceptions\n",
    "\n",
    "Basic Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: division by zero\n"
     ]
    }
   ],
   "source": [
    "a: float = 0\n",
    "b: float = 0\n",
    "\n",
    "try:\n",
    "    b: float = 1/a\n",
    "except ZeroDivisionError as e:\n",
    "    print(f\"Error: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More complex example. Code inside the *else* block will only be executed if *try* block had no exceptions. Code inside the *finally* block will always be executed (unless a signal is received)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: division by zero\n",
      "This part is always called\n"
     ]
    }
   ],
   "source": [
    "import traceback\n",
    "\n",
    "a: float = 0\n",
    "b: float = 0\n",
    "\n",
    "try:\n",
    "    b: float = 1/a\n",
    "except ZeroDivisionError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "except ArithmeticError as e:\n",
    "    print(f\"We have a bit more complicated problem: {e}\")\n",
    "except Exception as serious_problem:  # Catch all exceptions\n",
    "    print(f\"I don't really know what is going on: {traceback.print_exception(serious_problem)}\")\n",
    "else:\n",
    "    print(\"No errors!\")\n",
    "finally:\n",
    "    print(\"This part is always called\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Raising Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have ValueError, as a planned!\n"
     ]
    }
   ],
   "source": [
    "from decimal import *\n",
    "\n",
    "def div(a: Decimal, b: Decimal) -> Decimal:\n",
    "    if b == 0:\n",
    "        raise ValueError(\"Second argument must be non-zero\")\n",
    "    return a/b\n",
    "\n",
    "\n",
    "try:\n",
    "    c: Decimal = div(1, 0)\n",
    "except ValueError:\n",
    "    print(\"We have ValueError, as a planned!\")\n",
    "    # raise # We can re-raise exception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Built-in Exceptions\n",
    "```text\n",
    "BaseException\n",
    " +-- SystemExit                   # Raised by the sys.exit() function\n",
    " +-- KeyboardInterrupt            # Raised when the user press the interrupt key (ctrl-c)\n",
    " +-- Exception                    # User-defined exceptions should be derived from this class\n",
    "      +-- ArithmeticError         # Base class for arithmetic errors\n",
    "      |    +-- ZeroDivisionError  # Dividing by zero\n",
    "      +-- AttributeError          # Attribute is missing\n",
    "      +-- EOFError                # Raised by input() when it hits end-of-file condition\n",
    "      +-- LookupError             # Raised when a look-up on a collection fails\n",
    "      |    +-- IndexError         # A sequence index is out of range\n",
    "      |    +-- KeyError           # A dictionary key or set element is missing\n",
    "      +-- NameError               # An object is missing\n",
    "      +-- OSError                 # Errors such as “file not found”\n",
    "      |    +-- FileNotFoundError  # File or directory is requested but doesn't exist\n",
    "      +-- RuntimeError            # Error that don't fall into other categories\n",
    "      |    +-- RecursionError     # Maximum recursion depth is exceeded\n",
    "      +-- StopIteration           # Raised by next() when run on an empty iterator\n",
    "      +-- TypeError               # An argument is of wrong type\n",
    "      +-- ValueError              # When an argument is of right type but inappropriate value\n",
    "           +-- UnicodeError       # Encoding/decoding strings to/from bytes fails\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exits by raising SystemExit exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "# sys.exit()  # Exits with exit code 0 (success)\n",
    "# sys.exit(777)  # Exits with passed exit code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### User-defined Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "MyException",
     "evalue": "My car is broken",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mMyException\u001b[0m                               Traceback (most recent call last)",
      "\u001b[1;32mc:\\Works\\amaargiru\\ipycs\\PYCS.ipynb Ячейка 100\u001b[0m in \u001b[0;36m<cell line: 4>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Works/amaargiru/ipycs/PYCS.ipynb#Y166sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mclass\u001b[39;00m \u001b[39mMyException\u001b[39;00m(\u001b[39mException\u001b[39;00m):\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Works/amaargiru/ipycs/PYCS.ipynb#Y166sZmlsZQ%3D%3D?line=1'>2</a>\u001b[0m     \u001b[39mpass\u001b[39;00m\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Works/amaargiru/ipycs/PYCS.ipynb#Y166sZmlsZQ%3D%3D?line=3'>4</a>\u001b[0m \u001b[39mraise\u001b[39;00m MyException(\u001b[39m\"\u001b[39m\u001b[39mMy car is broken\u001b[39m\u001b[39m\"\u001b[39m)\n",
      "\u001b[1;31mMyException\u001b[0m: My car is broken"
     ]
    }
   ],
   "source": [
    "class MyException(Exception):\n",
    "    pass\n",
    "\n",
    "raise MyException(\"My car is broken\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exception Object\n",
    "\n",
    "```python\n",
    "arguments = <name>.args\n",
    "exc_type = <name>.__class__\n",
    "filename = <name>.__traceback__.tb_frame.f_code.co_filename\n",
    "func_name = <name>.__traceback__.tb_frame.f_code.co_name\n",
    "line = linecache.getline(filename, <name>.__traceback__.tb_lineno)\n",
    "error_msg = ''.join(traceback.format_exception(exc_type, <name>, <name>.__traceback__))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Math\n",
    "\n",
    "### Basic Math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Power: 9.869604401089358\n",
      "Round: 3.14\n",
      "Int round: 300\n",
      "Abs: 3.141592653589793\n",
      "Complex abs: 14.142135623730951\n"
     ]
    }
   ],
   "source": [
    "from math import pi\n",
    "\n",
    "a: float = pi ** 2  # Or pow(pi, 2)\n",
    "print(f\"Power: {a}\")\n",
    "\n",
    "b: float = round(pi, 2)\n",
    "print(f\"Round: {b}\")\n",
    "\n",
    "c: int = round(256, -2)\n",
    "print(f\"Int round: {c}\")\n",
    "\n",
    "d: float = abs(-pi)\n",
    "print(f\"Abs: {d}\")\n",
    "\n",
    "e: float = abs(10+10j)  # Or e: float = abs(complex(real=10, imag=10))\n",
    "print(f\"Complex abs: {e}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bitwise Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "And: 0b00000000\n",
      "Or: 0b11111111\n",
      "Xor: 0b11111111\n",
      "Left shift: 0b10101010000\n",
      "Right shift: 0b00001010\n",
      "Not: 0b-1010110\n"
     ]
    }
   ],
   "source": [
    "a: int = 0b01010101\n",
    "b: int = 0b10101010\n",
    "\n",
    "print(f\"And: 0b{a&b:08b}\")\n",
    "print(f\"Or: 0b{a|b:08b}\")\n",
    "print(f\"Xor: 0b{a^b:08b}\")\n",
    "print(f\"Left shift: 0b{a << 4:08b}\")\n",
    "print(f\"Right shift: 0b{b >> 4:08b}\")\n",
    "print(f\"Not: 0b{~a:08b}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Bit count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4242 in binary format: 0b1000010010010\n",
      "Bit count: 4\n"
     ]
    }
   ],
   "source": [
    "a: int = 4242\n",
    "print(f\"{a} in binary format: 0b{a:b}\")\n",
    "\n",
    "c = a.bit_count()  # Returns the number of ones in the binary representation of the absolute value of the integer\n",
    "print(f\"Bit count: {c}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fractions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 5)\n"
     ]
    }
   ],
   "source": [
    "from fractions import Fraction\n",
    "\n",
    "f = Fraction(\"0.2\").as_integer_ratio()\n",
    "\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Euclidean distance between two points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.39588732276722\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "p1 = (0.22, 1, 12)\n",
    "p2 = (-0.12, 3, 7)\n",
    "\n",
    "print(math.dist(p1, p2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Single float random: 0.9024807633898538\n",
      "Single int random: 7\n",
      "Random bytes: b'>\\xe0^\\x16PX\\xf8E\\xf8\\x98'\n",
      "Random choice: Bob\n",
      "Random list without duplicates: [5, 10, 3, 6, 1]\n",
      "List before shuffle: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
      "List after shuffle: [10, 4, 6, 5, 1, 8, 3, 9, 7, 2]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "rf: float = random.random()  # A float inside [0, 1)\n",
    "print(f\"Single float random: {rf}\")\n",
    "\n",
    "ri: int = random.randint(1, 10)  # An int inside [from, to]\n",
    "print(f\"Single int random: {ri}\")\n",
    "\n",
    "rb = random.randbytes(10)\n",
    "print(f\"Random bytes: {rb}\")\n",
    "\n",
    "rc: str = random.choice([\"Alice\", \"Bob\", \"Maggie\", \"Madhuri Dixit\"])\n",
    "print(f\"Random choice: {rc}\")\n",
    "\n",
    "rs: str = random.sample([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 5)\n",
    "print(f\"Random list without duplicates: {rs}\")\n",
    "\n",
    "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "print(f\"List before shuffle: {a}\")\n",
    "random.shuffle(a)\n",
    "print(f\"List after shuffle: {a}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Profiling\n",
    "\n",
    "### Stopwatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2923033237457275 seconds\n"
     ]
    }
   ],
   "source": [
    "from time import time\n",
    "start_time = time()\n",
    "\n",
    "j: int = 0\n",
    "for i in range(10_000_000):  # Long operation\n",
    "    j = i ** 2\n",
    "\n",
    "duration = time() - start_time\n",
    "print(f\"{duration} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### High performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.3540456001646817 seconds\n"
     ]
    }
   ],
   "source": [
    "from time import perf_counter\n",
    "start_time = perf_counter()\n",
    "\n",
    "j: int = 0\n",
    "for i in range(10_000_000):  # Long operation\n",
    "    j = i ** 2\n",
    "\n",
    "duration = perf_counter() - start_time\n",
    "print(f\"{duration} seconds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### timeit\n",
    "\n",
    "Try to avoid a number of common traps for measuring execution times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8552540000528097"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "\n",
    "def long_pow():\n",
    "    j: int = 0\n",
    "    for i in range(1000_000):  # Long operation\n",
    "        j = i ** 2\n",
    "\n",
    "timeit(\"long_pow()\", number=10, globals=globals(), setup='pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Call Graph\n",
    "\n",
    "Generates a PNG image of the call graph with highlighted bottlenecks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pycallgraph3 import PyCallGraph\n",
    "from pycallgraph3.output import GraphvizOutput\n",
    "\n",
    "def long_pow():\n",
    "    j: int = 0\n",
    "    for i in range(1000_000):  # Long operation\n",
    "        j = i ** 2\n",
    "\n",
    "def short_pow():\n",
    "    j: int = 0\n",
    "    for i in range(1000):  # Short operation\n",
    "        j = i ** 2\n",
    "\n",
    "with PyCallGraph(output=GraphvizOutput()):\n",
    "    # Code to be profiled\n",
    "    long_pow()\n",
    "    short_pow()\n",
    "    # This will generate a file called pycallgraph3.png"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"pycallgraph3.png\" style=\"height:400px\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sources  \n",
    "Official documentation for Python: [docs.python.org](https://docs.python.org/)  \n",
    "A very thorough Python cheat sheet without basic syntax: [Comprehensive Python Cheatsheet](https://github.com/gto76/python-cheatsheet)  \n",
    "Python cheat sheet with basic syntax like flow control: [Python Cheatsheet](https://github.com/wilfredinni/python-cheatsheet). Contains Jupiter [Notebooks](https://github.com/wilfredinni/python-cheatsheet/tree/master/jupyter_notebooks).  \n",
    "List of awesome Python frameworks, libraries and resources: [Awesome Python](https://github.com/vinta/awesome-python).  \n",
    "Python best practices guidebook: [\"The Hitchhiker’s Guide to Python\"](https://github.com/realpython/python-guide)  \n",
    "Code examples of data science libraries, frameworks and toolkits: [Joel Grus, \"Data Science from Scratch\"](https://github.com/joelgrus/data-science-from-scratch)  \n",
    "For more experienced Python programmers: [\"Python 3 Patterns, Recipes and Idioms\"](https://python-3-patterns-idioms-test.readthedocs.io/en/latest/index.html)  \n",
    "For beginners and intermediate level Python programmers: [\"Python Notes for Professionals\"](https://goalkicker.com/PythonBook/)  \n",
    "In-depth introduction to the Python language: [Mark Lutz, \"Learning Python\"](https://drive.google.com/file/d/0B2Y-n6IlHYliSXZxMk0xT0NSY1E/preview)  "
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77"
  },
  "kernelspec": {
   "display_name": "Python 3.10.0 64-bit",
   "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.10.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}