basic/PyBasics-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Table of contents**<a id='toc0_'></a>    \n",
    "- [Python Keywords](#toc1_)    \n",
    "  - [Python 35 Keywords](#toc1_1_)    \n",
    "- [Python Identifiers](#toc2_)    \n",
    "  - [Variables](#toc2_1_)    \n",
    "  - [Constants](#toc2_2_)    \n",
    "  - [Literals](#toc2_3_)    \n",
    "- [Python Data Types](#toc3_)    \n",
    "- [Python Type Conversion (Type Casting)](#toc4_)    \n",
    "- [Python Operators](#toc5_)    \n",
    "- [Python Namespace and Scope](#toc6_)    \n",
    "  - [Python Variable Scope << Namespaces >>](#toc6_1_)    \n",
    "- [References](#toc7_)    \n",
    "\n",
    "<!-- vscode-jupyter-toc-config\n",
    "\tnumbering=false\n",
    "\tanchor=true\n",
    "\tflat=false\n",
    "\tminLevel=1\n",
    "\tmaxLevel=6\n",
    "\t/vscode-jupyter-toc-config -->\n",
    "<!-- THIS CELL WILL BE REPLACED ON TOC UPDATE. DO NOT WRITE YOUR TEXT IN THIS CELL -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc1_'></a>[Python Keywords](#toc0_)\n",
    "- Keywords are predefined, reserved words \n",
    "- Cannot use a keyword as a variable name, function name\n",
    "- used to define the syntax and structure of the Python language\n",
    "\n",
    "**Python has `35 keywords` >> All the keywords except True, False and None are in lowercase**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a id='toc1_1_'></a>[Python 35 Keywords](#toc0_)\n",
    "\n",
    "`import` `from` `as` \n",
    "\n",
    "`if` `else` `elif`\n",
    "\n",
    "`in` `is` `and` `or` `not`\n",
    "\n",
    "`for` `while` `break` `continue` `pass`\n",
    "\n",
    "`def` `return` `raise` `yield`\n",
    "\n",
    "`try` `except` `finally` `assert`\n",
    "\n",
    "`global` `nonlocal`\n",
    "\n",
    "`lambda` `True` `False` `None`\n",
    "\n",
    "`with` `await` `async` `del` `class`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Here is a list of the Python keywords.  Enter any keyword to get more help.\n",
      "\n",
      "False               class               from                or\n",
      "None                continue            global              pass\n",
      "True                def                 if                  raise\n",
      "and                 del                 import              return\n",
      "as                  elif                in                  try\n",
      "assert              else                is                  while\n",
      "async               except              lambda              with\n",
      "await               finally             nonlocal            yield\n",
      "break               for                 not                 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Print All Python Keywords\n",
    "help(\"keywords\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc2_'></a>[Python Identifiers](#toc0_)\n",
    "\n",
    "Identifiers are the name given to variables, classes, methods, etc.\n",
    "\n",
    "`language = 'Python'`\n",
    "Here, language is a variable (an identifier) which holds the value 'Python'\n",
    "\n",
    "\n",
    "## <a id='toc2_1_'></a>[Variables](#toc0_)\n",
    "A `variable` is a container (storage area) to hold data.  Exp: `number = 10`\n",
    "\n",
    "**Variable Naming Conventions**\n",
    "- snake_case\n",
    "- MACRO_CASE\n",
    "- camelCase\n",
    "- CapWords\n",
    "\n",
    "**Common Rules for Naming Convention**\n",
    "\n",
    "1. If an identifier starts with an underscore, then it is a private identifier\n",
    "2. Class names should normally use the CapWords convention. Exp: class BankAccount:\n",
    "3. Modules should have short, all-lowercase names. Underscores can be used in the module name if it improves readability.\n",
    "4. Python packages should also have short, all-lowercase names, although the use of underscores is discouraged.\n",
    "5. Function names should be lowercase, with words separated by underscores as necessary to improve readability. Exp:  def withdrawal(): or def bank_withdrawal():\n",
    "6. Variable names follow the same convention as function names.\n",
    "```\n",
    "a=[1,2,3]\n",
    "d={‘a’:1}\n",
    "colors=[‘red’,’blue’]\n",
    "```\n",
    "7. Method names and also instance variables should be lowercase with words separated by underscores as necessary to improve readability.\n",
    "8. Use one leading underscore only for non-public methods and instance variables.\n",
    "\n",
    "\n",
    "## <a id='toc2_2_'></a>[Constants](#toc0_)\n",
    "A `constant` is a special type of variable whose value cannot (is not) be changed. Exp: PI = 3.14\n",
    "\n",
    "## <a id='toc2_3_'></a>[Literals](#toc0_)\n",
    "`Literals` are representations of fixed values in a program. \\\n",
    "They can be numbers, characters, or strings, etc. For example, 'Hello, World!', 12, 23.0, 'C', etc.\n",
    "\n",
    "**Python Literal Types**\n",
    " - `Numeric literals: ` can belong to 3 different numerical types: Integer, Float, and Complex. Exp:  a = 6 + 9j. \n",
    " - `boolean literals:` True, False\n",
    " - `Character literals:` are unicode characters enclosed in a quote. Exp: some_character = 'S'\n",
    " - `String literals` are sequences of Characters enclosed in quotation marks.\n",
    " - `Special literal:` None >> used to specify a null variable. Exp: num = None\n",
    " - `Four literal collections:` List literals, Tuple literals, Dict literals, and Set literals.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc3_'></a>[Python Data Types](#toc0_)\n",
    "\n",
    "\n",
    "![Python Data Types](imgs/python_data_types.PNG)\n",
    "\n",
    "\n",
    "**Since everything is an object in Python programming, data types are actually classes and variables are instances(object) of these classes.**\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 is of type <class 'int'>\n",
      "2.0 is of type <class 'float'>\n",
      "(1+2j) is of type <class 'complex'>\n",
      "5 is Binary of type <class 'int'>\n",
      "105 is Octa of type <class 'int'>\n",
      "337 is Hexa of type <class 'int'>\n",
      "010\n"
     ]
    }
   ],
   "source": [
    "num1 = 5\n",
    "print(num1, 'is of type', type(num1))\n",
    "\n",
    "num2 = 2.0\n",
    "print(num2, 'is of type', type(num2))\n",
    "\n",
    "num3 = 1+2j\n",
    "print(num3, 'is of type', type(num3))\n",
    "\n",
    "num4 = 0b101 #Binary \n",
    "print(num4, 'is Binary of type', type(num4))\n",
    "\n",
    "num4 = 0o151\n",
    "print(num4, 'is Octa of type', type(num4))\n",
    "\n",
    "num4 = 0x151\n",
    "print(num4, 'is Hexa of type', type(num4))\n",
    "\n",
    "binary = 0b010\n",
    "print(\"{:03b}\".format(binary))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc4_'></a>[Python Type Conversion (Type Casting)](#toc0_)\n",
    "Type conversion is the process of converting data of one type to another\n",
    "\n",
    "**Type conversion in Python**\n",
    "\n",
    "- Implicit Conversion - automatic type conversion\n",
    "- Explicit Conversion - manual type conversion\n",
    "\n",
    "**Explicit Type Conversion is also called `Type Casting`**\n",
    "- Python avoids the loss of data in Implicit Type Conversion.\n",
    "- In Type Casting, loss of data may occur as we enforce the object to a specific data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value: 125.56\n",
      "Data Type: <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "## Implicit Type Conversion >>  integer to float\n",
    "number = 123\n",
    "\n",
    "number += 2.56\n",
    "\n",
    "# display new value and resulting data type\n",
    "print(\"Value:\",number)\n",
    "print(\"Data Type:\",type(number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data type of num_string before Type Casting: <class 'str'>\n",
      "Data type of num_string after Type Casting: <class 'int'>\n",
      "Sum: 35\n",
      "Data type of num_sum: <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# Explicit Type Conversion\n",
    "num_string = '12'\n",
    "num_integer = 23\n",
    "\n",
    "print(\"Data type of num_string before Type Casting:\",type(num_string))\n",
    "\n",
    "# explicit type conversion\n",
    "num_string = int(num_string)\n",
    "\n",
    "print(\"Data type of num_string after Type Casting:\",type(num_string))\n",
    "\n",
    "num_sum = num_integer + num_string\n",
    "\n",
    "print(\"Sum:\",num_sum)\n",
    "print(\"Data type of num_sum:\",type(num_sum))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc5_'></a>[Python Operators](#toc0_)\n",
    "Operators are special symbols that perform operations on variables and values.\n",
    "\n",
    "**Types of Python Operators**\n",
    "\n",
    "- Arithmetic operators\n",
    "- Assignment Operators\n",
    "- Comparison Operators\n",
    "- Logical Operators\n",
    "- Bitwise Operators\n",
    "- Special Operators\n",
    "\n",
    "<!-- using Table Style for this -->\n",
    "| *1. Arithmetic operators* | \n",
    "|:--:| \n",
    "| ![Arithmetic](imgs/arithmetic_ops.PNG) |\n",
    "\n",
    "\n",
    "| *2. Assignment Operators* | \n",
    "|:--:| \n",
    "| ![Assignment](imgs/assignment_ops.PNG) |\n",
    "\n",
    "\n",
    "| *3. Comparison Operators* | \n",
    "|:--:| \n",
    "| ![Comparison](imgs/comparision_ops.PNG) |\n",
    "\n",
    "\n",
    "| *4. Logical Operators* | \n",
    "|:--:| \n",
    "| ![Logical](imgs/logical_ops.PNG) |\n",
    "\n",
    "\n",
    "| *5. Bitwise Operators* | \n",
    "|:--:| \n",
    "| ![Bitwise](imgs/bitwise_ops.PNG) |\n",
    "\n",
    "\n",
    "6. Special Operators\n",
    "- `Identity operators:`   is and is not are used to check if two values are located on the same part of the memory.\n",
    "- `Membership operators:` in and not in are the membership operators. They are used to test whether a value or variable is found in a sequence (string, list, tuple, set and dictionary).\n",
    "\n",
    "[PyDocumentation > 6.10.2. Membership test operations](https://docs.python.org/3/reference/expressions.html#is)\n",
    "\n",
    "- The operators `in and not in` test for membership. x in s evaluates to True if x is a member of s. \n",
    "- For container types such as list, tuple, set, frozenset, dict, or collections.deque, \n",
    "- **the expression x in y is equivalent to any(x is e or x == e for e in y).**\n",
    "- For the string and bytes types, x in y is True if and only if x is a substring of y. An equivalent test is y.find(x) != -1. \n",
    "- Empty strings are always considered to be a substring of any other string, so \"\" in \"abc\" will return True\n",
    "\n",
    "[PyDocumentation >  6.10.3. Identity comparisons](https://docs.python.org/3/reference/expressions.html#is-not)\n",
    "\n",
    "- The operators is and is not test for an object’s identity: x is y is true if and only if x and y are the same object. \n",
    "- An Object’s identity is determined using the `id()` function. x is not y yields the inverse truth value.\n",
    "\n",
    "\n",
    "[PyDocumentation > 3. Data model > 3.1. Objects, values and types](https://docs.python.org/3/reference/datamodel.html#objects-values-and-types)\n",
    "\n",
    "- All data in a Python program is represented by objects or by relations between objects.\n",
    "- Every object has an identity, a type and a value. \n",
    "- An object’s identity never changes once it has been created; you may think of it as the object’s address in memory. \n",
    "- The `is` operator compares the identity of two objects; the `id()` function returns an integer representing its identity.\n",
    "- An object’s type determines the operations that the object supports (e.g., “does it have a length?”) and also defines the possible values for objects of that type. The type() function returns an object’s type (which is an object itself). Like its identity, an object’s type is also unchangeable.\n",
    "\n",
    "**Mutable vs Immutable Objects**\n",
    "- The value of some objects can change. Objects whose value can change are said to be `mutable`; objects whose value is unchangeable once they are created are called `immutable`. \n",
    "- (The value of an immutable container object that contains a reference to a mutable object can change when the latter’s value is changed; however the container is still considered immutable, because the collection of objects it contains cannot be changed. So, immutability is not strictly the same as having an unchangeable value, it is more subtle.) \n",
    "- An object’s mutability is determined by its type; for instance, numbers, strings and tuples are immutable, while dictionaries and lists are mutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_id:2252713034096 \n",
      "y_id:2252713034096 x1 is y1 True\n",
      "x1 is not y1:  False\n",
      "x2 is y2:  True\n",
      "x3 is y3:  False\n",
      "x3_id:2252796120832 \n",
      "y3_id:2252796229312 x3 is y3 False\n"
     ]
    }
   ],
   "source": [
    "x1 = 5\n",
    "y1 = 5\n",
    "x2 = 'Hello'\n",
    "y2 = 'Hello'\n",
    "x3 = [1,2,3]\n",
    "y3 = [1,2,3]\n",
    "\n",
    "print(f\"x_id:{id(x1)} \\ny_id:{id(y1)} x1 is y1 {x1 is y1}\")  # prints True\n",
    "\n",
    "print(\"x1 is not y1: \", x1 is not y1)  # prints False\n",
    "print(\"x2 is y2: \", x2 is y2)  # prints True\n",
    "print(\"x3 is y3: \", x3 is y3)  # prints False\n",
    "\n",
    "print(f\"x3_id:{id(x3)} \\ny3_id:{id(y3)} x3 is y3 {x3 is y3}\")  # prints True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc6_'></a>[Python Namespace and Scope](#toc0_)\n",
    "\n",
    "- `Namespace` is a mapping of every name used to store the values of variables and other objects in the program, and to associate them with a specific name\n",
    "- This allows us to use the same name for different variables or objects in different parts of your code, without causing any conflicts or confusion.\n",
    "\n",
    "\n",
    "| ![Python Namespaces](imgs/namespace.png) | \n",
    "|:--:| \n",
    "| *Python Namespaces* |\n",
    "\n",
    "**`Built-in namespace`**\n",
    "- `built-in namespace` is created when we start the Python interpreter and exists as long as the interpreter runs. \n",
    "- This is the reason that built-in functions like id(), print() etc. are always available to us from any part of the program.\n",
    "\n",
    "**`Global namespace`**\n",
    "- Each module creates its own `Global namespace`.\n",
    "- These different namespaces are isolated. Hence, the same name that may exist in different modules does not collide.\n",
    "- Modules can have various functions and classes. \n",
    "\n",
    "**`Local namespace`**\n",
    "- A local namespace is created when a function is called, which has all the names defined in it.\n",
    "- Similar is the case with class.\n",
    "\n",
    "**`Python Nonlocal Variables`**\n",
    "\n",
    "- In Python, nonlocal variables are used in nested functions whose local scope is not defined. \n",
    "  - This means that the variable can be neither in the local nor the global scope.\n",
    "- We use the nonlocal keyword to create nonlocal variables.\n",
    "\n",
    "## <a id='toc6_1_'></a>[Python Variable Scope << Namespaces >>](#toc0_)\n",
    "**When a reference is made inside a function, the name is searched in the local namespace, then in the global namespace and finally in the built-in namespace.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global namespace 10\n",
      "local namespace 20\n",
      "nested local namespace:  30\n"
     ]
    }
   ],
   "source": [
    "# number is in the global namespace\n",
    "number = 10\n",
    "\n",
    "def outer_function():\n",
    "    #  number is in the local namespace \n",
    "    number = 20\n",
    "\n",
    "    def inner_function():\n",
    "        #  number is in the nested local namespace \n",
    "        number = 30\n",
    "\n",
    "        print(\"nested local namespace: \", number)\n",
    "\n",
    "    print(\"local namespace\", number)\n",
    "\n",
    "    inner_function()\n",
    "\n",
    "# print the value of the global variable\n",
    "print(\"global namespace\", number)\n",
    "\n",
    "# call the outer function and print local and nested local variables\n",
    "outer_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner: nonlocal\n",
      "outer: nonlocal\n"
     ]
    }
   ],
   "source": [
    "##################### Nonlocal NameSpace #######\n",
    "# outside function \n",
    "def outer():\n",
    "    message = 'local'\n",
    "\n",
    "    # nested function  \n",
    "    def inner():\n",
    "\n",
    "        # declare nonlocal variable\n",
    "        nonlocal message\n",
    "\n",
    "        message = 'nonlocal'\n",
    "        print(\"inner:\", message)\n",
    "\n",
    "    inner()\n",
    "    print(\"outer:\", message)\n",
    "\n",
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <a id='toc7_'></a>[References](#toc0_)\n",
    "\n",
    "- [The Python Language Reference](https://docs.python.org/3/reference/index.html)\n",
    "- [Programiz - Python](https://www.programiz.com/python-programming/)"
   ]
  }
 ],
 "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}