Object Oriented Programming (OOP)

1. Introduction to Python
Programming
• Python can be used for a wide range of applications, including web development,
scientific computing, data analysis, artificial intelligence, and more. It is also a
popular language for scripting and automation, due in part to its simplicity and ease
of use.

• Python is a high-level, interpreted programming language

• It is known for its simplicity, readability, and ease of use, which make it an ideal
language for beginners and experts alike.

• Python has a large and active community, which means that there are many libraries,
frameworks, and tools available to extend its functionality.
Key features of Python
• Easy to learn: Python has a simple and easy-to-understand syntax that makes it
easy to learn and use.
• Interpreted: Python is an interpreted language, which means that you can run your
code directly without needing to compile it first.
• Object-Oriented: Python supports object-oriented programming (OOP), which allows
you to create classes and objects that encapsulate data and behavior.
• Cross-platform: Python runs on many operating systems, including Windows, macOS,
and Linux, which makes it a versatile language.
• Large standard library: Python comes with a large standard library that provides
many useful functions and modules for tasks such as file I/O, networking, and web
development.
More aspects of Python programming:
• Rapid development: Python's simplicity and ease of use make it an ideal
language for rapid development, which can save time and money in the
software development process.
• Web frameworks: Python has several popular web frameworks, such as
Django, Flask, and Pyramid, which make it easy to develop web applications.
• Database connectivity: Python can connect to a wide range of databases,
including MySQL, PostgreSQL, and MongoDB, which makes it a popular
language for database-driven applications.
• GUI development: Python can be used to develop graphical user interfaces
(GUIs) using popular toolkits such as Tkinter, PyQt, and wxPython.
More aspects of Python programming:
• Packaging and distribution: Python makes it easy to package and distribute
your code as libraries, modules, or standalone applications.
• Standardization: Python has a standardized coding style and coding
conventions, which makes it easy for developers to read and understand each
other's code.
• Documentation: Python has a built-in documentation system called Docstrings,
which makes it easy to document your code and generate documentation for
others to use.
• Community-driven development: Python is developed by a community of
volunteers who work together to maintain and improve the language, which
ensures that it continues to evolve and improve over time.
Follow the following steps to run Python on your
computer.

• Download and install Anaconda or Thonny IDE.

• Go to: File > New. Then save the file with .py
extension. For example,
hello.py
The file name should end with .py
• Write Python code in the file and save it.
Python Indentation
Most of the programming languages like C, C++, and Java use
braces { } to define a block of code. Python, however, uses
indentation.

for i in range(1,11):
print(i)
if i == 5:
print(“hello”)
break

if True:
print('Hello’)
a = 5

if True: print('Hello'); a = 5
Python Indentation
In Python, indentation is used to denote blocks of code. Python does
not use braces or semicolons to delimit blocks. Instead, Python relies on
the use of whitespace (spaces or tabs) to indicate the start and end of
blocks of code.

class Triangle(Polygon):
def __init__(self):
Polygon.__init__(self,3)

def findArea(self):
a, b, c = self.sides
# calculate the semi-perimeter
s = (a + b + c) / 2
area = (s*(s-a)*(s-b)*(s-c)) ** 0.5
print('The area of the triangle is %0.2f' %area)
Docstrings in Python
Python docstrings (documentation strings) are the string literals that
appear right after the definition of a function, method, class, or
module.
For example:
def double(num):
"""Function to double the value"""
return 2*num
The docstrings are associated with the object as their __doc__
attribute.
So, we can access it:

print(double.__doc__)

Output
Function to double the value
Constants

A constant is a type of variable whose value cannot be

changed.

In Python, constants are usually declared and assigned in a

module.

The module is a new file containing variables, functions, etc

which is imported to the main file. Inside the module,
constants are written in all capital letters
Example: Create a file constant.py:

PI = 3.14
GRAVITY = 9.8

Create a new file main.py:

import constant

print(constant.PI)
print(constant.GRAVITY)
Data types in Python
- Python Numbers: int, float and complex

a = 5
print(a, "is of type", type(a))
Output: 5 is of type <class 'int'>

a = 2.0
print(a, "is of type", type(a))
Output: 2.0 is of type <class 'float'>
Python List
List is an ordered sequence of items.

In Python programming, a list is created by placing all the items (elements)

inside square brackets [], separated by commas.

It is one of the most used datatype in Python and is very flexible.

# empty list
my_list = []

# list of integers
my_list = [1, 2, 3]

# list with mixed data types

my_list = [1, "Hello", 3.4]

# nested list
my_list = ["mouse", [8, 4, 6], ['a’]]
Python List
List Indexing
# List indexing
my_list = ['p', 'r', 'o', 'b', 'e’]
print(my_list[0])
print(my_list[2:4])# elements 3rd to 5th
print(my_list[:-2])# elements beginning to 2nd last
print(my_list[-1]) # print the last item
print(my_list[-2]) # print the second last item
Python List
How to change or add elements to a list?
# Correcting mistake values in a list
odd = [2, 4, 6, 8]

# change the 1st item

odd[0] = 1

print(odd)

# change 2nd to 4th items

odd[1:4] = [3, 5, 7]

print(odd)
Python List
How to change or add elements to a list?
# Appending and Extending lists in Python
odd = [1, 3, 5]

odd.append(7)

odd.extend([9, 11, 13])

We can also use + operator to combine two lists. This is also called concatenation.

print(odd + [9, 7, 5])

odd.insert(1,3)

del my_list[2]
del my_list[1:5] # delete multiple items
del my_list # delete entire list
Python List
Python List Methods

append() - Add an element to the end of the list

extend() - Add all elements of a list to the another list

insert() - Insert an item at the defined index

remove() - Removes an item from the list

pop() - Removes and returns an element at the given index

clear() - Removes all items from the list

index() - Returns the index of the first matched item

count() - Returns the count of the number of items passed as an argument

sort() - Sort items in a list in ascending order

reverse() - Reverse the order of items in the list

copy() - Returns a shallow copy of the list

Python List
List Comprehension: Elegant way to create new List

List comprehension is an elegant and concise way to create a new list from an
existing list in Python.

A list comprehension consists of an expression followed by for statement inside

square brackets.

Here is an example to make a list with each item being increasing power of 2.

pow2 = [2 ** x for x in range(10)]

print(pow2)

Output

[1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

This code is equivalent to: pow2 = []

for x in range(10):
pow2.append(2 ** x)
Python List
Other List Operations in Python

my_list = ['p', 'r', 'o', 'b', 'l', 'e', 'm']

print(len(my_list))

# Output: True
print('p' in my_list)

# Output: False
print('a' in my_list)

print('c' not in my_list) # Output: True

print(my_list.count('m')) # occurrences of m, Output: 1

print(my_list.index('e')) # Output: 5
Python List
Iterating Through a List

for fruit in ['apple','banana','mango']:

print("I like",fruit)
- Python Tuple

Tuple is an ordered sequence of items same as a list. The only difference

is that tuples are immutable.
Tuples once created cannot be modified.
It is defined within parentheses ( ) where items are separated by
commas.

t = (5,'program', 1+3j)

print("t[1] = ", t[1])

Output: t[1] = program

print("t[0:3] = ", t[0:3])

Output: t[0:3] = (5, 'program', (1+3j))
Python Tuple
A tuple in Python is similar to a list but we cannot change the elements
# tuple with mixed datatypes
my_tuple = (1, "Hello", 3.4)
print(my_tuple)

A tuple can also be created without using parentheses.

my_tuple = 3, 4.6, "cat"

print(my_tuple)

Having one element within parentheses is not enough. We will need a trailing comma:
my_tuple = ("hello")
print(type(my_tuple)) # <class 'str'>

# Creating a tuple having one element

my_tuple = ("hello",)
print(type(my_tuple)) # <class 'tuple'>
Python Tuple
We cannot change, add, delete or remove items from a tuple
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# Can delete an entire tuple

del my_tuple

Tuple Methods

my_tuple = ('a', 'p', 'p', 'l', 'e',)

print(my_tuple.count('p')) # Output: 2

print(my_tuple.index('l')) # Output: 3

print('a' in my_tuple) # Output: True

print('g' not in my_tuple) # Output: True

- Python Strings
String is sequence of Unicode characters.
We can use single quotes or double quotes to represent strings.
Multi-line strings can be denoted using triple quotes, ''' or """.

s = "This is a string"
s = '''A multiline
string'''

s = 'Hello world!'

print("s[4] = ", s[4])

Output: s[4] = o

print("s[6:11] = ", s[6:11])

Output: s[6:11] = world
Python Strings
my_string = '''Hello'''
print(my_string)

# triple quotes string can extend multiple lines

my_string = """Hello, welcome to
the world of Python"""
print(my_string)

str = 'programing'
#first character
print('str[0] = ', str[0])

#last character
print('str[-1] = ', str[-1])

#slicing 2nd to 5th character

print('str[1:5] = ', str[1:5])

#slicing 6th to 2nd last character

print('str[5:-2] = ', str[5:-2])
Python Strings
How to change or delete a string?

my_string = 'programiz'
my_string[5] = 'a'
del my_string[1]
del my_string

Concatenation of two or more strings

# Python String Operations
str1 = 'Hello'
str2 = 'World!'

# using +
print('str1 + str2 = ', str1 + str2)

# using *
print('str1 * 3 =', str1 * 3)
Python Strings
Iterating through a string
count = 0
for letter in 'Hello World':
if(letter == 'l'):
count += 1
print(count,'letters found')

String Membership Test

Print('a' in 'program')
True
Print('at' not in 'battle')
False

String Reverse
x = "abc"
x[::-1]

Output:
‘cba’
Python Strings
Built-in functions to Work with Python
Various built-in functions that work with sequence (list) work with strings as well.

The enumerate() function returns an enumerate object.

len() returns the length of the string.

str = 'cold'

# enumerate()
list_enumerate = list(enumerate(str))
print('list(enumerate(str)) = ', list_enumerate)

#character count
print('len(str) = ', len(str))

Output:
list(enumerate(str) = [(0, 'c'), (1, 'o'), (2, 'l'), (3, 'd')]
len(str) = 4
Python Strings
Python String Formatting
Escape Sequence
If we want to print a text like He said, "What's there?"

print("He said, "What's there?"")

...
SyntaxError: invalid syntax
print('He said, "What's there?"')
...
SyntaxError: invalid syntax

# using triple quotes

print('''He said, "What's there?"''')

# escaping single quotes

print('He said, "What\'s there?"')

# escaping double quotes

print("He said, \"What's there?\"")
Python Strings
Here is a list of all the escape sequences supported by Python.

Escape Sequence Description

\newline Backslash and newline ignored
\\ Backslash
\' Single quote
\" Double quote
\a ASCII Bell
\b ASCII Backspace

\f ASCII Formfeed

\n ASCII Linefeed

\r ASCII Carriage Return

\t ASCII Horizontal Tab

\v ASCII Vertical Tab

\ooo Character with octal value ooo

\xHH Character with hexadecimal value HH

Python Strings
Escape sequences Examples:

print("C:\\Python32\\Lib")
C:\Python32\Lib

print("This is printed\nin two lines")

This is printed
in two lines

print("This is \x48\x45\x58 representation")

This is HEX representation
Python Strings
Sometimes we may wish to ignore the escape sequences inside a string.
To do this we can place r or R in front of the string.

Examples:

>>> print("This is \x61 \ngood example")

This is a
good example

>>> print(r"This is \x61 \ngood example")

This is \x61 \ngood example
Python Strings
The format() Method for Formatting Strings

# formatting integers
print("Binary representation of {0} is {0:b}".format(12))
'Binary representation of 12 is 1100'

# formatting floats
print("Exponent representation: {0:e}".format(1566.345))
'Exponent representation: 1.566345e+03'

# round off
print("One third is: {0:.3f}".format(1/3))
'One third is: 0.333'

# string alignment
print("|{:<10}|{:^10}|{:>10}|".format('Apple','Orange','Mango'))
'|Apple | Orange | Mango|'
Python Strings
Common Python String Methods

str1= "PyTHon"
print(str1.lower())

print(str1.upper())

str2 ="This will split all words into a list"

print(str2.split())

str3= " "

str3.join(['This', 'will', 'join', 'all', 'words', 'into', 'a',
'string'])

str4 = "Introduction to Python Programming"

print (str4.find("tho"))

str4=str4.replace("Introduction to", "Advanced")

print (str4)
- Python Set
• Set is an unordered collection of unique items.
• Set is defined by values separated by comma inside braces { }. Items in a set are
not ordered.
• Since, set are unordered collection, indexing has no meaning. Hence, the slicing
operator [ ] does not work.

a = {5,2,3,1,4}

print("a = ", a)
Output: a = {1, 2, 3, 4, 5}

# data type of variable a

print(type(a))

Output: <class 'set'>

We can perform set operations like union, intersection on two sets.

Sets have unique values. They eliminate duplicates.

a = {1,2,2,3,3,3}
print(a)
Output: {1, 2, 3}
Python Sets
A set is created by placing all the items (elements) inside curly braces {}, separated by comma, or by
using the built-in set() function.

my_set = {1, 2, 3}
print(my_set)

# set of mixed datatypes

my_set = {1.0, "Hello", (1, 2, 3)}
print(my_set)

my_set = set([1, 2, 3, 2])

print(my_set)

Output:

{1, 2, 3}
{1.0, (1, 2, 3), 'Hello’}
{1, 2, 3}
Python Sets
Creating an empty set is a bit tricky.

# initialize a with {}
a = {}

# check data type of a

print(type(a))
Output: <class 'dict'>

# initialize a with set()

a = set()

# check data type of a

print(type(a))
Output: <class 'set'>
Python Sets
Modifying a set in Python

my_set = {1, 3}

my_set.add(2)

print(my_set)

my_set.update([2, 3, 4])

# add list and set

my_set.update([4, 5], {1, 6, 8})

print(my_set)
Python Sets
Removing elements from a set

my_set = {1, 3, 4, 5, 6}
my_set.discard(4)
my_set.remove(6)
my_set.discard(2)
print(my_set)

discard() function leaves a set unchanged if the element is not present in the set

remove() function will raise an error if element is not present in the set
Python Sets
pop() and clear()

my_set = set("HelloWorld")
print(my_set) {'H', 'e', 'd', 'r', 'W', 'l', 'o'}

# pop an element
# Output: random element
print(my_set.pop())
H
# pop another element
my_set.pop()
print(my_set) {'d', 'r', 'W', 'l', 'o'}

# clear my_set
# Output: set()
my_set.clear()
set()
print(my_set)
Python Sets
Python Set Operations

Set Union
Union of A and B is a set of all elements from both sets.

# Set union method

# initialize A and B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# use | operator
# Output: {1, 2, 3, 4, 5, 6, 7, 8}
print(A | B)

A.union(B)
B.union(A)
Python Sets
Python Set Operations

Set Intersection
Intersection of A and B is a set of elements that are common in both the sets.
Intersection is performed using & operator. Same can be accomplished using the
intersection() method.

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

print(A & B)
print(A.intersection(B))
print(B.intersection(A))
Python Sets
Python Set Operations

Set Difference
Difference of the set B from set A (A - B) is a set of elements that
are only in A but not in B. Similarly, B - A is a set of elements in B
but not in A.

Difference is performed using - operator. Same can be

accomplished using the difference() method.

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

print(A - B)
print(A.difference(B))
print(B.difference(A))
Python Sets
Python Set Operations

Set Symmetric Difference

Symmetric Difference of A and B is a set of elements in A and B but not
in both (i.e. excluding the intersection).

Symmetric difference is performed using ^ operator. Same can be

accomplished using the method symmetric_difference().

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

print(A ^ B)
print(A.symmetric_difference(B))
print(B.symmetric_difference(A))
Python Sets
Python Set Operations

Other Python Set Methods

Method Description
Add() Adds an element to the set
clear() Removes all elements from the set
copy() Returns a copy of the set
difference() Returns the difference of two or more sets as a new set
difference_update() Removes all elements of another set from this set

discard() Removes an element from the set if it is a member. (Do nothing if the element is not in set)

intersection() Returns the intersection of two sets as a new set

intersection_update() Updates the set with the intersection of itself and another
isdisjoint() Returns True if two sets have a null intersection
issubset() Returns True if another set contains this set
issuperset() Returns True if this set contains another set

pop() Removes and returns an arbitrary set element. Raises KeyError if the set is empty

remove() Removes an element from the set. If the element is not a member, raises a KeyError

symmetric_difference() Returns the symmetric difference of two sets as a new set

symmetric_difference_update() Updates a set with the symmetric difference of itself and another

union() Returns the union of sets in a new set

update() Updates the set with the union of itself and others
Python Sets
Python Set Operations

Set Membership Test

my_set = set("apple")
print('a' in my_set) # True
print('p' not in my_set) # False

Iterating Through a Set

for letter in set("apple"):

print(letter)
Python Sets
Python Set Operations

Built-in Functions with Set

Function Description
all() Returns True if all elements of the set are true (or if the set is empty). print(all(my_set))
any() Returns True if any element of the set is true. If the set is empty, returns False.
enumerate() Returns an enumerate object. It contains the index and value for all the items of the set as a pair.
len() Returns the length (the number of items) in the set.
max() Returns the largest item in the set.
min() Returns the smallest item in the set.
Sorted() Returns a new sorted list from elements in the set(does not sort the set itself).
Sum() Returns the sum of all elements in the set.
Python Sets
Python Set Operations

Python Frozenset
Frozenset is a new class that has the characteristics of a set, but its elements cannot be changed once
assigned. While tuples are immutable lists, frozensets are immutable sets.

Sets being mutable are unhashable, so they can't be used as dictionary keys. On the other hand,
frozensets are hashable and can be used as keys to a dictionary.

Frozensets can be created using the frozenset()function.

This data type supports methods like copy(), difference(), intersection(),

isdisjoint(), issubset(), issuperset(), symmetric_difference() and union().

Being immutable, it does not have methods that add or remove elements.

A = frozenset([1, 2, 3, 4])
B = frozenset([3, 4, 5, 6])
print(A.isdisjoint(B)) # False
A.difference(B) # frozenset({1, 2})
- Python Dictionary
Dictionary is an unordered collection of key-value pairs.
It is generally used when we have a huge amount of data.
Dictionaries are optimized for retrieving data. We must know the key to retrieve the value.

In Python, dictionaries are defined within braces { } with each item being a pair in the form
key:value.
Key and value can be of any type.

d = {1:'value','key':2}
type(d)
Output: <class 'dict'>

We use key to retrieve the respective value. But not the other way around.

print("d[1] = ", d[1]);

Output: d[1] = value

print("d['key'] = ", d['key']);

Output: d['key'] = 2
Python Dictionary

# empty dictionary
my_dict = {}

# dictionary with integer keys

my_dict = {1: 'apple', 2: 'ball'}

# dictionary with mixed keys

my_dict = {'name': 'Ahmad', 1: [2, 4, 3]}

# using dict()
my_dict = dict({1:'apple', 2:'ball'})

# from sequence having each item as a pair

my_dict = dict([(1,'apple'), (2,'ball')])
Python Dictionary
Accessing Elements from Dictionary

While indexing is used with other data types to access values, a dictionary uses keys. Keys can be used
either inside square brackets [] or with the get()method.
If we use the square brackets [], KeyError is raised in case a key is not found in the dictionary.
On the other hand, the get() method returns None if the key is not found.

# get vs [] for retrieving elements

my_dict = {'name': 'Saleem', 'age': 26}

print(my_dict['name'])
print(my_dict.get('age'))

# Trying to access keys which doesn't exist throws error

# Output None
print(my_dict.get('address'))

# KeyError
print(my_dict['address'])
Python Dictionary
Changing and Adding Dictionary elements

If the key is already present, then the existing value gets updated. In case the key is not present,
a new (key: value) pair is added to the dictionary.

# Changing and adding Dictionary Elements

my_dict = {'name': 'Salah Aldeen', 'age': 26}

# update value
my_dict['age'] = 27

print(my_dict)

# add item
my_dict['address'] = 'Al-Quds'

print(my_dict)
Python Dictionary
Removing elements from Dictionary

pop(): Remove a particular item using its key and returns the value.
popitem(): used to remove and return an arbitrary (key, value) item pair from the dictionary.
clear(): Remove all items.
del: remove individual items or the entire dictionary itself.

squares = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

print(squares.pop(4)) # remove (4:16)

print(squares) # (4:16) removed

# remove an arbitrary item, return (key,value)

print(squares.popitem()) # Output: (5, 25)
print(squares) # Output: {1: 1, 2: 4, 3: 9}

squares.clear() # remove all items

print(squares) # Output: {}

del squares
print(squares) # Throws Error
Python Dictionary
Python Dictionary Methods
Method Description
clear() Removes all items from the dictionary.
copy() Returns a shallow copy of the dictionary.
Returns a new dictionary with keys from seq and value equal to v (defaults to
fromkeys(seq[, v]) None).
Returns the value of the key. If the key does not exist, returns d (defaults to
get(key[,d]) None).
items() Return a new object of the dictionary's items in (key, value) format.
keys() Returns a new object of the dictionary's keys.
Removes the item with the key and returns its value or d if key is not found. If
pop(key[,d]) d is not provided and the key is not found, it raises KeyError.
Removes and returns an arbitrary item (key, value). Raises KeyError if the
popitem() dictionary is empty.
Returns the corresponding value if the key is in the dictionary. If not, inserts
setdefault(key[,d]) the key with a value of d and returns d (defaults to None).
Updates the dictionary with the key/value pairs from other, overwriting
update([other]) existing keys.
values() Returns a new object of the dictionary's values
Python Dictionary
Python Dictionary Comprehension

# Dictionary Comprehension
squares = {x: x*x for x in range(6)}

print(squares)

Output

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

This code is equivalent to

squares = {}
for x in range(6):
squares[x] = x*x
print(squares)
Python Dictionary
Python Dictionary Comprehension

# Dictionary Comprehension with if conditional

odd_squares = {x: x*x for x in range(11) if x % 2 == 1}

print(odd_squares)

Output

{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

Python Dictionary
Other Dictionary Operations
Dictionary Membership Test
squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}
print(1 in squares) # Output: True
print(2 not in squares) # Output: True

# membership tests for key only not value

print(49 in squares) # Output: False

Iterating Through a Dictionary

squares = {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

for i in squares:
print(squares[i])
 Python Dictionary
Dictionary Built-in Functions

Function Description
Return True if all keys of the dictionary are True (or if the
all() dictionary is empty).
Return True if any key of the dictionary is true. If the dictionary
any() is empty, return False.
len() Return the length (the number of items) in the dictionary.

cmp() Compares items of two dictionaries. (Not available in Python 3)

sorted() Return a new sorted list of keys in the dictionary.

squares = {0: 0, 1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

print(all(squares)) # Output: False

print(any(squares)) # Output: True
print(len(squares)) # Output: 6
print(sorted(squares)) # Output: [0, 1, 3, 5, 7, 9]
Python Dictionary
Conversion between data types
print(float(5)) # convert from int to float
Output: 5.0
print(int(10.6)) # convert from float to int
Output: 10
print(float('2.5')) # convert from string to float
Output: 2.5
print(str(25)) # convert from int to string
Output: '25’
print(set([1,2,3])) # convert from list to set
Output: {1, 2, 3}
print(tuple({5,6,7}) # convert from set to tuple
Output: (5, 6, 7)
print(list('hello’)) # convert from string to list
Output: ['h', 'e', 'l', 'l', 'o’]

To convert to dictionary, each element must be a pair:

print(dict([[1,2],[3,4]])) # convert from list to dict
Output: {1: 2, 3: 4}
print(dict([(3,26),(4,44)])) # convert from tuple to dict
Output: {3: 26, 4: 44}
Python Output Using print() function
a = 5
print('The value of a is', a)
Output: The value of a is 5

The actual syntax of the print() function is:

print(*objects, sep=' ', end='\n', file=sys.stdout,
flush=False)

Examples:
print(1, 2, 3, 4)
Output: 1 2 3 4

print(1, 2, 3, 4, sep='*’)
Output: 1*2*3*4

print(1, 2, 3, 4, sep='#', end='&’)

Output: 1#2#3#4&
Output formatting
Formatting can be done by using the str.format() method.

x = 5; y = 10
print('The value of x is {} and y is {}'.format(x,y))
Output: The value of x is 5 and y is 10

print('I love {0} and {1}'.format('bread','butter'))

print('I love {1} and {0}'.format('bread','butter’))

Output:
I love bread and butter
I love butter and bread

print('Hello {name}, {greeting}'.format(greeting =

'Good morning', name = 'Ahmad'))
Output:
Hello Ahmad, Good morning
Output formatting
% operator

text = "My name is %s, and I am %d Years old" % ("Ahmad", 35)

Or

text = ("My name is %s,"

"and I am %d Years old"
% ("Ahmad", 35))
Python Input
Formatting can be done by using the str.format() method.

num = input('Enter a number: ')

Output:
Enter a number: 10

The entered value 10 is a string, not a number.

To convert into a number we can use int() or float()

x = int(num)
Python Import
When our program grows bigger, it is a good idea to break it
into different modules.
A module is a file containing Python definitions and
statements. Python modules have a filename and end with
the extension .py.

Definitions inside a module can be imported to another

module or the interactive interpreter in Python. We use the
import keyword to do this.
For example, we can import the math module by typing the following line:
import math
print(math.pi)

We can use the module in the following ways:

from math import pi
Print(pi)

import sys
print(sys.path)
Arithmetic operators

Operator Meaning Example

+ Add two operands or unary plus x + y+ 2
- Subtract right operand from the left or unary minus x - y- 2
* Multiply two operands x*y
/ Divide left operand by the right one (always results into float) x/y
Modulus - remainder of the division of left operand by the x % y (remainder of
%
right x/y)
Floor division - division that results into whole number adjusted
// x // y
to the left in the number line
x**y (x to the power
** Exponent - left operand raised to the power of right
y)
Comparison operators

Operator Meaning Example

Greater than - True if left operand is greater
> x>y
than the right
Less than - True if left operand is less than the
< x<y
right
== Equal to - True if both operands are equal x == y
!= Not equal to - True if operands are not equal x != y
Greater than or equal to - True if left operand is
>= x >= y
greater than or equal to the right
Less than or equal to - True if left operand is less
<= x <= y
than or equal to the right
Logical operators

Operator Meaning Example

and True if both the operands are true x and y
or True if either of the operands is true x or y
True if operand is false (complements the
not not x
operand)
Bitwise operators
In the table below: Let x = 10 (0000 1010 in binary) and y = 4 (0000 0100 in binary) x = 0000 1010
y = 0000 0100
Operator Meaning Example
& Bitwise AND x & y = 0 (0000 0000)
| Bitwise OR x | y = 14 (0000 1110)
~ Bitwise NOT ~x = -11 (1111 0101)
^ Bitwise XOR x ^ y = 14 (0000 1110)
>> Bitwise right shift x >> 2 = 2 (0000 0010)
<< Bitwise left shift x << 2 = 40 (0010 1000)
Assignment operators

Operator Example Equivalent to

= x=5 x=5
+= x += 5 x=x+5
-= x -= 5 x=x-5
*= x *= 5 x=x*5
/= x /= 5 x=x/5
%= x %= 5 x=x%5
//= x //= 5 x = x // 5
**= x **= 5 x = x ** 5
&= x &= 5 x=x&5
|= x |= 5 x=x|5
^= x ^= 5 x=x^5
>>= x >>= 5 x = x >> 5
<<= x <<= 5 x = x << 5
Identity operators
Operator Meaning Example
True if the operands are identical (refer to the same
is x is True
object)
True if the operands are not identical (do not refer
is not x is not True
to the same object)
x1 = 5
y1 = 5
x2 = 'Hello'
y2 = 'Hello'
x3 = [1,2,3]
y3 = [1,2,3]

print(x1 is not y1)

Output: False

print(x2 is y2)
Output: True

print(x3 is y3)
Output: False
Membership operators
Operator Meaning Example
in True if value/variable is found in the sequence 5 in x
not in True if value/variable is not found in the sequence 5 not in x

x = 'Hello world'
y = {1:'a',2:'b'}

print('H' in x)
Output: True

print('hello' not in x)
Output: True

print(1 in y)
Output: True

print('a' in y)
Output: False
What is Name in Python?
Name (also called identifier) is simply a name given to objects. Everything in Python is an object.
Name is a way to access the underlying object.

a = 2
print('id(2) =', id(2))
Output: id(2) = 9302208

print('id(a) =', id(a))

Output: id(a) = 9302208

a = a+1
b = 2
What is a Namespace in Python?

A namespace is a collection of names.

In Python, you can imagine a namespace as a mapping of every name you have defined to corresponding objects.

Different namespaces can co-exist at a given time but are completely isolated.

A namespace containing all the built-in names is created when we start the Python interpreter and exists as long as
the interpreter runs.
This is the reason that built-in functions like id(), print() etc. are always available to us from any part of the
program.

Each module creates its own global namespace.

Example of Scope and Namespace in Python
def outer_function():
b = 20
def inner_func():
c = 30

a = 10

The variable a is in the global namespace. Variable b is in the local namespace of

outer_function()and c is in the nested local namespace of inner_function().

When we are in inner_function(), c is local to us, b is nonlocal and a is global. We

can read as well as assign new values to c but can only read b and a from
inner_function()

If we try to assign as a value to b, a new variable b is created in the local namespace which
is different than the nonlocal b.

If we declare a as global, all the reference and assignment go to the global a

 Example of Scope and Namespace in Python
def outer_function(): def outer_function(): def outer_function():
a = 20 global a #global a
a = 20 #a = 20
def inner_function():
a = 30 def inner_function(): def inner_function():
print('a =', a) global a #global a
a = 30 #a = 30
inner_function() print('a =', a) print('a =', a)
print('a =', a)
inner_function() inner_function() Read
Only
print('a =', a) print('a =', a)
a = 10
outer_function()
print('a =', a) a = 10 a = 10
outer_function() outer_function()
print('a =', a) print('a =', a)

Output: Output: Output:

a = 30 a = 30 a = 10
a = 20 a = 30 a = 10
a = 10 a = 30 a = 10
 Example of Scope and Namespace in Python
def outer_function(): def outer_function(): def outer_function():
a = 20 global a #global a
a = 20 #a = 20
def inner_function():
a = 30 def inner_function(): def inner_function():
print('a =', a) global a #global a
a = 30 #a = 30
inner_function() print('a =', a) print('a =', a)
print('a =', a)
inner_function() inner_function() Read
Only
print('a =', a) print('a =', a)
a = 10
outer_function()
print('a =', a) a = 10 a = 10
outer_function() outer_function()
print('a =', a) print('a =', a)

Output: Output: Output:

a = 30 a = 30 a = 10
a = 20 a = 30 a = 10
a = 10 a = 30 a = 10