Introduction To Python Basics

Relational Operators

Relational operators are used for comparing two values. The relational operators return boolean values.

a,b=10, 5

print(a,b)

print(a>b) # Greater than operator

print(a<b) # Less than operator

print(a>=b) # Greater than or equal to operator

print(a<=b) # Less than or equal to operator

print(a==b) # Equal operator

print(a!=b) # Not equal operator

Logical Operators

Logical operators are used to combine conditional statements.

a1, b1, c1=10, 20, 30 

print(a1, b1, c1)

print(c1>a1 and c1>b1) # “and” operator returns True if both the statements are true

print(a1>b1 and c1>b1) # Returns “False” since a1 is not greater than b1

print(a1>b1 or c1>b1) # Gives “True” as or operator returns True if one of the statements is true

print(not a1>b1) # Reverses the results, returns True if the result is false

Bitwise Operators

Bitwise operators are used to compare binary numbers. The following are some examples of binary operators (&, |, ^, ~, <<, >>).

a,b = 10,5

print(bin(a), bin(b))

print(a & b) # Sets each bit to 1 if both bits are 1

print(bin(a & b))

print(a | b) # Sets each bit to 1 if one of 2 bits is 1

print(bin(a | b))

print(bin(a ^ b)) # Sets each bit to 1 if only one of two bits is 1 

print(bin(~a)) # Inverts all the bits

print(bin(a<<2)) # Shifts left by pushing zeros in from the right and let the leftmost bits fall off

print(bin(a>>2)) # Shift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off

Membership Operators

These operators are used to check if a sequence is present in an object (list, tuples, dictionaries, etc). Examples of such operators are in and not in.

list = [1,2,3,4,5]

x = 2

print(x in list) # Returns True since 2 is present in the list

print(x not in list) # Returns False as the value of x is present in the list

Identity Operators

These operators are used to compare the objects to see if they are the same object with the same memory location. Examples of such operators are “is” and “is not.”

x = 10

y = 10

print(x is y) # Returns True as the values of x and y are the same

print(x is not y) # Returns False

If you change y = 12, then print(x is not y) will return True.

Certain functions are not pre-built into Python, but these functions can be found inside Python Modules. Math is one such module that has a wide collection of mathematical functions. The following link has all the mathematical functions covered in detail: mathematical functions - Python

Some of the basic functions available are ceil(), floor(), factorial(), fabs(), isfinite(), exp(). There are other trigonometric and hyperbolic functions that you can use.

To use these functions, you need to import the math module.

import math

print(math.pi)

You can also import specific functions from the math module.

From math import pi

print(pi)

The following is how to use additional mathematical functions:

import math

X = 9.5

print(ceil(X)) # Returns the nearest integer greater than 9.5

print(math.tan(X))

y = 3

print(math.pow(X,y))

print(math.sqrt(x))

print(math.factorial(y))

Let’s talk about how to accept inputs from the user in Python.

Python has a built-in input() function that has prompt as a parameter, which is a string representing a default message before the input.

name = input(“Enter your name”) # “” represents new line

print(“Hi”, name)

The inline input function always accepts a string.

age = input(“Enter your age”)

print(type(age))

print(age + 5) # Throws an error because  age is a string and 5 is an integer

To add an integer to the age variable, you need to convert it into an integer.

print(int(age) + 5)

print(“%s is %d years old”%(name, int(age)))

Python has a feature that slices the characters from the user input function.

name = input(“Input a word”)[:4]

print(name) # Returns the first four letters of the word

Since you know input() function accepts values as strings, you can explicitly pass inputs in the form of an integer.

a = int(input(“Enter a multiple of 5”))

print(type(a))

Next in this Python tutorial, you will learn the different decision-making statements and loops in Python.

If Statement

The if statement is used to test a specific condition. If the condition is true, a block of code is executed.

a = int(input(“Enter a multiple of 5”))

if a%5 != 0:

    print(a, ‘Not a multiple of 5’)

a = int(input(“Enter a multiple of 5”))

if a%5 != 0:

    print(a, ‘Not a multiple of 5’)

print(“this is what happens next”)

From the above output, you can see that the if statement runs only those lines of code that are indented. An indented line of code in Python has four spaces from the beginning of the line.

Else Statement

The else statement is executed when the expression in the if condition is false.

a = int(input(“Enter a number”))
if a%2 != 0:

    print(a, ‘is an odd number’)

else:

    print(a, ‘is an even number’)

print(“this is what happens next”)

From the above output, since five is not directly divisible by two, we can see that the result is “5 is an odd number.” 

However, since four is divisible by two, the else statement is executed, and the result is “4 is an even number.”

Elif Statement

The elif statement in Python enables you to check multiple conditions and execute specific block of statements if the previous conditions were false.

a = int(input(“Enter a number a”))

b = int(input(“Enter a number b”))

c = int(input(“Enter a number c”))

if a>b and a>c:

    print(a, ‘is the greatest number’)

elif b>a and b>c:

    print(b, ‘is the greatest number’)

else:

    print(c, ‘is the greatest number’)

As you can see, since b>a and b>c, the elif statement is executed.

Nested if: There may be instances where you want to check for another condition after a condition ends up being true. In these cases, you can use nested if statements.

age = int(input(“Enter your age”))

if age >= 60:

    print(“You  are eligible for senior citizen discount”)

else:

    if age <=18:

        print(“You are eligible for minor discount”)

    else:

        print(“You are not eligible for any discount”)  

The following is how a While Loop works in Python:

While Loop: While loop is used to execute a set of statements as long as a condition is true.

word = “Python”

i = 0

while i<5:

    print(i, word)

    i+=1

The above code prints Python five times since the while condition is true until i<5.

You can also use a while loop to add elements to an empty list.

lst = []

c = input(“Enter any key to add elements to list and 0 to exit loop”)

while c != “0”:

    lst.append(c) # Add elements to the empty list until c is not equal to 0

    c = input(“Enter any key to add elements to list and 0 to exit loop”)

print(lst)

For Loop

A for loop in Python is used to iterate over a sequence (list, tuple, set, dictionary, and string).

word = “Python”

for w in range(3):

    print(w, word)

Using for loop, you can print all the elements present in a list in sequence.

lst = [1,2,”hello”,[1,2,3]]

for obj in list: # This will iterate through all the elements in the list and print it one by one

    print(obj)

# Program to count the number of vowels in the input using a for loop:

word = input(“enter word ”)

count = 0

for i in word:

    if i in [‘a’,’e’,’i’,’o’,’u’,’A’,’E’,’I’,’O’,’U’]:

        count += 1

print(“number of vowels in %s is %d”%(word, count))

Break

The break statement terminates the loop before it has iterated through all the items.

fruits = [“apple”, “orange”, “grapes”]

for x in fruits:

    print(x)

    if x == “orange”: # This will break the loop when the element in the list is an orange

        break

Continue

The continue statement will stop the current iteration of the loop, and continue with the next iteration.

fruits = [“apple”, “orange”, “grapes”]

for x in fruits:

    if x == “orange”:

        continue

    print(x)

Below is another example that illustrates how a “continue” statement works:

n = 20

for i in range(2, n//2+1):

    if n%i != 0:

        continue

    print(“%d is divisible by %d”%(n,i))

One of the most useful features of Python is its built-in libraries that make programming easier. With that in mind, we will now be discussing how Array and NumPy works.

Learn data operations in Python, strings, conditional statements, error handling, and the commonly used Python web framework Django with the Python Training course.

Array

Python does not have built-in support for arrays. However, Python; ists can be used instead. An array is a special variable that can hold more than one value at a time.

Syntax: array(data type, value list)

The following example shows how to declare an array:

from array import * # Imports all the sub modules and functions from array module 

ar = array(‘i’, [1,2,3,4,5]) # Here ‘i’ represents an array of integer type

print(type(ar))

print(ar[2])

ar.append(-10) # Adds -10 to end of the array

print(ar)

ar.remove(3) # Removes element 3 from the array list

print(ar)

ar = ar*3 # Multiplies the array elements three times

print(ar)

NumPy

NumPy is a Python library that is used for processing large multi-dimensional arrays and matrices.

If you are working in IDE, you need to use “pip install numpy” to install NumPy. If you are working with Jupyter notebook, you can use “conda install NumPy.”

In PyCharm, you’ll go to File>>>Settings>>>Project>>>Project Interpreter>>>Click on the plus(+) sign on the top right corner and search for NumPy. Click on Install Package.

import numpy as np

ar1 = np.array([1,2,3])

As you can see from the output, this is a 1D array with no commas between the values. It is different from a list that has commas between the values. 

You can create a 2D array as follows:

ar1 = np.array([[1,2,3], [4,5,6]])

print(ar1)

The dimension, size, shape, and type of elements in an array can be checked using the following:

print(“Dimension:”,ar1.ndim)

print(“Size:”,ar1.size)

print(“Shape:”,ar1.shape)

print(“type of elements:”,ar1.dtype)

The following is a link to learn more on NumPy library 

Next, we’ll go over the functions available in NumPy.

To create an array filled with zeroes, you can do the following:

z = np.zeros((2,2),dtype=”int”) # Creates a 2x2 array filled with zeroes

print(z)

You can use the full() function to create an array of any dimension and elements.

z = np.full((2,3),1) # Creates a 2x3 array filled with ones

print(z)

Like lists, arrays in Python can be sliced using the index position.

ar3 = np.array([[1,2,3],[4,5,6],[10,11,12]])

print(ar3[1,2]) # Returns 6 as the output

print(ar3[1,::-1]) # Prints the elements of the second list of the array in reverse order

print(ar3[:2,::-1]) # Prints the elements of the first and second list in reverse order

You can perform arithmetic operations on the elements of an array.

ar3 = np.array([[1,2,3],[4,5,6],[10,11,12]])

print(ar3+10) # Add 10 to all the elements

print(ar3*10) #Multiplies 10 to each element in the array

The NumPy array has other functionalities as well. For instance, you can find the sum, mean, maximum and minimum of the elements in the array.

ar3 = np.array([[1,2,3],[4,5,6],[10,11,12]])

print(ar3.sum()) # Gives the total sum of all the elements

print(ar3[0].sum()) # Returns only the sum of the first list of elements in the array

print(ar3[0].min()) # Return the last element from the first list

The elements in an array can be transposed as well.

ar3 = np.array([[1,2,3],[4,5,6]])

print(ar3)

print(ar3.T)

To return the array into normal form, use:

ar3 = ar3.T

print(ar3.T)

Now let’s continue this Python tutorial by learning about functions in Python. A function is a block of code that only runs when it is called. You can pass data in the form of parameters to a function, and it can return data as a result.

Syntax: def function_name():

                 Block of code  

def fun(): # fun is the function name

    print(“Simplilearn”)

fun() # Calling the function

The following is another example of adding two numbers using a function.

def add(a,b): # Function add accepts two parameters, a and b

    print(a+b)

add(4,5) # It is mandatory to pass the required number of parameters while calling the function

def add(a,b):

    s = a+b

    return s # This returns the value of a+b from the function

n = add(4,5)

print(n)

def add(a,b):

    s = a+b

    d = a-b

    return s, d # Returns two values for addition and subtraction from the function

n1, n2 = add(4,5)

print(n1, n2)

You can also assign values to the parameters while declaring a function.

def add(a=5, b=3):

    s = a+b

    d = a-b

    return s, d 

n1, n2 = add()

print(n1, n2)

*args and **kwargs: These are mostly used in function definitions to pass a variable number of arguments to a function.

*args: In Python, a single asterisk form of *args can be used as a parameter to send a non-keyworded variable-length argument list to functions.

def args_kwargs(*myArgs):

    print(myArgs)

    print(myArgs[1])

args_kwargs(1,2,3,4)

def args_kwargs(*myArgs):

    a = myArgs[0] + myArgs[1]

    return a

a = args_kwargs(1,2,3,4)

print(a) # This returns 3 since myArgs[0]=1 and myArgs[1]=2

**kwargs: The double asterisk form of **kwargs is used to pass a keyworded, variable-length argument dictionary to a function.

def args_kwargs(**myKwargs):

    print(myKwargs) # Prints the values in the form of a dictionary

    print(myKwargs[‘a’]+myKwargs[‘b’])

args_kwargs(a=10, b=20)

def args_kwargs(**myKwargs):

    print(myKwargs)

    if ‘a’ in myKwargs and ‘b’ in myKwargs:

        print(myKwargs[‘a’]+myKwargs[‘b’]) # Won’t print, = as ‘a’ in not present in the function call

args_kwargs(c=10, b=20)

Python allows you to assign the function name to a variable. 

def args_kwargs(**myKwargs):

    print(myKwargs)

    if ‘a’ in myKwargs and ‘b’ in myKwargs:

        print(myKwargs[‘a’]+myKwargs[‘b’]) 

args_kwargs(c=10, b=20)

d=args_kwargs

d(a=1, b=2)

The final Python function that you will learn in this Python basics tutorial is known as Recursive. Recursion is a method of programming in which a function calls itself one or more times in its body.

def rec(n):

    if n==1:

        print(n)

        return

    print(n)

    return rec(n-1)

rec(3)

Recursion can be used to write a function that returns the factorial of a number.

The following code is considered a general way to write a function to return the factorial.

def fact(n):

    f = 1

    for i in range(1, n+1):

        f *= i

    return f

print(fact(3))

Using recursive function to return the factorial of a number:

def fact(n):

    if n==1:

        return 1

    return n * fact(n-1)

print(fact(3))

Learn the essentials of object-oriented programming, web development with Django, and more with the Python Training Course. Enroll now!

Lambda Function

Lambda can take any number of arguments, but can only have one expression.

Syntax: lambda arguments: expression

Here, you will see how a Lambda function works and why it is important.

The following is a Lambda function used to add two numbers passed as an argument, and print the result:

l = lambda a,b : a+b

print(l(10,20))

Next, we’ll go over how to implement filter, map, and reduce a list using the Lambda function.

Filter Function

A filter() function in Python takes in a function and list as arguments. It filters out all the elements of a sequence, for which the function returns True.

list = [‘a’, ‘b’, ‘e’, ‘f’, ‘o’, ‘a’]

l = list(filter(lambda x:x in [‘a’, ‘e’, ‘i’, ‘o’, ‘u’],lst))

print(l)

Map Function

The map() function also takes in a function and list as an argument. A new list is returned, which contains all the Lambda modified items that each item for that function returned. 

The following example is a function that changes every character to the preceding character based on its ASCII value:

lst = [‘a’, ‘b’, ‘e’, ‘f’, ‘o’, ‘a’]

result = map(lambda x:chr(ord(x)+1),lst) # It maps all the letters to its ascii values using ord()

print(list(result))

Reduce Function

Reduce() function accepts a function and a sequence, and returns a single value. This function is defined in the “functools” module.

lst = [‘a’, ‘b’, ‘e’, ‘f’, ‘o’, ‘a’]

result = map(lambda x:chr(ord(x)+1),lst) 

print(list(result))

from functools import reduce

result = reduce(lambda x,y:x+y,lst)

print(result)

So far, we have looked at functions, and the different ways to write them. Now, let’s focus on Modules under the basics of Python.

A module can be considered the same thing as a code library. It is a file containing a set of functions that you want to include in your application.

Suppose there is a file called mod1.py in the same location as the scratch file and it has a prime function, and an even function.

def prime(a):

    for i in range(2,a):

        if a%i == 0:

            print(“Number is not prime”)

            return

    print(“Number is prime”)

def even(a):

    if a%2 == 0:

        print(“Number is even”)

    else:

        print(“Number is odd”)

You can access mod1.py file from the scratch file by importing it.

from mod1 import *

n = int(input(“Enter a number”))

prime(n) # Calling the prime function

even(n) # Calling the even function

Using modules makes your code compact and more readable; you don’t have to read through a hundred lines of code. Furthermore, you can share this module with other people who can utilize it in their projects.

Now that you know the basics of Python programming, it is time to learn about Object Oriented Programming (OOP) and its different features. 

Everything, including every instance, is an object in Python. OOP is a programming paradigm that focuses on objects. An object has Attributes and Behaviour.

An attribute contains the data that describes the object, such as lists, tuples, arrays, variables.

The behavior has methods applied to the attributes.

Here is an example of a car that has the following attributes and behaviors:

Class

A class in OOP is a collection of similar objects.

Inheritance

The inheritance mechanism in Python is one of the most important features of OOP. It allows a new class to inherit the features of another class. 

Example: There can be a “vehicles” class, and under vehicles, there is a class called “car.” Here, “vehicles” are called the parent class and “car” is the child class. A car can inherit all the functions and features of vehicles.

Encapsulation

This is the feature of preserving data from direct access.

Polymorphism

Polymorphism is a feature that lets you use the same function in multiple ways.

Suppose you have vehicles and bicycles. Bicycles accelerate very differently than a car does; a car runs on fuel and a bicycle has pedals. Both of them can accelerate but are used differently.

The following example explains the concept of Object-Oriented Programming:

class Car:

    carType = “manual” # global feature

    def __init__(self, year, speed): #__init()__ is executed when the function is being initiated

        self.year=year # creating an instance

        self.speed=speed

    @staticmethod

    def welcome():

        print(“Welcome to the car showroom”)

    @classmethod

    def type(cls):

        print(print(“These cars are”, cls.carType))

    def getSpeed(self):

        print(“Maximum speed is”, self. speed)

BMW = Car(2018, 155)

Ford = Car(2016, 140)

Car.welcome()

BMW.getSpeed()

Ford.getSpeed()

Car.type()

The following is an example of Inheritance:

class Car:

    def __init__(self, year, speed): 

        self.year=year # creating an instance

        self.speed=speed

    def getSpeed(self):

        print(“Maximum speed:”, self.speed)

class Sedan(Car): # Sedan inherits the features of Car

    pass

BMW = Car(2018, 155)

Ford = Car(2016, 140)

BMW.getSpeed()

In the last section of this Python basics tutorial, let’s look at an example showing how to implement Polymorphism in Python.

class Car:

    def __init__(self,name):

        self.name=name

class Sedan(Car):

    def getSpeed(self):

        print(“Maximum speed 150”)

class SUV(Car):

    def getSpeed(self):

        print(“Maximum speed 120”)

carLst = [Sedan(“Camry”), SUV(“Scorpio”)]

for car in carLst:

    print(car.name + “:”,end= “”)

    car.getSpeed()

You can see we have polymorphed car class into Sedan and SUV and inherited the functionalities of car class.

Looking forward to making a move to the programming field? Take up the Python Training Course and begin your career as a professional Python programmer

Conclusion

This Python tutorial should give readers a better understanding of all basic Python concepts, including different conditional statements, handling data using NumPy, how to write a function, how to create a module, how to implement different features of Object Oriented Programming using classes and objects, and more.

For a more hands-on experience, go through this Simplilearn video on “Python Tutorial” delivered by our Data Science experts that covers the Python structure. 

How Simplilearn Can Help You

Simplilearn’s Python Training Course is an all-inclusive program that will introduce you to the increasingly popular Python development language and expose you to the essentials of Object-Oriented Programming, web development with Django, and game development. 

Learning Python also opens up even more career advancement opportunities, as it’s used widely in the field of software development, one of the most popular career options that professionals choose today. If this Python tutorial has piqued your interest, why not check out our other Software development courses, like Java Certification Training and Full Stack Developer course to learn more.