reference_guide.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "71ed3d22",
   "metadata": {},
   "source": [
    "# Python Reference Guide"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e907e0c",
   "metadata": {},
   "source": [
    "Need a quick reference guide to help you while you hack? This is no substitute for the actual course content, but here's a \"cheatsheet\" to help jog your memory!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fadb6601",
   "metadata": {},
   "source": [
    "## Handy Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7c3e0a42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This will print some text\n"
     ]
    }
   ],
   "source": [
    "print('This will print some text')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "3ec022ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is: Ryan'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use string formatting (\"f-strings\") to insert values\n",
    "name = 'Ryan'\n",
    "f'My name is: {name}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "1ab7a06a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10, 2)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# An iterable object containing sequential integers\n",
    "range(0, 10)\n",
    "\n",
    "# Iterate by steps of 2\n",
    "range(0, 10, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "835fcf5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Returns the datatype of the value passed in\n",
    "type(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e38dc92b",
   "metadata": {},
   "source": [
    "## Math Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cdf9ab4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Addition\n",
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "563311f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Subtraction\n",
    "2 - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "29ee6dd9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Multiplication\n",
    "5 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "09a49593",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Division\n",
    "25 / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6707e4e5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Exponents \n",
    "5 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "659df18d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Modulus (remainder after division)\n",
    "17 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b890997",
   "metadata": {},
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0e3bde08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integers\n",
    "x = 1\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b2dd1551",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Floats\n",
    "x = 1.0\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a981a3d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Strings\n",
    "x = 'Ryan'\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b36870dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Booleans\n",
    "x = True\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "281f4c7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bytes"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Byte data\n",
    "x = bytes(4)\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b20d6ca4",
   "metadata": {},
   "source": [
    "### Casting Datatypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "5aa946e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String to integer\n",
    "int('1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "ab1c3cf2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Float to integer\n",
    "int(1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "5ae89ef1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integer to float\n",
    "float(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "844ab9ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integer to boolean\n",
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ede2547c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String to boolean (Anything other than an empty string is True)\n",
    "bool('')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "2158dae1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Int to string\n",
    "str(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "26ff8624",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\xf0\\x9f\\x99\\x82'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String to bytes, requires the encoding\n",
    "bytes('🙂', 'utf-8')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe277050",
   "metadata": {},
   "source": [
    "## String Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "39bd5f9a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ryan Mitchell'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String concatenation\n",
    "'Ryan ' + 'Mitchell'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "ae71aefe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PythonPythonPythonPythonPythonPython'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String multiplication\n",
    "'Python'*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "37fbcde4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Access a particular character in a string\n",
    "'Python'[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdd3e0cd",
   "metadata": {},
   "source": [
    "## Boolean Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "ba869927",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# AND\n",
    "print(True and True)\n",
    "print(True and False)\n",
    "print(False and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "28b2fa5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# OR\n",
    "print(True or True)\n",
    "print(True or False)\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "bc55ebf9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# NOT \n",
    "print(not True)\n",
    "print(not False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "35e8e720",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equality operator\n",
    "5 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "f1306639",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inequality operator\n",
    "5 != 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "5ec97ec8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Less than\n",
    "4 < 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "e20ef2df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Less than or equals to \n",
    "5 <= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "09cc20bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Greater than\n",
    "5 > 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "b60907e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Greater than or equals to\n",
    "5 >= 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a2e7267",
   "metadata": {},
   "source": [
    "## Control Flow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d50b0640",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cb4e8515",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This will print\n"
     ]
    }
   ],
   "source": [
    "if False: \n",
    "    print('This does not print')\n",
    "else: \n",
    "    print('This will print')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "8e2abd4c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number: 0\n",
      "Number: 1\n",
      "Number: 2\n",
      "Number: 3\n",
      "Number: 4\n"
     ]
    }
   ],
   "source": [
    "# Iterate through items in a range\n",
    "for i in range(0, 5):\n",
    "    print('Number: {}'.format(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "9fffb55a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number: 1\n",
      "Number: 2\n",
      "Number: 3\n",
      "Number: 4\n",
      "Number: 5\n"
     ]
    }
   ],
   "source": [
    "# Iterate through items in a list\n",
    "for i in [1,2,3,4,5]:\n",
    "    print('Number: {}'.format(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d3644b73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number: 0\n",
      "Number: 1\n",
      "Number: 2\n",
      "Number: 3\n",
      "Number: 4\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 5:\n",
    "    print('Number: {}'.format(i))\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3e111af",
   "metadata": {},
   "source": [
    "## Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cd23c41",
   "metadata": {},
   "source": [
    "### Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "1652a902",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aList = [1,2,3,4]\n",
    "type(aList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "6190492f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 5, 5]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Append item to a list\n",
    "aList.append(5)\n",
    "aList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "0c73fb6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List concatenation\n",
    "[1,2,3] + [4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "2f429961",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List multiplication\n",
    "[1,2] * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "8dc04f2c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4]\n",
      "[5, 6, 7, 8, 9, 10]\n",
      "[1, 3, 5, 7, 9]\n",
      "[1, 4, 7, 10]\n"
     ]
    }
   ],
   "source": [
    "# Accessing items in a list\n",
    "\n",
    "aList = [1,2,3,4,5,6,7,8,9,10]\n",
    "# Print the item at index 4\n",
    "print(aList[4])\n",
    "\n",
    "# Print the items at index 0, up to (not including) index 4\n",
    "print(aList[0:4])\n",
    "\n",
    "# If the first index is missing, it's assumed to be 0\n",
    "print(aList[:4])\n",
    "\n",
    "# If the last index is missing, it's assumed to go to the end of the list\n",
    "print(aList[4:])\n",
    "\n",
    "# Print every other item in the list\n",
    "print(aList[::2])\n",
    "\n",
    "# Print every third item in the list\n",
    "print(aList[::3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7307ea7",
   "metadata": {},
   "source": [
    "### Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "c167cdcf",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "aDict = {\n",
    "    'one': 1,\n",
    "    'two': 2,\n",
    "    'three': 3,\n",
    "}\n",
    "# Add key/value pairs to dictionary\n",
    "aDict['four'] = 4\n",
    "\n",
    "# Access values by keys\n",
    "print(aDict['one'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "08a785bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['one', 'two', 'three', 'four'])\n",
      "dict_values([1, 2, 3, 4])\n",
      "dict_items([('one', 1), ('two', 2), ('three', 3), ('four', 4)])\n"
     ]
    }
   ],
   "source": [
    "# Print all keys\n",
    "print(aDict.keys())\n",
    "\n",
    "# Print all values\n",
    "print(aDict.values())\n",
    "\n",
    "# Print all key/value pairs\n",
    "print(aDict.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d90663f",
   "metadata": {},
   "source": [
    "### Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5a6bcf01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "aSet = {1,2,3,4}\n",
    "\n",
    "# Add an item to a set\n",
    "aSet.add(5)\n",
    "\n",
    "# Remove an item from a set\n",
    "aSet.remove(2)\n",
    "print(aSet)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8a25d64",
   "metadata": {},
   "source": [
    "### Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "aade96be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Tuples cannot be modified\n",
    "aTuple = (1,2,3,4)\n",
    "aTuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b57deb09",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a6aa39d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Function with one argument and a return value\n",
    "def aFunction(anArg):\n",
    "    return anArg + 1\n",
    "\n",
    "aFunction(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c4d61e84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "9\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Different ways of calling a function with a keyword argument\n",
    "def aFunction(anArg, optionalArg=1):\n",
    "    return anArg + optionalArg\n",
    "\n",
    "print(aFunction(5))\n",
    "print(aFunction(5, 4))\n",
    "print(aFunction(5, optionalArg=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bed429aa",
   "metadata": {},
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "fbfbb1ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value for the class attribute \"val\"\n"
     ]
    }
   ],
   "source": [
    "# A simple class with one attribute and one method\n",
    "class ParentClass:\n",
    "    def __init__(self, val):\n",
    "        self.val = val\n",
    "        \n",
    "    def printVal(self):\n",
    "        print(self.val)\n",
    "        \n",
    "\n",
    "classInstance = ParentClass('Value for the class attribute \"val\"')\n",
    "classInstance.printVal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "01e3544e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Child class! Value for the class attribute \"val\"\n"
     ]
    }
   ],
   "source": [
    "# Extend the parent class to create a child class        \n",
    "class ChildClass(parentClass):\n",
    "    \n",
    "    def printVal(self):\n",
    "        print('Child class! {}'.format(self.val))\n",
    "        \n",
    "childInstance = ChildClass('Value for the class attribute \"val\"')\n",
    "childInstance.printVal()   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3cc855fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A default value\n"
     ]
    }
   ],
   "source": [
    "# Overriding the parent class constructor\n",
    "class AnotherChildClass(parentClass):\n",
    "    def __init__(self):\n",
    "        super().__init__('A default value')\n",
    "        \n",
    "anotherChildInstance = AnotherChildClass()\n",
    "anotherChildInstance.printVal()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55741ea8",
   "metadata": {},
   "source": [
    "## File Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "21ebdf42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Beautiful is better than ugly.\\n', 'Explicit is better than implicit.\\n', 'Simple is better than complex.\\n', 'Complex is better than complicated.\\n', 'Flat is better than nested.\\n', 'Sparse is better than dense.\\n', 'Readability counts.\\n', \"Special cases aren't special enough to break the rules.\\n\", 'Although practicality beats purity.\\n', 'Errors should never pass silently.\\n', 'Unless explicitly silenced.\\n', 'In the face of ambiguity, refuse the temptation to guess.\\n', 'There should be one-- and preferably only one --obvious way to do it.\\n', \"Although that way may not be obvious at first unless you're Dutch.\\n\", 'Now is better than never.\\n', 'Although never is often better than *right* now.\\n', \"If the implementation is hard to explain, it's a bad idea.\\n\", 'If the implementation is easy to explain, it may be a good idea.\\n', \"Namespaces are one honking great idea -- let's do more of those!\"]\n"
     ]
    }
   ],
   "source": [
    "# Open a file for reading\n",
    "with open('09_01_file.txt', 'r') as f:\n",
    "    data = f.readlines()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a374618f",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('test.txt', 'w') as f:\n",
    "    f.write('Writing a new line\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d69598c",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('test.txt', 'a') as f:\n",
    "    f.write('Adding a new line to the last one\\n')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}