01_Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sagar Giri \n",
    "\n",
    "[https://girisagar46.github.io](https://girisagar46.github.io)\n",
    "\n",
    "*girisagar46@gmail.com* | *sgiri@alumni.deerwalk.edu.np* ""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "History\n",
    "====\n",
    "\n",
    "* Development started in 1980s.\n",
    "* Developed by Guido Van Rossum (BDFL).\n",
    "* Python First Release: 1991\n",
    "* First used in *Star Wars: The Phantom Menace* for processing and rendering VFX\n",
    "* In **2000**, Python 2.0 was released\n",
    "* In **2003**, Python is used in Blender 2.26 for generating and manipulating 3D graphics\n",
    "* In **2008**, Python 3.0 was released\n",
    "* Python source code is also available under the GNU General Public License (GPL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "* Python is a widely used **high-level**, **general-purpose**, **interpreted**, **dynamic programming language**.\n",
    "  * **high-level** : strong abstraction from the details of the computer.\n",
    "  * **general-purpose**: designed to be used for writing software in a wide variety of application domains\n",
    "  * **interpreted**: You do not need to compile your program before executing it. This is similar to PERL and LISP.\n",
    "  * **dynamic programming language**: Runtime instead of compile time (referred to as \"scripting languages\") \n",
    "  \n",
    "* Object Oriented Programming: \n",
    "  * Python supports Objected-Oriented style or technique of programming that encapsulates code within objects.\n",
    "\n",
    "* Interactive\n",
    "  * You can actually sit at a Python prompt and interact  with the interpreter directly to write your programs\n",
    "\n",
    "* Indented\n",
    "  * Python programs are highly readable\n",
    "\n",
    "* Strong and as well as Dynamic Typing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global Context\n",
    "\n",
    "![](https://zgab33vy595fw5zq-zippykid.netdna-ssl.com/wp-content/uploads/2017/09/growth_major_languages-1-1024x878.png)\n",
    "\n",
    "*Source : [https://stackoverflow.blog/2017/09/06/incredible-growth-python/](https://stackoverflow.blog/2017/09/06/incredible-growth-python/)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Popularity\n",
    "\n",
    "![](https://spectrum.ieee.org/image/MzEwMDE1Nw.png)\n",
    "\n",
    "*Source: [https://spectrum.ieee.org/at-work/innovation/the-2018-top-programming-languages](https://spectrum.ieee.org/at-work/innovation/the-2018-top-programming-languages)*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Python Philosophy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "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": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Usage of Python Programming Language\n",
    "\n",
    "- Linux Scripting/ Administration\n",
    "- Web Developement\n",
    "- Application Scripting\n",
    "- Big Data\n",
    "- Machine Learning\n",
    "- Artificial Intelligence\n",
    "- Glueing of different programming language\n",
    "- IOT\n",
    "- ....etc..... etc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PEP8\n",
    "\n",
    "> The Style Guide for Python Code\n",
    "\n",
    "[http://pep8.org/](http://pep8.org/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "#!/usr/bin/python3\n",
    "\n",
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you always run these kinds of scripts from the command line like \n",
    "```python\n",
    " >> python hello_world.py \n",
    "```\n",
    "\n",
    "If the script is made executable, the operating system will use that first line to know which interpreter to run to parse the rest of the file to perform some action.\n",
    "```python\n",
    ">> chmod +x hello_world.py\n",
    ">> ./hello_world.py\n",
    "```\n",
    "In Windows, it typically uses the .py suffix to determine how to execute the script"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indentation\n",
    "\n",
    "Whitespace (indentatoin) is **Very** important in Python.\n",
    "\n",
    "```python\n",
    "# Error below since there is a single space at the start of the line\n",
    " print('Hello')\n",
    "print('World')\n",
    "```\n",
    "\n",
    "\n",
    "```python\n",
    "  File \"whitespace.py\", line 3\n",
    "    print('Hello')\n",
    "    ^\n",
    "IndentationError: unexpected indent\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Interpreter (The Python Shell)\n",
    "\n",
    "* It is used to execute snippets of Python language\n",
    "* A means to learning Python or for debugging purposes\n",
    "* The prompt is usually `>>>`\n",
    "* A special variable _ holds the result of last printed expression\n",
    "* One can type part of command and repeatedly press Up arrow key to match commands from history\n",
    "* `exit()` to exit\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Variables\n",
    "\n",
    "* Python variables should start with _ or alphabet\n",
    "example:- \n",
    "```python\n",
    "_first_name, _last_name, dob, gender\n",
    "```\n",
    "\n",
    "Creating variable means you are reserving some space in memory\n",
    "\n",
    "You can assign a variable with different data types like integer, float, string, etc. without mentioning the data type\n",
    "example:- \n",
    "```python\n",
    "_first_name = 'Ram' \t#Assigning string \n",
    "_last_name = \"Sth\" \t\t#Assigning string \n",
    "_age = 25               #Assigning integer \n",
    "_salary = 9000.00  \t\t#Assigning float\n",
    "```\n",
    "\n",
    "Python allows you to assign single value to several variables simultaneously\n",
    "example:- \n",
    "```python\n",
    "_sum =  _total =  _average = 97 \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numbers in Python\n",
    "\n",
    "- Integers (example: 2, 5, 10 which are whole numbers)\n",
    "- Floating point numbers ***floats*** (example: 2.25, 3.24E-4) \n",
    "\n",
    "```python\n",
    ">>> num1 = 7\n",
    ">>> num2 = 42\n",
    ">>> total = num1 + num2\n",
    ">>> print(total)\n",
    "49\n",
    ">>> total\n",
    "49\n",
    "\n",
    "# no limit to integer precision, only limited by available memory\n",
    ">>> 34 ** 32\n",
    "10170102859315411774579628461341138023025901305856\n",
    "\n",
    "# using single / gives floating point output\n",
    ">>> 9 / 5\n",
    "1.8\n",
    "\n",
    "# using double / gives only the integer portion, no rounding\n",
    ">>> 9 // 5\n",
    "1\n",
    "\n",
    ">>> 9 % 5\n",
    "4\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Floating Points \n",
    "```python\n",
    ">>> appx_pi = 22 / 7\n",
    ">>> appx_pi\n",
    "3.142857142857143\n",
    "\n",
    ">>> area = 42.16\n",
    ">>> appx_pi + area\n",
    "45.30285714285714\n",
    "\n",
    ">>> num1\n",
    "7\n",
    ">>> num1 + area\n",
    "49.16\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# String\n",
    "\n",
    "* strings can be declared using single, double quotes or triple quotes\n",
    "* Use `\\` to escape quotes which are part of string itself if the string contains both single and double quotes\n",
    "\n",
    "```python\n",
    ">>> str1 = 'This is a string'\n",
    ">>> str1\n",
    "'This is a string'\n",
    ">>> greeting = \"Hello World!\"\n",
    ">>> greeting\n",
    "'Hello World!'\n",
    "\n",
    ">>> weather = \"It's a nice and warm day\"\n",
    ">>> weather\n",
    "\"It's a nice and warm day\"\n",
    ">>> print(weather)\n",
    "It's a nice and warm day\n",
    "\n",
    ">>> weather = 'It\\'s a nice and warm day'\n",
    ">>> print(weather)\n",
    "It's a nice and warm day\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "* Use `r` prefix (stands for raw) if you do not want escape sequences to be interpreted\n",
    "* It is commonly used with regular expressions\n",
    "\n",
    "```python\n",
    ">>> raw_str = r'Blue\\nRed\\nGreen'\n",
    ">>> print(raw_str)\n",
    "Blue\\nRed\\nGreen\n",
    "\n",
    "# to see how the string is stored internally\n",
    ">>> raw_str\n",
    "'Blue\\\\nRed\\\\nGreen'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* String concatenation and repetition\n",
    "\n",
    "```python\n",
    ">>> str1 = 'Hello'\n",
    ">>> str2 = ' World'\n",
    ">>> print(str1 + str2)\n",
    "Hello World\n",
    "\n",
    ">>> style_char = '-'\n",
    ">>> style_char * 10\n",
    "'----------'\n",
    "\n",
    ">>> word = 'dwit '\n",
    ">>> print(word * 5)\n",
    "dwit dwit dwit dwit dwit \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "* Triple quoted strings `\"\"\"` or `'''` can be used as required as well as escape characters using \\\n",
    "\n",
    "```python\n",
    "#!/usr/bin/python3\n",
    "\n",
    "\"\"\"\n",
    "This line is part of multiline comment\n",
    "\n",
    "This program shows examples of triple quoted strings\n",
    "\"\"\"\n",
    "```\n",
    "* This is single line comment\n",
    "\n",
    "```python\n",
    "# This method does this\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accessing Values in Strings\n",
    "\n",
    "* Python does not support a character type; these are treated as strings of length one.\n",
    "\n",
    "* Subsets of strings can be taken using the slice operator ([ ] and [:] ) with indexes starting at 0 in the beginning of the string and working their way from -1 at the end.\n",
    "\n",
    "* The plus (+) sign is the string concatenation operator and the asterisk (*) is the repetition operator. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "Hello\n",
      "Hello\n",
      "World\n",
      "Worl\n",
      "Hello WorldHello World\n",
      "Hello World!!\n"
     ]
    }
   ],
   "source": [
    "_name = 'Hello World'\n",
    "\n",
    "\"Any string that is not assigned to a variable is considered as comment\"\n",
    "\n",
    "print(_name[0])       # This prints H\n",
    "print(_name[0:5])     # This prints Hello\n",
    "print(_name[:5])      # This prints Hello\n",
    "print(_name[6:])      # This prints World\n",
    "print(_name[-5:-1])   # This prints Worl\n",
    "print(_name * 2)      # This prints Hello WorldHello World\n",
    "print(_name + '!!')   # This prints Hello World!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***NOTE: If an string is not assigned to a variable, it is regarded as a comments***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings Are Immutable\n",
    "\n",
    "Once you create a string, you cannot change it.\n",
    "\n",
    "For example:\n",
    "```python\n",
    ">>> my_string = \"Hello World!\"\n",
    "\n",
    ">>> my_string[0] = \"X\"  # You can not do this\n",
    "\n",
    "----------------------------------------------------------------\n",
    "TypeError                                 Traceback (most recent call last)\n",
    "<ipython-input-1-5dc639bead5d> in <module>()\n",
    "      1 my_string = \"Hello World!\"\n",
    "      2 \n",
    "----> 3 my_string[0] = \"X\"\n",
    "\n",
    "TypeError: 'str' object does not support item assignment\n",
    "\n",
    "\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Formatting Strings\n",
    "\n",
    "There are many ways we can format strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the Python Programming class with 8 students\n"
     ]
    }
   ],
   "source": [
    "# Example 1\n",
    "\n",
    "class_name = \"Python Programming\"\n",
    "\n",
    "no_of_students = 8\n",
    "\n",
    "sentence = \"This is the {} class with {} students\".format(class_name, no_of_students)\n",
    "\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Sagar Giri and email is girisagar4@gmail.com\n",
      "My email is girisagar4@gmail.com and name is Sagar Giri\n"
     ]
    }
   ],
   "source": [
    "# Example 2\n",
    "\n",
    "name = 'Sagar Giri'\n",
    "email = \"girisagar4@gmail.com\"\n",
    "\n",
    "print(\"My name is {0} and email is {1}\".format(name, email))\n",
    "\n",
    "print(\"My email is {1} and name is {0}\".format(name, email))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am studying Python in Deerwalk Learning center\n"
     ]
    }
   ],
   "source": [
    "# Example 3\n",
    "\n",
    "institute = \"Deerwalk Learning center\"\n",
    "course = \"Python\"\n",
    "\n",
    "sentence = \"I am studying {course} in {institute}\".format(course = \"Python\", institute = \"Deerwalk Learning center\")\n",
    "\n",
    "print(sentence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.333\n",
      "__Python__\n"
     ]
    }
   ],
   "source": [
    "# decimal (.) precision\n",
    "print('{0:.3f}'.format(1.0/3))\n",
    "\n",
    "\n",
    "# fill with underscores (_) with the text centered\n",
    "# (^) to 10 width '__Python__'\n",
    "print('{0:_^10}'.format('Python'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is awesome.\n",
      "3.1429\n",
      "June 10, 2019\n"
     ]
    }
   ],
   "source": [
    "# Example 4\n",
    "\n",
    "# f-strings which are available on Python3.6\n",
    "\n",
    "programming_language = \"Python\"\n",
    "\n",
    "# can use variable directly inside the placeholder. This makes code length shorter.\n",
    "statement = f\"{programming_language} is awesome.\" \n",
    "print(statement)\n",
    "\n",
    "# Number formatting\n",
    "pi = 22/7\n",
    "print(f\"{pi:.5}\")\n",
    "\n",
    "\n",
    "# Prints today's date with help \n",
    "# of datetime library \n",
    "import datetime \n",
    "  \n",
    "today = datetime.datetime.today() \n",
    "print(f\"{today:%B %d, %Y}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f-strings literal are widley being adopted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "<html>\n",
      "    <head>\n",
      "         <title>Python is Awesome</title>\n",
      "    </head>\n",
      "    <body>\n",
      "       Hi\n",
      "    </body>\n",
      "</html>\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Example 5\n",
    "\n",
    "# This is by using the builtin library. It's cool.\n",
    "\n",
    "from string import Template\n",
    "\n",
    "dynamic_title = \"Python is Awesome\"\n",
    "\n",
    "html_template_str = \"\"\"\n",
    "<html>\n",
    "    <head>\n",
    "         <title>$title</title>\n",
    "    </head>\n",
    "    <body>\n",
    "       Hi\n",
    "    </body>\n",
    "</html>\n",
    "\"\"\"\n",
    "html_template = Template(html_template_str)\n",
    "\n",
    "# substitute(title=dynamic_title)\n",
    "generated_html = html_template.substitute(title=dynamic_title)\n",
    "\n",
    "print(generated_html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Which string interpolation to choose?\n",
    "\n",
    "![https://files.realpython.com/media/python-string-formatting-flowchart.4ecf0148fd87.png](https://files.realpython.com/media/python-string-formatting-flowchart.4ecf0148fd87.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constants in Python\n",
    "\n",
    "\n",
    "* `None` The sole value of the type `NoneType`\n",
    "* `None` is frequently used to represent the absence of a value\n",
    "* `False` The false value of the bool type\n",
    "* `True` The true value of the bool type\n",
    "\n",
    "```python\n",
    ">>> bool(2)\n",
    "True\n",
    ">>> bool(0)\n",
    "False\n",
    ">>> bool('')\n",
    "False\n",
    ">>> bool('a')\n",
    "True\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators\n",
    "* arithmetic operators\n",
    "    * `+` addition\n",
    "    * `-` subtraction\n",
    "    * `*` multiplication\n",
    "    * `/` division (float output)\n",
    "    * `//` division (integer output, result is not rounded)\n",
    "    * `**` exponentiation\n",
    "    * `%` modulo\n",
    "* string operators\n",
    "    * `+` string concatenation\n",
    "    * `*` string repetition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* comparison operators\n",
    "    * `==` equal to\n",
    "    * `>` greater than\n",
    "    * `<` less than\n",
    "    * `!=` not equal to\n",
    "    * `>=` greater than or equal to\n",
    "    * `<=` less than or equal to\n",
    "* boolean logic\n",
    "    * `and` logical and\n",
    "    * `or` logical or\n",
    "    * `not` logical not\n",
    "* bitwise operators\n",
    "    * `&` and\n",
    "    * `|` or\n",
    "    * `^` exclusive or\n",
    "    * `~` invert bits\n",
    "    * `>>` right shift\n",
    "    * `<<` left shift\n",
    "* and many more..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| `x ^ y` |\t bitwise exclusive or of `x` and `y `\t| \n",
    "|---------|----------------------------|\n",
    "| `x & y` |\t bitwise and of `x` and `y` \t |\n",
    "| `x << n` |\t `x` shifted left by n bits|\n",
    "| `x >> n` \t| `x` shifted right by n bits|\n",
    "| `~x` \t    | the bits of `x` inverted|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|operation| ? |\n",
    "|-----------|----------|\n",
    "| `-x` \t| `x` negated | \n",
    "| `+x` \t |`x` unchanged | \t  \t \n",
    "| `abs(x)` \t| absolute value or magnitude of `x`| \n",
    "| `int(x)` \t| `x` converted to integer|\n",
    "| `float(x)` | \t`x` converted to floating point|\n",
    "| `complex(re, im)` \t| `a` complex number with real part re, imaginary part im.\t|\n",
    "| `divmod(x, y)` \t| the pair `(x // y, x % y)`|\n",
    "| `pow(x, y)` \t| `x` to the power `y`|\n",
    "| `x ** y` \t| `x` to the power `y`|"
   ]
  }
 ],
 "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": 2
}