Language/Python/00-Introduction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Python is a widely used high-level programming language for general-purpose programming<br>created by Guido van Rossum and ﬁrst released in 1991."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hisory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Python laid its foundation in the late 1980s.\n",
    "- The implementation of Python was started in the December 1989 by Guido Van Rossum at CWI in Netherland.\n",
    "- In February 1991, van Rossum published the code (labeled version 0.9.0) to alt.sources.\n",
    "- In 1994, Python 1.0 was released with new features like: lambda, map, filter, and reduce.\n",
    "- Python 2.0 added new features like: list comprehensions, garbage collection system.\n",
    "- On December 3, 2008, Python 3.0 (also called \"Py3K\") was released. It was designed to rectify fundamental flaw of the language.\n",
    "- ABC programming language is said to be the predecessor of Python language which was capable of Exception Handling and interfacing with Amoeba Operating System."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Why Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">  A dynamic type system and automatic memory management and supports multiple programming paradigms, including object-oriented, imperative, functional programming, and procedural styles. It has a large and comprehensive standard library.\n",
    "\n",
    "**Why Python 2.7?**\n",
    "1. Awesome community support! This is something you’d need in your early days. Python 2 was released in late 2000 and has been in use for more than 17 years.\n",
    "2. Plethora of third-party libraries! Though many libraries have provided 3.x support but still a large number of modules work only on 2.x versions. If you plan to use Python for speciﬁc applications like web-development with high reliance on external modules, you might be better off with 2.7.\n",
    "3. Some of the features of 3.x versions have backward compatibility and can work with 2.7 version.<br>Example          Like the print function has been backported from python 3 to versions later than python 2.7\n",
    "\n",
    "**Why Python 3.8?**\n",
    "1. Cleaner and faster! Python developers have ﬁxed some inherent glitches and minor drawbacks in order to set a stronger foundation for the future. These might not be very relevant initially, but will matter eventually.\n",
    "2. It is the future! 2.7 is the last release for the 2.x family and eventually everyone has to shift to 3.x versions. Python 3 has released stable versions for past 5 years and will continue the same.\n",
    "> There is no clear winner but I suppose the bottom line is that you should focus on learning Python as a language. Shifting between versions should just be a matter of time. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Indentation instead of braces\n",
    "- Several sequence types\n",
    "- Strings ’…’: made of characters, immutable\n",
    "- Lists […]: made of anything, mutable\n",
    "- Tuples (…) : made of anything, immutable\n",
    "- Powerful subscripting (slicing)\n",
    "- Functions are independent entities (not all functions are methods)\n",
    "- Exceptions as in Java\n",
    "- Simple object system\n",
    "- Iterators (like Java) and generators\n",
    "- It implies that other languages such as C/C++ can be used to compile the code and thus it can be used further in our python code.\n",
    "- It can be easily integrated with languages like C, C++, JAVA etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Versions Of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Two major versions of Python are currently in active use:\n",
    "- Python 3.x is the current version and is under active development. \n",
    "- Python 2.x is the legacy version and will receive only security updates until 2020. No new features will be implemented. Note that many projects still use Python 2, although migrating to Python 3 is getting easier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Release Dates -"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python 3.x VersionRelease Date**\n",
    "- 3.7 &emsp;2018-06-27 \n",
    "- 3.6 &emsp;2016-12-23 \n",
    "- 3.5 &emsp;2015-09-13 \n",
    "- 3.4 &emsp;2014-03-17 \n",
    "- 3.3 &emsp;2012-09-29 \n",
    "- 3.2 &emsp;2011-02-20 \n",
    "- 3.1 &emsp;2009-06-26 \n",
    "- 3.0 &emsp;2008-12-03 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python 2.x VersionRelease Date**\n",
    "- 2.7 &emsp;2010-07-03 \n",
    "- 2.6 &emsp;2008-10-02 \n",
    "- 2.5 &emsp;2006-09-19 \n",
    "- 2.4 &emsp;2004-11-30 \n",
    "- 2.3 &emsp;2003-07-29 \n",
    "- 2.2 &emsp;2001-12-21 \n",
    "- 2.1 &emsp;2001-04-15 \n",
    "- 2.0 &emsp;2000-10-16 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Application Of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Python is known for its general purpose nature that makes it applicable in almost each domain of software development. Python as a whole can be used in any sphere of development.\n",
    "\n",
    "- Web Applications\n",
    "- Desktop GUI Applications\n",
    "- Software Development\n",
    "- Scientific and Numeric\n",
    "- Business Applications\n",
    "- Console Based Application\n",
    "- Audio or Video based Applications\n",
    "- 3D CAD Applications\n",
    "- Enterprise Applications\n",
    "- Applications for Images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Installation Of Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> - Download from  http://www.python.org\n",
    "- Install python 3\n",
    "- While installing python add it to path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Verify if Python is installed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Go to command prompt and type python --version\n",
    "2. If it shows you the version then it’s ﬁne or if it shows error go to next step\n",
    "3. If already installed then please uninstall and install again\n",
    "4. select option Add Python 3.x to PATH or Add Python to environment variables \n",
    "5. After installing go to cmd and type python Then type print(\"I've got my very own Python!\") and press enter\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choosing a development environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Once you have installed Python, there are various options for choosing an environment. Here are the 3 most common options:**\n",
    "> ● Terminal / Shell based <br>● IDLE (default environment) <br>● Notebooks<br>\n",
    "While the right environment depends on your need, I personally prefer iPython Notebooks a lot. It provides a lot of good features for documenting while writing the code itself and you can choose to run the code in blocks (rather than the line by line execution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Types in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> In python programming language, we are not going to use any built-in data types to declare a variable like in C, C++. <br>In python, mostly we use built-in data types for type casting the variables. All data values are treated as object for related classes in python programming Language and every object as an identity, value and type. <br>To determine a variable’s type in Python, you can use the type () function. The value of some objects can be changed. Objects whose value can be changed are called mutable. objects whose value is unchangeable are called immutable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. None<br>2. numeric - int, float, complex, bool<br>3. list<br>4. tuple<br>5. set<br>6. string<br>7. range<br>8. dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable is a container which store the data value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> - Variables do not need to be declared with any particular type and can even change type after they have been set.\n",
    "- A variable name must start with a letter or the underscore character('_') .<br>Like - myvar, myVar, _myVar, MYVAR\n",
    "- A variable name cannot start with a number.<br>Like - 1myVar\n",
    "- A variable name can only contain alpha-numeric characters and underscores(A-Z,a-z,0-9 and _ ) .<br>Like - my_var, var2\n",
    "- Variables name are case-sensitive.<br>Like name,Name and NAME are three different variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assigning Value to Muliple Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Python allows us to assign values to the multiple variables in a single line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "num1, num2, num3 = 1, 2, 3\n",
    "print(num1)\n",
    "print(num2)\n",
    "print(num3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Arithmetic Operator : +, -, *, /, //, **, %\n",
    "- Assignment Operator : = (for ex - varname = value)\n",
    "- Relational Operator : <, >, <=, >=, ==, !=\n",
    "- Logical Opeartor : and, or, not\n",
    "- Unary Operator: +, - (like- +5, -3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Arithmetic operators take numerical values(either literals or variables) as their operands and return a single numerical value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3 # Addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 - 2 # Subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 * 2 # Multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 ** 3 # Exponent -> 5**3 is same as 5^3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.3333333333333335"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 / 3 # division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 // 3 # Quotient(integer division) -> it gives only integer part of the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10%3 # modulus -> it gives remainder in integer division "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Assignment Operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### The basic assignment operator is equal (=), which assign he values of its right opearand to its left operand."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "num1 = 5\n",
    "print(num1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Surya Prakash Giri'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = 'Surya Prakash Giri'\n",
    "name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Relational Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Relational operators are used for comparision of two values to understand the type of relationship a pair of number shares. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 > 2 # 1 'is less than' 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > 3 # 5 'is greater than' 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 >= 7 # 9 'is greater than or equal to' 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 <= 1 # 4 'is less than or equal to' 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 == 8.0 # 8 'is equal to' 8.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 != 7 # 7 'is not equal to'7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Logical Operators allow a program to make decision based on multiple condition. The logical operators are -\n",
    "- logical and (&&) : It is used to determine whether both operands or conditions are true.\n",
    "- logical or (||) : It is used to determine whether either of the condition or operands is true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 3 and 4 > 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*3 == 6 or 5/2 == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9>1 and 5<2 or 7*2 != 14"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Syntax Of Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name1: Akash\n",
      "<class 'str'>\n",
      "name2: Surya Prakash\n",
      "<class 'str'>\n",
      "para1: This is\n",
      "an example\n",
      "of paragraph.\n",
      "<class 'str'>\n",
      "num1: 12\n",
      "<class 'int'>\n",
      "float1: 3.4\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# is use for single line comments\n",
    "\n",
    "''' This is \n",
    "a muti-line \n",
    "comments'''\n",
    "\n",
    "name1 = \"Akash\" # name -> 'Akash'\n",
    "print('name1:',name1) # printing the value of name1 \n",
    "print(type(name1))\n",
    "\n",
    "name2 = 'Surya Prakash'\n",
    "print('name2:',name2) # printing the value of name2\n",
    "print(type(name2))\n",
    "\n",
    "para1 = '''This is\n",
    "an example\n",
    "of paragraph.'''\n",
    "print('para1:',para1) # printing the value of para1 \n",
    "print(type(para1))\n",
    "\n",
    "num1 = 12\n",
    "print('num1:',num1) # printing the value of num1 \n",
    "print(type(num1))\n",
    "\n",
    "float1 = 3.4\n",
    "print('float1:',float1) # printing the value of float1 \n",
    "print(type(float1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####    Note- name = 'Suryaprakash' and name = \"Suryaprakash\" are same. we can create string variables either by using single or double quotes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**This tutorial is intended to be a public resource. As such, if you see any glaring inaccuracies or if a critical topic is missing, please feel free to point it out or (preferably) submit a pull request to improve the tutorial. Also, we are always looking to improve the scope of this article. For anything feel free to mail us @ colearninglounge@gmail.com**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The author of this article is Surya Prakash Giri.\n",
    "You can follow him on [Github](https://github.com/Akashgiri963), [Linkedin](https://www.linkedin.com/in/surya-prakash-giri-18024a195), [Instagram](https://instagram.com/suryaprakash_giri)."
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}