Quick Refresh of Python Basics

Download latest version of python from Python Website.

Previous versions also can be downloaded from here. Install python by running the downloaded .exe file. Check for successful installation by opening command prompt and typing python --version

Output will be the current version of python like Python 3.10.0

Python interpreter helps writing python code in the command line itself.

To open python interpreter, type python.

Interpreter will become enabled with below message and >>> symbol.

    Python 3.10.0 (tags/v3.10.0:b494f59, Oct  4 2021, 19:00:18) [MSC v.1929 64 bit (AMD64)] on win32
    Type "help", "copyright", "credits" or "license" for more information.
    >>>

We can write python code next to >>>
Code that needs multiple lines are denoted by ...
... automatically comes for multi-line commands like if, for.

    >>> age = 70
    >>> if age < 18:
    ...     print("Young")
    ... elif age >=18 and age < 60:
    ...     print("Adult")
    ... else:
    ...     print("Old")
    ...
    Old

To exit interpreter, type Ctrl+Z then Enter.

This launcher is used for Windows OS.
py.exe launcher can be used for executing code under different versions.
Type py to check if launcher is installed. Will display latest python version. Some sample usages below.

For Windows.

For Linux, macOS, etc we can do this by using below commands and py launcher is not required.

Python uses variables to hold data. Data can be of different types. Python has 3 basic data types.

Numeric types are:

Same variables can be used for different datatypes. Below example works fine.

    a= 10
    a = "Test String"

String datatype is used to hold texts. String values should be placed within "". Strings can be manipulated using built-in functions.
Some examples below. Consider a string: s = " This is a string "

To combine string and non-string values, use string formatting as shown below.

    num = 30
    text = "Text is combined with number {}"
    print(text.format(num))

Easier way of combining multiple values. Uses {} as place holders. Within bracket we can provide name or index.
Format type option can be provided as second parameter.
Some common formats are decimal(:d), number(:n), percentage(:%). Number of decimal places to display can be indicated after :.
Examples below:

    s1 = "String with 2 values: {0} and {1}".format("One", 2)
    s2 = "String with 2 values: {first} and {second}".format(first ="One", second =2)
    print (s1)
    print (s2)
    marksPercent = "Marks Percent is {:.1%}"
    print(marksPercent.format(0.7522))

For more, click Python String Formatting.

Python provides built-in functions to convert data types. int(), float(), str()
Examples below:

    n1 = 10 #integer datatype
    n2 = 20.25 #floating datatype
    n3 = 20 + 5J #complex datatype
    print("Type of " + str(n1) + " is ", type(n1))
    print("Type of " + str(n2) + " is ", type(n2))
    print("Type of " + str(n3) + " is ", type(n3))
    n1 = float(n1)
    n2 = int(n2)
    n3 = str(n3)
    print("After casting " + str(n1) + " is {0} type".format(type(n1)))
    print("After casting " + str(n2) + " is {0} type".format(type(n2)))
    print("After casting " + str(n3) + " is {0} type".format(type(n3)))

Arithmetic operators are provided for performing all the basic arithmetic operations.
These are +, -, *, /, %, **, //
% is modulus operator which returns reminder of division
** is exponential operator (2 ** 3 = 2 * 2 * 2 = 8)
// is floor division. decimal part is skipped and integer value returned

Assignment operator is used to assign value to a variable.
a = 25

Comparison operators are used to compare 2 variables and return a Boolean result (True or False).
These are +, -, *, /, %, **, //
== equal to
!= not equal to
< less than
> greater than
<= less than or equal to
>= greater than or equal to

Logical operators are used to perform logical operations.
Samples below:

    n1 = 10
    n2 = 5
    n3 = 15
    n4 = 15
    print (n1 == n2 and n3 == n4)#'Both should be true to return True'
    print (n1 == n2 or n3 == n4)#'Atleast one should be true to return True'
    print(not(n3 == n4))#'If n3 is equal to n4 then False is returned'

Date is not considered as a data type in python. To work with dates, we can import datetime package.

    import datetime
    print(datetime.datetime.now())
    print(datetime.datetime.now().year)

New date objects can be created like:

    dt = datetime.datetime(2021, 3, 25)

Use strftime() to get parts of date in different formats.

   print(dt.strftime("%m"))

Some options mentioned using above example:
%d - 25, %b - Mar, %B - March, %y - 21, %Y - 2021

Math functions can be applied on numeric datatypes.
Need to import Math module.
Important ones are:

   floor(), isfinite(), isnan(), pow(x, y), min(), max(), abs(), ceil()

Some constants like math.pi, math.nan are also available.

Data structures are used to hold a collection of data into a single variable and manipulate these with associated built-in functions.
3 main groups are:

A quick comparison:

Samples:

myList = ["text1", 5, True, "Text2", "Text2"]

myTuple = ("text1", 5, True, "Text2", "Text2")

myRange = range(3, 10)

myDictionary = {"key1":"text1", "key2":5, "key3":True, "key4":"text2", "key1":"new text"}

mySet = {"text1", 5, True, "Text2", "Text2"}

myFrozenSet = frozenset(mySet)#'list, tuple, set can be frozen

List comprehensions are pythons short way of creating a new list from existing.
This allows to filter lists to create a new list with a single line of code.
Can be applied on any iterable. ie, Data structures or strings.

Following example filters out even numbers from an existing list and create a new list:

    num = [5, 10, 7, 25, 34, 15, 20, 38, 45, 50]
    even = [e for e in num if e%2 == 0]
    print(even)

Single line comments. Use #

   #This is a comment

Multi-line comments. Use """ ..... """ or ''' ..... '''

    """
        Comment line 1
        Comment line 2
    """

Python has option to do conditional checks using if---elif---else statements.
Boolean values are expected in the if---else conditions. ie, Comparison and logical operations can be used here as in example below.

    age = 15
    if age < 18:
        print("Young")
    elif age >=18 and age < 60:
        print("Adult")
    else:
        print("Old")

match...case is a different way of conditional flow. Use this feature to check for a particular value rather than a comparison or logical operation.
This is a new feature. Example below.

count = 5
match count:
    case 1:
        print("I have 1 pen")
    case 2:
        print("I have 1 pens")
    case _:
        print("I have more than 3 pens")

case _: is the default case, if none of the above cases match.

Python has 2 looping statements. while, for.
while is used if don't have a particular sequence and we want to loop till a particular condition is satisfied.
for is used to iterate through data structures or characters in a string.
Examples below

    ticks = 0
    while ticks < 5:
        ticks = ticks + 1
        print("Tick " + str(ticks))    

    myList = ["text1", 5, True, "Text2", "Text2"]
    for l in myList:
        print(l)   

break is used to exit from loops.
continue is used to skip lines below and continue with next iteration.
pass can be used to declare an empty block. To do nothing for a particular action.

    if age < 1:
        pass

Functions are a set of actions that can be performed when called. Functions are defined using def keyword. Can have 0 or more parameters. Function can return any datatypes or data structures.

    def findSum(a, b):
        return a+ b

    s = findSum(5, 2)
    print(s)

If number of input args are expected to change, we an put a * symbol to indicate that and pass any number of args.
Example below:

    def findSum(*a):
        s = 0
        for l in a:
            s = s + l
	
        return s

    s = findSum(5, 2, 3, 10)
    print(s)

Python allows setting default values to a parameter and also keyword arguments.

Lambda is a single lined anonymous function. Lambda functions can accept any number of arguments. Can be called using the variable name it is assigned to.
Syntax: lambda commaseparatedargs : operation
Example:

    sum = lambda a, b, c : a + b + c
    print(sum(10, 20, 50))

Classes can be considered as a template with a set of predefined properties and functions. Properties are variables that holds values. Functions are a set of actions that we do to get a desired outcome.

To use classes, we create objects from it. Objects are the instances of a class and any number of objects can be created from a class template. Objects can hold values for all the class properties and can call the class functions to do a particular type of action.

Sample Class:

Consider a school with lots of students. Each student will be having different name, date of birth, grade, etc. They will be studying different subjects.
It may be required to perform different action like calculate age based on date of birth, calculate marks, etc. So we can create a class template with name, dob as properties and calculateAge(), calculateMarks() as functions. This template can be used to represent all the students as objects.

__init__() is the first method that is getting called on creating an object and it is mandatory for all classes. This can be used to initialize the variables.

Values can be assigned at the time of creating object, which uses __init__() method or by calling objectName.property. Similarly, functions are called as objectName.functionName().

Sample code below:

import datetime

class Student:
    def __init__(self, name, dob, gender, grade):
        self.name = name
        self.dob = dob
        self.gender = gender
        self.grade = grade
        self.subjects = ["Maths"]

    def calculateAge(self):
        d = datetime.datetime.today()
        years = d.year - self.dob.year - ((d.month, d.day) < (self.dob.month, self.dob.day))
        return years
    
    def calculateMarks(self):
        marks = 100
        #Do some action here
        return marks

student1 = Student("John", datetime.date(2005,10, 22), "M", 10)
print("Age of {} is {}".format(student1.name, student1.calculateAge()))
student1.subjects.append("Chemistry")
print("{} studies {}".format(student1.name, student1.subjects))

student2 = Student("Tom", datetime.date(2007,5, 15), "M", 8)
print("Age of {} is {}".format(student2.name, student2.calculateAge()))
student2.subjects.remove("Maths")
student2.subjects.append("History")
print("{} studies {}".format(student2.name, student2.subjects))

Python supports inheritance. Parent class features can be assessed to child class by inheriting.

    class Parent:
        def __init__(self):
            print("Parent Constructor")
        def parentFunc(self):
            print("Parent Function")
    class Child(Parent):
        def __init__(self):
            print("Child Constructor")
            super().__init__()
        def childFunc(self):
            print("Child Function")
    c = Child()
    c.parentFunc()

As in above sample, child objects can access parent functions and properties.
Python supports multiple and multilevel inheritance.
super() function can be used to access parent functions and variables from child class.

Error handling blocks are as below

    try:
	    #Some code here
    except:
	    #exception block here
    else: 
	    #steps to execute if no error occurs
    finally:
	    #executes regardless of error or not

Same variable name is possible as global and local within the same module.
To access a global variable from within a function, use keyword global.

Iterators are objects that can be looped using for statement.
Data structures and string datatype are iterable using for loop, which will access each element at a time, in case of string each character.
Iterable objects implements iterator, that has functions iter() and __next__()
iter() returns a loopable object in back-end.
__next__() access one element at a time till end. After that StopIteration() exception is raised.

When using for loop, these steps happen in behind the scenes and we need not worry about these while implementing.

A normal function returns the result as a single unit. It can return any basic data type or a data structure such as list.
A generator is also a kind of function. Difference is that generator return a single item of a loopable object (strings or data structures) at a time.
Advantage of generator over a function is that generators are iterable and we can use it directly in a for loop.
Generators can be implemented using yield keyword.
See example below which calculates sum till the entered number.

    def sumTill(num):
        i = 0
        j = 0
        for n in range(num):
            j += 1
            i = i + j
            if (j > num):
                break
            yield "Sum of numbers from 0 to {0} = {1}".format(j, i);

    for n in sumTill(5):
        print (n)

Python comes with a set of standard packages which we can you in our modules just by importing them. For example, datetime module helps us to work with dates easily. These packages come with the python installation, and we don't have to install them separately. Some of the most important and most used built-in packages are:

Third party libraries are the modules/packages developed by other users that can be used in our modules.
First, we need to install these using the command pip install <Packagename>
Then we can use its functionalities by importing it to our modules.

Modules can be considered as a group of statements kept together in a single file. As our programs become larger, keeping similar sections as a module helps in better organizing the code. It helps in re-usability as well.
In python module is usually a single file saved as .py
Below example shows how to create module and add some functions to it and reuse it in a different module.
Create a file named myModule.py and add below code. As seen here, it has 2 functions.

    def myFunc1():
        print("This is myFunc1() of myModule")

    def myFunc2(val):
        print("This is myFunc2() of myModule with input {}".format(val))

One function has empty parameters and the other has one input parameter.
Now create a new file testMyModule.py in the same folder and add below code.

    import myModule

    myModule.myFunc1()

    myModule.myFunc2(1)
    myModule.myFunc2("test")

Running the test module will get you the below output.

It is important to note that the module that you create should be within same folder of the file that you are using it. Or we can place our modules in the folder mentioned in the sys.path environment variable.

Packages can be considered as a collection of modules. A package can contain multiple folders inside, each containing multiple modules.
We can import the entire package to a new module by using command: import <packageName>
Or a particular module only within the package using: import <packageName>.<moduleName>
Packages should be placed in the same folder or in the sys.path.

All the open source and licensed packages are listed in Python Package Index repository. We can use the pip command to install a package which is available in this repository.

To install python -m pip install PackageName
For specific version python -m pip install PackageName==3.0.2
For min version python -m pip install PackageName>=3.0.2
For upgrade python -m pip install -upgrade PackageName

To use older python versions:

Python has built-in functions to work with some type of files like .txt. For other types we can use third-party libraries like python-docx for word documents or openpyxl for excel worksheets.

To get user input from console use input() function.
To display result, use print()

    age = input("Enter Age : ")
    print(age)

Python has json standard library to work with json strings. It provides mainly 2 methods.
To read from json use loads().

    import json
    jsonStr = '{"employees" : [{"name" : "Tim", "role" : "CEO"}, {"name" : "Tiffany", "role" : "Manager"}, {"name" : "Eric", "role" : "Associate"}]}'
    jsn = json.loads(jsonStr)
    print(len(jsn["employees"]))
    print(jsn["employees"][0]["name"])

To convert objects to json use dumps().

    lst = ["Car", "Bus", "Bike", 1, 2, True]
    a = json.dumps(lst)
    print (a)

Data types strings, int, float, bool and data structures list, tuple, dict are serializable.
Complex numbers cannot be serialized. So is set data structure.

When we install a package for our project, it gets copied to site_packages folder mentioned in pythonpath. When we work with multiple projects, there may be scenarios that require different versions of a third-party package for these projects. While installing a package, there are chances that older version gets uninstalled and may be some other conflicts that can occur. This may result in one or more of your projects to stop working. This is where virtual environment becomes useful.
Virtual environments can be considered as a separate directory where all your project related files are stored and not depend on the common python installation locations.
To create virtual environment: Navigate to the folder from comment prompt and type:

This command will create some folders like Include, Lib, Scripts and varies depending on OS. All our pip installations will be kept in Lib/site-packages folder. Scripts folder has activate.bat file.

Next step is to activate the VE using command:

Now we can execute all python commands in this virtual environments like installing package, running a module, etc.

In some cases, when we try to install packages in virtual environments using pip commands, we will get an error like: pip not found.

To fix this, run the below command:

Some of the packages may not be working in latest version of Python. If so, we have to setup everything for older python version, including virtual environment. Use the below commands. This sample sets up Python 3.9 virtual environment.

Sys.path are the folder locations that python will search for, for the installed packages when a project runs. Our referenced packages should be available in any of these paths in order for our projects to run. Run below command in interpreter to see the paths.

    import sys
    sys.path
    
    ['', 'C:\\Users\\<UserName>\\AppData\\Local\\Programs\\Python\\Python310\\python310.zip',
    'C:\\Users\\<UserName>\\AppData\\Local\\Programs\\Python\\Python310\\DLLs',
    'C:\\Users\\<UserName>\\AppData\\Local\\Programs\\Python\\Python310\\lib',
    'C:\\Users\\<UserName>\\AppData\\Local\\Programs\\Python\\Python310',
    'C:\\Users\\<UserName>\\AppData\\Roaming\\Python\\Python310\\site-packages']

Pythonpath is an environment variable that we can set to add additional paths for our projects, which can contain python modules that we use in our project.