Chapter 1: Review of Python basic

Fundamental of Python
Introduction of Python
Python is an interpreter, interactive, object-oriented, and high-
level programming language. It was created by Guido van Rossum in
1991 at National Research Institute for Mathematics and Computer
Science Netherlands.

Features of Python

 Python is interpreted, Interactive, directly executed, with pre-compiled code.

 It is loosely typed Programming Language or Dynamically typed language with few
keywords and simple English-like structure and is easy to learn.
 It is free open-source and portable language having a large repository of libraries.
 It take less time to develop as python programs are typically 3-5 times shorter than
equivalent java programs.
 It is easily compatible with other languages like c, c++, java, etc.
 Python is a Case-sensitive language.

Python IDLE
The python IDLE tool offers an interactive and a more efficient platform to write your code in
python. (Integrated Development Learning Environment)

Python IDLE comprise Python Shell (Interactive mode) and Python Editor (Script mode).

Python Modes or Modes of Python IDLE

● Interactive Mode: The Python commands are directly typed at >>> command prompt and
as soon as we press the enter key, the interpreter displays the results immediately, which is
known as displaying. (We cannot save file or command)
>>>10+50
60
● Script Mode: We can write multiple line of code here and get output and errors are running
code. We can open script mode using CTRL+N
Syntax of print () in python:
print(value1,value1,…………,sep=’ ‘, end=’ ‘)
Displaying Vs Printing: Getting output without using print function in interactive mode is called
displaying, And getting output using print () in interactive or script mode.
Different types of files in python:
.py, .pyw, .pyc, .pyd, .pyo, .pyz

-----------------------------------------------------------------------------------------------------------------------------------
Python character set: Character set is a set of valid characters recognized by python. A character
by letter, digit or any other special symbol.
1. Letters: A-Z, a-z 2. Digits: 0-9 3. Special Symbols:+-/*&=!@_ etc.
4. Whitespaces: Blank space, tabs (‘\t’), carriage return (Enter key), newline, form feed (skips to
the start of the next page.)
5. Other Characters: All ASCII code and Unicode character.

Tokens: A token is the smallest element of a python script that is meaningful to the interpreter.

Types of Tokens are:

 Identifiers: Name of variables, constant and function or module is called an identifier.

 Keywords: The reserved words of python. No keyword can be used as an identifier.
 Literals: A fixed numeric or non-numeric value which stored in any variable is called Literals.
 Operators: It is a symbol that performs some kind of operation on given values like: +,-,*,
**, /, etc.
 Delimiters/ Punctuators: Delimiters are symbols which can be used as separators of values
or to enclose some values. Like: {} [] , : ;

Structure of a python program:

● Expressions: Expression is a combination of symbols, operators and operands. Like: a+b

● Statements: Statements is defined as any programming instruction given in python as per
the syntax , Like print(‘hello’), a=10
● Comments: Comments are additional information provided for a statement. (#) is used for
single line comment and (‘’’ ‘’’) used for multiple line comments.
● Function: A function is a block of code which only runs when it is called.
● Blocks: A block is a piece of Python program text that is executed as a unit.
Expressions Statements
Expression is a combination of symbols, Statements is defined as any programming
operators and operands instruction given in python as per the syntax
An expression represents some value. Statement is given to execute a task.
The outcome of an expression is always a value. Statement may or may not return a value as the
result.
Ex: 3*7+10 Print(‘hello’), a=10, if 10>5 etc.

Variable:
A Variable is like a container that stores any value. x=3, age=30

Rules for valid Variable name:

● A variable name must start with a letter or the underscore character

● A variable name cannot start with a number
● A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )
 ● Variable names are case-sensitive (age, Age and AGE are three different variables)
● A variable name cannot contain spaces.

Components of Variable/Object:
A). Identity of the Variable / Object: It refers to the Variable’s memory location address which is
unchanged once it has been created. We can check memory location using this method:
id()

B). Type of the Variable / Object (data type):

int float Complex Str(seq.) Boolean None

5 5.5 2+5j “hello” True/False(0/1) None

*(None is a datatype with single value. It is used to signify the absence of value / Condition
evaluating to false in a situation.)

We can seen any data type by: type()

y=”Hello”
type(y)

C). Value of the Variable/Object:

The value stored in Variable like: age=20, so 20 is the value of the variable.
L-value is age, and R-Value is 20

Multiple Assignments:
1) Assigning multiple values to multiple variables: x,y,z=2,3,4
2) Assigning same value to multiple variable: a=b=c=10

What is Dynamic Typing:

It refers to declaring a variable multiple times with values of different data types. And variable
automatically changes its data types according to data.
a=10
a=”Hello”
Keywords
Keywords are words that are already reserved for some particular purpose. The names of these
keywords should not be used as identifiers/Variable. Keywords are also called reserved words.

False, None, True, and, as, assert, break, class, continue, def, del, elif, else, except, finally, for,
from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield.

Mutable and Immutable Types:

Mutable: A mutable object can be changed after it is created. Example: List, dictionary etc.
Immutable: A immutable object cannot be changed after it is created. Example: int, float,
complex, bool, string, tuple etc.

Taking input by input() (Python built in functions)

1. input(): Its used to get user input in string format. ex: input(“Enter any number”)
2. int(): This function converts the inputted string value into numeric value if possible.
3. eval(): Its used to evaluate string as a number if possible. eval(“10+50”)

Type Casting
The process of converting the value of one data type (integer, string, float, etc.) to another data
type is called type conversion. Python has two types of type conversion.

1. Implicit Type Conversion: Python automatically converts one data type to another data
type. This process doesn't need any user involvement. Ex: type(5/2)
2. Explicit (forced) Type Conversion: In Explicit Type Conversion, users convert the data type
of an object to required data type. Ex: float(5), str(5),int(‘5’)

Operators and Operands

An operator is a symbol that performs an operation. +,-,*,/
An operator acts on some variables called operands.
For example, if we write a + b, the operator + is acting on two operands a and b. Python provides
some useful operators for performing various operations.

Binary Operators: Operators that operate on two operands are known as binary operators. Ex:
3+3
Unary Operators: Operators that operate on one operand are known as unary operators. Ex: -3
Types of Operators:
Arithmetic operators:
Comparison operators

Logical operators,
Shorthand /Augmented Assignment operators,
Membership operators.

Identity operators,

Precedence of Python Operators

Operators Meaning
() Parentheses
** Exponent (Power)
* , /, //, % Multiplication, Division, Floor division, Modulus
+- Addition, Subtraction
==, !=, >, >=, <, <=, is, is not, in, not Comparisons, Identity, Membership operators
in
Not Logical NOT
And Logical AND
or Logical OR

What is Functions?
A function is a block of code which only runs when it is called/invoke.

Advantages of Functions:

1. We can avoid rewriting the same logic/code again and again in a program.
2. We can call Python functions multiple times in a program.
3. Code becomes reusable.

How to define and call a function in python function:

def function_name():
statement
print(value)

Function Calling/invoking

function_name()

What is Debugging?
Debugging is the process of finding and fixing errors or bugs in the source code of any software.

Errors are of three types – • Compile Time Error • Run Time Error • Logical Error
1. Compile time error: These errors are basically of 2 types –

1. Syntax Error: Violation of formal rules of a programming language results in syntax error.
print(“hello)
2. Semantics Error: Semantics refers to the set of rules which sets the meaning of statements.
A meaningless statement results in semantics error.
x*y=z

2. Run time Error: These errors are generated during a program execution due to resource
limitation. Such type of error are also termed as exceptions.
Ex: Division by zero, using variable which has not been defined, accessing a list element which
doesn’t exist, try to access a file which doesn’t exit.

3. Logical Error: If a program is not showing any compile time error or run time error but not
producing desired output, it may be possible that program is having a logical error.
ex: Using wrong operators like using // in place of /, giving wrong operator precedence.

-----------------------------------------------------------------------------------------------------------------------------------
 Conditional Statement and Looping Statement

Flow of execution/Program Control and Flow

Control and flow of a program is classified into 4 categories:
1. Sequence Statement 2. Selection/Decision Statement
3. Iteration / Looping Statement 4. Jump Statement

1. Sequence: In this program executes in sequential order, one after another, without any jump in
the program.

Ex: Program to calculate sum:

a=10
b=20
c=a+b
print(c)

2. Selection/ Decision: In this program executes according to condition. If any condition in true
code will run if condition if false code will not run. Keyword If , else

Types of Decision making statement in python:

1. if statement
2. if else statement
3. if elif else statement
4. Nested if-else statement
if statement:
The statements inside the body of “if” only execute if the given condition returns true. If the
condition returns false then the statements inside “if” are skipped.
Syntax:
if test expression:
statement(s)
statement(s)

if else statement:
The if/else statement executes a block of code if a specified condition is true. If the condition is
false, another block of code can be executed.
Syntax:

if test expression:

Body of if

else:
 Body of else

if elif else statement:

The if-elif-else statement allows you to check multiple expressions for TRUE and execute a block of
code as soon as one of the conditions evaluates to TRUE.

Syntax

if expression1:
statement(s)
elif expression2:
statement(s)
elif expression3:
statement(s)
else:
statement(s)

Nested if-else statement:

There may be a situation when you want to check for another condition after a condition resolves
to true. In such a situation, you can use the nested if else statement.

The syntax of the nested if...elif...else construct may be −

if expression1:
statement(s)
if expression2:
statement(s)
else:
statement(s)
else:
statement(s)

3. Iteration / Looping: In this statement program executes multiple times according to condition.
Keyword while, for

Types of looping statement in python:

1. for loop
2. while Loop
3. Nested for Loop
4. Nested while loop
For loop statement:
The for loop statement is used to iterate / repeat itself over a range of values or a sequence. (That
is either, a list, a tuple, a dictionary, or a string).

Syntax:
for iterating_var in sequence:
statements(s)
statements(s)

Use of range()
range(start, stop, step)

While loop statement:

A while loop statement in python executes a block of code repeatedly as long as the test/control
condition of the loop is true.

Syntax:

while test expression:

Body of while

Jump Statement:

1. break statement
2. continue statement
3. pass
Break Statement: Break statement in Python is used to terminate the loop when some external
condition is triggered.

Break statement with for loop Syntax

for iterating_var in sequence:

if condition:
break
statements(s)

Continue Statement: The continue statement is used to skip the rest of the code inside a loop for
the current iteration only.

Continue statement with for loop Syntax

for iterating_var in sequence:

 if condition:
continue
statements(s)

Pass Statement: The pass statement is a null operation, it does nothing.

l=[10,20]
for i in l:
pass

-----------------------------------------------------------------------------------------------------------------------------------
String in Python
What is String:

A string is a sequence of characters. We can enclose characters in quotes (single, double or triple.)

For example: fruits=’Mango Apple Grapes’

Creating String /Types of string:

str1=’Hello world’
str2=”Python Programming”
str3=’’’Python
Programming’’’

Escape sequence character: \, \n, \t, \r, \f, \’, \’’.

*(An escape sequence character is represented as a string with one byte of memory.)

Empty String: An empty string is a string without any characters inside.

str=” ”, str=’ ‘

Multiple line String: Multiline strings are represented using triple quotes (‘’’ ‘’’) or even single or
double quotes.
 Indexing in a string (Accessing Characters)

Accessing individual characters of the string by using the index value is called indexing.

Traversing a String: Traversing a string means accessing all the elements of the string one after the
other by using the subscript / index value.

For loop:

First way: Second way:

While loop:

Q: Write a program to count number of occurrence of a character in an inputted string.

Q: Write a program to count number of characters in string.
Q: Write a program to traverse a string in reverse order.
Special String Operators:

Concatenation: Concatenation refers to creating a new string by adding two strings. + is the
operator to join two string. Some Example: “Hello ”+”world”

Repetition or Replicate: By repetition of string we can create multiple copies of any string.
* is the Operator for repetition. Some Example: “Hello” *3.

Membership: Membership operators used for checking whether a particular character exists in the
given string or not. Operators are: “in” and “not in”
Some Example:
“H” in “Hello” Gives True
“H” not in “Hello” Gives False.

Comparison Operators: Comparison operators are used to compare two strings. Python compares
strings using ASCII or UNICODE.
Some Example:
“Tim”==”tim” Gives False
“Freedom” > “Free” Gives True

String Slicing: Slicing is used to retrieve a subset of values. Chunk of characters can be extracted
from a string using slice operator. Example: var1 [start: end: step]
Some Example:
Str=”Save money”
str[1:3] gives “av”
str[:3] gives “Sav”

Updating: We can "update" an existing string by (re)assigning a variable to another string.

Example: var1 [range] +”x”

String are Immutable:

Strings are immutable means that the element of the string cannot be changed after it is created.
a=”student”
a [1] =”O” is invalid.

String Methods and Built-in-functions:

len() index() count() lstrip() join()

capitalize() isalpha() lower() rstrip() swapcase()
split() isalnum() islower() strip() partition()
replace() isdigit() upper() isspace() ord()
find() title() isupper() istitle() chr()
len() – This method returns the length of the string.
Santax: len(str)

capitalize() – This method return the exact copy of the string with the first letter in uppercase.
Santax: str.capitalize()

split() – This method breaks up a string at the specified separator and returns a list of substrings.
Santax: str.split(separator,maxsplit)

replace() – This function replaces all the occurrences of the old string with the new string.
Santax: str.replace(old,new)

find() – This function is used to search the first occurrence of the substring in the given string.
find() returns the lowest index of the substring if it is found in the given string. If the substring is
not found it returns -1.
Santax: str.find(sub,start,end)

index() – This function is quite similar to find() but raises an exception if the substring is not
present in the given string.
Syntax: str.index(substring, start, end)

isalpha() – This function checks for alphabets in an inputted string. It returns True if the strings
contains only letters, otherwise returns False.
Syntax: str.isalpha()

isalnum() – The isalnum() method returns True if all the characters are alphanumeric, alphabet
letters(a-z) and numbers (0-9).
Syntax: str.isalnum()

isdigit() – This function returns True if the string contains only digits, otherwise False.
Syntax: str.isdigit()

title() – This function returns the string with first letter of every word in the string in uppercase
and rest in lowercase.
Syntax: str.title()

count() – This function returns number of times substring occurs in the given string.
Syntax: str.count(substring, start, end)

lower() – This function converts all the uppercase letters in the string into lowercase.
Syntax: str.lower()

upper() – This function converts lowercase letters in the string into uppercase.

Syntax: str.upper()

islower() – This function returns True if all the letters in the string are in lowercase.
Syntax: str.islower()
isupper() – This function returns True if all the letters in the string are in uppercase.
Syntax: str.isupper()

ord() – This function returns the ASCII/Unicode (ordinal) of the character.

Example: ord(“A”) gives 65

Chr() – This function returns the character represented by the inputted Unicode/ASCII number.
Example: chr(65) gives “A”

-----------------------------------------------------------------------------------------------------------------------------------
List in Python
What is List

A list is a collection of comma-separated values (items) within square brackets. Items in a list need
not of the same type. It stores data in ordered sequence.

Declaring/Creating List:

Syntax to creating List:

List_name=[“value1”, “value 2”, “value 3”, “value 4”]

Nested_List=[“value1”, [“value 2”, “value 3”], [“value 2”, “value 3”]]

Empty list=[ ]

Creating list from sequence, list(“Hello”)

Accessing List Elements:

Traversing a list:

Traversing a list means accessing each element of a list. This can be done by using either for or
while looping statement.

List Operators in Python

1) Concatenation: Concatenation or joining is a process in which multiple sequences/lists can be
combined together. ‘+’ is a symbol of concatenation operator.

2) Repetition/Replication/Multiply: This operator replicates the list for a specified number of

times and creates a new list. ‘*’ is a symbol of repetition operator.

3) Membership Operator: This operator used to check or test whether a particular

element or item is a member of any list or not. ‘in’ And ‘not in’ are the operators for membership
operator.

4) Indexing: Index is nothing but there is an index value for each item present in the sequence or
list. Example of nested list also.

5) Slicing Operator: This operator used to slice a particular range of a list or a sequence. Slice is
used to retrieve a subset of values.
Syntax: list [start : stop : step]

Built-in-functions and Methods of List

Append() Len() del statement

Extend() Sort() Remove()
Insert() Clear() Max()
Reverse() Count() Min()
Index() Pop() Sum()

What is Tuple:
Tuple is a sequence of immutable Python object. Tuples are sequences, just like lists. Tuples are
immutable it means we cannot perform insert, update and delete operation on them.

The only difference is that tuples are immutable , tuples use parentheses, and lists use square
brackets.

Example: tuple= (‘mango’,’apple’,’grapes’)

Example: List= [‘mango’,’apple’,’grapes’]

Tuple creation:

Empty tuple: t=()

Tuple with one element: t=(10,)
Tuple with one element: t=10,
Tuple with multiple value: t(10, “Hello”,20,”Kanpur”)
Creating tuple using function tuple()

Nested Tuple:
Example: fruits= (10 , 20 , (‘Ram’ , ’Mohan’) , 40 , 50 , [‘Red’ , ’blue’] , 60)

Accessing a Tuple and Nested Tuple:

Traversing a Tuple:

Traversing a tuple means accessing each element of a tuple. This can be done by using either for or
while looping statement.

Common Tuple operations:

 Tuple Slicing: Slicing is used to retrieve a subset of values.

Syntax: tuple_name[start:stop:step]
 Tuple Addition/Concatenation/joining:
 Tuple Multiplication/Repetition
 Membership Operator like ‘in’ and ‘not in’
 Comparing Tuples
Tuple Functions:

Built-in-functions and Methods of Tuple

len() count() any()

min() max() sorted()
index() del statement

What is Dictionary:
A python dictionary is a mapping of unique keys to values. It is a collection of key-value pairs.
Dictionaries are mutable which means they can be changed.

Important features of dictionaries are:

 Each key map to values. It’s called key value pair.

  Each key is separated from its values by a colon(:), the items are separated by commas, and
the entire dictionary is enclosed in curly braces {}.
 Keys are unique within a dictionary while values may not be.
 The value of a dictionary can be of any type, but the keys must be of an immutable data
types.

Creating a Dictionary:
Empty dictionary:
d={}
d=dict()

Adding an item in Dictionary:

D={}
D[‘input’]=’Keyboard’
D[‘Output’]=’Printer’
D[‘Language’]=’Python’

D={‘input’: ’Keyboard’, ‘Output’:’Printer’, ‘Language’=’Python’}

Accessing a Dictionary:
To access dictionary elements, you can use the square brackets along with the key to obtain its
value.
print(D[‘Output’])
It will give out: ‘Printer’

Traversing a Dictionary:
Traversing a dictionary means accessing each element of a Dictionary. This can be done by
using either for or while looping statement.

Common Dictionary operations:

 Appending values to Dictionary
 Updating Elements in a Dictionary
 Membership Operators ‘in’ and ‘not in’
 Removing an item from Dictionary

Built-in-functions and Methods of Dictionary

len() clear() get()

items() keys() values()
fromkeys() copy() popitem()
setdefault() max() and min() sorted()