1_pythonBasic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1) Print Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "print('hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2) comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1) comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# note that print is a function\n",
    "print('hello world')\n",
    "\n",
    "# Code tells you how, comments should tell you why."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2) Multiline Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nIf I really hate pressing `enter` and\\ntyping all those hash marks, I could\\njust do this instead\\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "If I really hate pressing `enter` and\n",
    "typing all those hash marks, I could\n",
    "just do this instead\n",
    "\"\"\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3) Docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def somefuction():\n",
    "    \n",
    "    \"\"\"Depending on where they sit in your program, \n",
    "    they could turn into docstrings, which are pieces of documentation \n",
    "    that are associated with a function or method. \n",
    "    If you slip one of these bad boys right after a function definition, \n",
    "    then what you intended to be a comment will become associated \n",
    "    with that object.\"\"\"\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3) Literal Constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 #is a literal constant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.23"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.23 #is a literal constant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a string'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'This is a string' #is a literal constant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"It's is a string\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"It's is a string\" #is a literal constant\n",
    "# also notice how to use apostrophe in a string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1) Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two types of numbers:\n",
    "* __integers__ :  The whole numbers like: 2, 33885, 405930442859, etc.  \n",
    "* __float__ : The decimals/fractions like: 3.23 and 3.45E-2 = 0.0345. The `E` notation indicates powers of 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2) Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.1) using single quotes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'string'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'string'\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.2) using double qoutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"what's up?\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = \"what's up?\" #preferred\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2.3) using triple qoutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sdf \\ndfd'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiline comments (2 ways like multiline comments)\n",
    "c = \"\"\"sdf \n",
    "dfd\"\"\"\n",
    "d = '''as\n",
    "fg\n",
    "ggg\n",
    "'''\n",
    "e = 'This is the first line\\nThis is the second line'\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'as\\nfg\\nggg\\n'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is the first line\\nThis is the second line'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is the first sentence. This is the second sentence.'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# without newline (\\n)\n",
    "f = \"This is the first sentence. \\\n",
    "This is the second sentence.\"\n",
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.1) format method\n",
    "The format method is used when wish to subsititue variable values in a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the price of 3 apples is 1.5'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 3\n",
    "price = 1.5\n",
    "\n",
    "st = 'the price of {0} apples is {1}'.format(n,price)\n",
    "st"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the price of 3 apples is 1.5'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "st2 = 'the price of {} apples is {}'.format(n,price)\n",
    "st2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order matters in this case\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'the price of 1.5 apples is 3'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('order matters in this case')\n",
    "st3 = 'the price of {} apples is {}'.format(price,n)\n",
    "st3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "order matters in this case\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'the price of 3 apples is 1.5'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('order matters in this case')\n",
    "st4 = 'the price of {n} apples is {price}'.format(price = price,n = n)\n",
    "st4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.333\n",
      "___hello___\n",
      "Swaroop wrote A Byte of Python\n"
     ]
    }
   ],
   "source": [
    "# decimal (.) precision of 3 for float '0.333'\n",
    "print('{0:.3f}'.format(1.0/3))\n",
    "# fill with underscores (_) with the text centered\n",
    "# (^) to 11 width '___hello___'\n",
    "print('{0:_^11}'.format('hello'))\n",
    "# keyword-based 'Swaroop wrote A Byte of Python'\n",
    "print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.2) string concatenation (ugly and error prone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the price of 3 apples is 1.5'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"the price of \"+ str(n) + \" apples is \"+ str(price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3.3) fStrings method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the price of 3 apples is 1.5'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'the price of {n} apples is {price}' #preferred"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4) Print function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print always ends with an invisible \"new line\" character ( \\n ) so that repeated\n",
    "calls to print will all print on a separate line each. To prevent this newline character from being printed, you can specify that it\n",
    "should end with a blank:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ab"
     ]
    }
   ],
   "source": [
    "print('a', end='')\n",
    "print('b', end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c\n"
     ]
    }
   ],
   "source": [
    "print('a', end=' ')\n",
    "print('b', end=' ')\n",
    "print('c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5) Escape Sequences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-25-07336096f76e>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-25-07336096f76e>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    'What's your name?'\u001b[0m\n\u001b[1;37m          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "'What's your name?'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_You can see the apostrophe cannot be used in the avove case. To make this possible we need escape Sequence `\\`_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"What's your name?\""
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'What\\'s your name?'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"What's your name?\""
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"What's your name?\" # same output as above"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Male\\\\Female'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Male\\\\Female'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Some often used Escape Sequence__\n",
    "\n",
    "* tab: `\\t`\n",
    "\n",
    "* newline: `\\n`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6) Raw Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you need to specify some strings where no special processing such as escape sequences are handled, then what you need is to\n",
    "specify a raw string by prefixing r or R to the string. An example is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Newlines are indicated by \\\\n'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r\"Newlines are indicated by \\n\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi\\\\tlol'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R'hi\\tlol'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hi\\tlol'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'hi\\tlol'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\tlol\n"
     ]
    }
   ],
   "source": [
    "print('hi\\tlol')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\\tlol\n"
     ]
    }
   ],
   "source": [
    "print(R'hi\\tlol')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Always use raw strings when dealing with regular expressions. Otherwise, a lot of backwhacking may be required. For\n",
    "example, backreferences can be referred to as `\\\\1` or r`\\1` ."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6) Variable / Identifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using just literal constants can soon become boring - we need some way of storing any information and manipulate them as well.\n",
    "This is where variables come into the picture. Variables are exactly what the name implies - their value can vary, i.e., you can\n",
    "store anything using a variable. Variables are just parts of your computer's memory where you store some information. Unlike\n",
    "literal constants, you need some method of accessing these variables and hence you give them names."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2) Identifier Naming\n",
    "Variables are examples of identifiers. Identifiers are names given to identify something. There are some rules you have to follow\n",
    "for naming identifiers:\n",
    "\n",
    "The first character of the identifier must be a letter of the alphabet (uppercase ASCII or lowercase ASCII or Unicode\n",
    "character) or an underscore ( _ ).\n",
    "\n",
    "The rest of the identifier name can consist of letters (uppercase ASCII or lowercase ASCII or Unicode character),\n",
    "underscores ( _ ) or digits (0-9).\n",
    "\n",
    "Identifier names are case-sensitive. For example, myname and myName are not the same. Note the lowercase n in the\n",
    "former and the uppercase N in the latter.\n",
    "\n",
    "Examples of valid identifier names are i , name_2_3 . Examples of invalid identifier names are 2things , this is\n",
    "spaced out , my-name and >a1b2_c3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7) Data Types\n",
    "\n",
    "Variables can hold values of different types called data types. The basic types are numbers and strings, which we have already\n",
    "discussed. In later chapters, we will see how to create our own types using classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8) Object\n",
    "\n",
    "Remember, Python refers to anything used in a program as an object. This is meant in the generic sense. Instead of saying \"the\n",
    "something\"', we say \"the object\".\n",
    "Note for Object Oriented Programming users:\n",
    "Python is strongly object-oriented in the sense that everything is an object including numbers, strings and functions.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9) Logical And Physical Line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A physical line is what you see when you write the program. A logical line is what Python sees as a single statement. Python\n",
    "implicitly assumes that each physical line corresponds to a logical line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Implicitly, Python encourages the use of a single statement per line which makes code more readable.\n",
    "If you want to specify more than one logical line on a single physical line, then you have to explicitly specify this using a\n",
    "semicolon ( ; ) which indicates the end of a logical line/statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, there, you are the best!\n"
     ]
    }
   ],
   "source": [
    "# one logical line & one physical line:\n",
    "print('hi, there, you are the best!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n",
      "you are beutiful\n"
     ]
    }
   ],
   "source": [
    "# two logical line & one physical line:\n",
    "print('hi'); print('you are beutiful')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*__Recommended__* use is to stick to writing a maximum of a single logical line on each single physical line. The idea\n",
    "is that you should never use the semicolon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one kind of situation where this concept is really useful: if you have a long line of code, you can break it into multiple\n",
    "physical lines by using the backslash. This is referred to as __explicit line joining__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a string. This continues the string.\n"
     ]
    }
   ],
   "source": [
    "s = 'This is a string. \\\n",
    "This continues the string.'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = \\\n",
    "5\n",
    "i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# above is same as \n",
    "i = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, there is an implicit assumption where you don't need to use a backslash. This is the case where the logical line has a\n",
    "starting parentheses, starting square brackets or a starting curly braces but not an ending one. This is called __implicit line joining__ (when using _list_)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10) Indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Whitespace is important in Python. Actually, __whitespace__ at the __beginning of the line is important__. This is called _indentation_.\n",
    "Leading whitespace (spaces and tabs) at the beginning of the logical line is used to determine the indentation level of the logical\n",
    "line, which in turn is used to determine the grouping of statements.\n",
    "\n",
    "This means that statements which go together __must__ have the same indentation. Each such set of statements is called a __block__.\n",
    "\n",
    "We will see examples of how blocks are important in later chapters.\n",
    "One thing you should remember is that wrong indentation can give rise to errors. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-60-1db0f95b265b>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-60-1db0f95b265b>\"\u001b[1;36m, line \u001b[1;32m3\u001b[0m\n\u001b[1;33m    print('Value is', i)\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mIndentationError\u001b[0m\u001b[1;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "i = 5\n",
    "# Error below! Notice a single space at the start of the line\n",
    " print('Value is', i)\n",
    "print('I repeat, the value is', i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__you cannot arbitrarily start new\n",
    "blocks of statements__ (except for the default main block which you have been using all along, of course). Cases where you can use new blocks will be detailed in later chapters such as the control flow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "__The official Python language recommendation is Use four spaces for indentation.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mutability in python\n",
    "Also check this:\n",
    "* https://medium.com/datadriveninvestor/mutable-and-immutable-python-2093deeac8d9\n",
    "* https://www.pitt.edu/~naraehan/python3/mutability.htm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}