Review of Python basics

CHAPTER - 1
 Python
• In last class we have learned about Python. In this class we will
learn Python with some new techniques.
• We know that Python is a powerful and high level language and it is
an interpreted language.
• Python gives us two modes of working-
– Interactive mode
– Script mode

ScriptMode
Interactiv
e Mode
 Python
• It is possible to develop various Apps with Python like–
– GUI Apps
– Web Apps
– Games
– DBMS Apps
– Scripting etc.

Python - Limitations
There are few limitations in Python which can be neglected because of its
vast usage.
It is not a Fast
Language. Libraries are
very less.
It is week in Type
binding.
 Token
• Token- is the smallest unit of any programming language.

It is also known as Lexical Unit. Types of token are-

i. Keywords
ii. Identifiers (Names)
iii. Literals
iv. Operators
v. Punctuators

Keywords
Keywords are those words which provides
a special meaning to interpreter.
These are reserved for specific functioning.
These can not be used as identifiers,
variable name or any other purpose.
Available keywords in Python are-

Neha Tyagi, KV 5 Jaipur II Shift

 Identifier
• These are building blocks of a program and are used to give names
to different parts/blocks of a program like - variable, objects, classes,
functions.
• An identifier may be a combination of letters and numbers.
• An identifier must begin with an alphabet or an underscore( _ ).
Subsequent letters may be numbers(0-9).
• Python is case sensitive. Uppercase characters are distinct
from lowercase characters (P and p are different for
interpreter).
• Length of an Identifier is unlimited.
• Keywords can not be used as an identifier.
• Space and special symbols are not permitted in an identifier name except
an underscore( _ ) sign.
• Some valid identifiers are –
• Myfile, Date9_7_17, Z2T0Z9, _DS, _CHK FILE13.
• Some invald identifiers are –
• DATA-REC, 29COLOR, break, My.File.
Literals / Values
• Literals are often called Constant Values.
• Python permits following types of literals -
– String literals - “Pankaj”
– Numeric literals – 10, 13.5, 3+5j
– Boolean literals – True or False
– Special Literal None
– Literal collections String Literals
String Literal is a sequence of characters that can be a combination of
letters, numbers and special symbols, enclosed in quotation marks,
single, double or triple(“ “ or ‘ ‘ or “’ ‘”).

In python, string is of 2 types-

-Single line string
Text = “Hello World” or Text =
‘Hello World’
-Multi lineText
string
= ‘hello\ or Text = ‘’’hello
world’ word ‘’’
 Numeric Literals
• Numeric values can be of three types -
– int (signed integers)
• Decimal Integer Literals – 10, 17, 210 etc.
• Octal Integer Literals - 0o17, 0o217 etc.
• Hexadecimal Integer Literals – 0x14, 0x2A4, 0xABD etc.
– float ( floating point real value)
• Fractional Form – 2.0, 17.5 -13.5, -.00015 etc.
• Exponent Form - -1.7E+8, .25E-4 etc.
– complex (complex numbers)
• 3+5i etc.

Boolean Literals
• It can contain either of only two values – True or False
 A= True
 B=False

Special Literals
• None, which means nothing (no value).
 X = None
Operators
• An Operator is a symbol that trigger some action
when
applied to identifier (s)/ operand (s)
• Therefore, an operator requires operand (s) to
compute upon. example :
c=a+b
Here, a, b, c are operands and operators are = and + which
are performing differently.
Punctuators
• In Python, punctuators are used to construct the program
and to make balance between instructions and statements.
Punctuators have their own syntactic and semantic
significance.
• Python has following Punctuators -
‘, ”, #, \, (, ), [, ], {, }, @. ,, :, .. `, =
 DATA TYPES
• Data can be of any type like- character, integer, real, string.
• Anything enclosed in “ “ is considered as string in Python.
• Any whole value is an integer value.
• Any value with fraction part is a real value.
• True or False value specifies boolean value.
• Python supports following core data types-
I. Numbers (int like10, 5) (float like 3.5, 302.24) (complex like 3+5j)
II. String (like “pankaj”, ‘pankaj’, ‘a’, “a” )
III. List like [3,4,5,”pankaj”] its elements are Mutable.
IV. Tuple like(3,4,5,”pankaj”) its elements are immutable.
V. Dictionary like {‘a’:1, ‘e’:2, ‘I’:3, ‘o’:4, ‘u’:5} where a,e,i,o,u

are keys
and 1,2,3,4,5 are their values.
 CORE DATA TYPES

Graphical View

CORE DATA
TYPE

Numbers None Sequences Mappings

Floating
Integer Complex String Tuple List Dictionary
Point

Boolean

10
 Variables and Values
An important fact to know is-
– In Python, values are actually objects.
– And their variable names are actually their reference names.
Suppose we assign 10 to a variable A.
A = 10
Here, value 10 is an object and A is its
reference name.
10

Referenc Object
e
variable
 Variables and Values
If we assign 10 to a variable B,
B will refer to same object.

Here, we have two variables, 10

but with same location.

Reference Object
Now, if we change value of B like variable
B=20
Then a new object will be created with 2
0
a new location 20 and this object will be
referenced by B. 10
 Mutable and Immutable Types
Following data types comes under mutable
and immutable types-
• Mutable (Changeable)
– lists, dictionaries and sets.

• Immutable (Non-Changeable)
– integers, floats, Booleans, strings and tuples.
 Operators
• The symbols that shows a special behavior or
action when applied to operands are called
operators. For ex- + , - , > , < etc.
• Python supports following operators-
I. Arithmetic Operator
II. Relation Operator
III. Identity Operators
IV. Logical Operators
V. Bitwise Operators
VI. Membership Operators
 Operator Associativity
• In Python, if an expression or statement consists
of multiple or more than one operator then
operator associativity will be followed from left-to-
right.

• In above given expression, first 7*8 will be calculated as 56, then 56 will
be divided by 5 and will result into 11.2, then 11.2 again divided by 2
and will result into 5.0.
*Only in case of **, associativity will be followed from right-to-left.

Above given example will be calculated as 3**(3**2).

 Type Casting
• As we know, in Python, an expression may be consists of
mixed datatypes. In such cases, python changes data types
of operands internally. This process of internal data type
conversion is called implicit type conversion.
• One other option is explicit type conversion which is like-
<datatype> (identifier)
For ex-
a=“4”
b=int(a)
Another ex-
If a=5 and b=10.5 then we can convert a
to float. Like d=float(a)
In python, following are the data conversion
functions-
(1) int ( ) (2) float( ) (3) complex( )
 Taking Input in Python
• In Python, input () function is used to take input which takes input in the
form of string. Then it will be type casted as per requirement. For ex- to
calculate volume of a cylinder, program will be as-

• Its output will be as-

 Types of statements in Python
• In Python, statements are of 3 types-

» Empty Statements
• pass
» Simple Statements (Single Statement)
• name=input (“Enter your Name “)
• print(name) etc.
» Compound Statements
<Compound Statement Header>:
<Indented Body containing multiple simple
statements/compound statements>
• Here, Header line starts with the keyword and ends at colon (:).
• The body consists of more than one simple Python statements
or compound statements.
 Statement Flow Control
• In a program, statements executes in sequential
manner or in selective manner or in iterative
manner.
Sequential Selective Iterative
 Python -----if Statements
• In Python, if statement is used to select statement
for processing. If execution of a statement is to be
done on the basis of a condition, if statement is to
be used. Its syntax is-
if <condition>:
statement(s)
like -
 Python---if-else Statements
• If out of two statements, it is required to select one
statement for processing on the basis of a condition,
if-else statement is to be used. Its syntax is-
if <condition>:
statement(s) when condition is true
else:
statement(s) when condition is false
like -
Nested If -else
 Loop/Repetitive Task/Iteration
These control structures are used for repeated
execution of statement(s) on the basis of a condition.
Loop has 3 main components-
1. Start (initialization of loop)
2. Step (moving forward in loop )
3. Stop (ending of loop)

Python has following loops-

– for loop
– while loop
 range () Function
• In Python, an important function is range( ).
its syntax is-
range ( <lower limit>,<upper limit>)
If we write - range (0,5 )
Then a list will be created with the values
[0,1,2,3,4] i.e. from lower limit to the value one less than
ending limit.

range (0,10,2) will have the

list [0,2,4,6,8]. range (5,0,-1) will have the
list [5,4,3,2,1].
 Jump Statements
break Statement

for <var> in <sequence>:

while <test-condition>:
statement1
statement1
if <condition>:
if <condition>:
break
break
statement2
statement2
statement3
statement3
Statement4
Statement4
statement5
statement5
 Jump Statements
break Statement

Output Output
 in and not in operator
• in operator-
3 in [1,2,3,4] will return True.
5 in [1,2,3,4] will return False.

– not in operator-
5 not in [1,2,3,4] will return True.
 Jump Statements
continue Statement

Output of both the program---

Nested Loop

OUTPUT
 String Creation
• String can be created in following ways-
1. By assigning value directly to the variable
String Literal

2. By taking
Input

Input ( ) always return input in

the form of a string.
 Traversal of a string
• Process to access each and every character of a string
for the purpose of display or for some other purpose is
called string traversal.
Output

Program to print a String after reverse -

Output
 String Operators
• There are 2 operators that can be used to work
upon strings + and *.
»+ (it is used to join two strings)
• Like - “tea” + “pot” will result into “teapot”
• Like- “1” + “2” will result into “12”
• Like – “123” + “abc” will result into “123abc”

»* (it is used to replicate the string)

• like - 5*”@” will result into “@@@@@”
• Like - “go!” * 3 will result “go!go!go!”

note : - “5” * “6” expression is invalid.

 String Slicing
• Look at following examples carefully-
Index 0 1 2 3 4 5 6 7 8 9 10 11 12 13
Word R E S P O N S I B I L I T Y
Reverse index
-14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

word =
“RESPO
NSIBILIT
Y”

word[ 0 : 14 ] will result into‘RESPONSIBILITY’

word[ 0 : 3] will result into‘RES’

word[ 2 : 5 ] will result into‘SPO’

word[ -7 : -3 ] will result into‘IBIL’

word[ : 14 ] will result
into‘RESPONSIBILITY’
 String Functions
String.capitalize() Converts first character of every word to Capital Letter

String.find() Returns the Lowest Index of Substring

String.index() Returns Index of Substring

String.isalnum() Checks Alphanumeric Character

String.isalpha() Checks if All Characters are Alphabets

String.isdigit() Checks Digit Characters

String.islower() Checks if all Alphabets in a String.are Lowercase

String.isupper() returns if all characters are uppercase characters

String.join() Returns a Concatenated String

String.lower() returns lowercased string

String.upper() returns uppercased string

len() Returns Length of an Object

ord() returns Unicode code point for Unicode character

reversed() returns reversed iterator of a sequence

slice() creates a slice object specified by range()

 List Creation
• List is a standard data type of Python. It is a sequence which
can store values of any kind.
•List is represented by square brackets “ [ ] “
For ex -
• [] Empty list
• [1, 2, 3] integers list
• [1, 2.5, 5.6, 9] numbers
• [ ‘a’, ‘b’, ‘c’] list (integer
• [‘a’, 1, ‘b’, 3.5, ‘zero’] and float)
mixed values list
• [‘one’, ’two’, ’three’] characters string list
list
• In Python, only list and dictionary are mutable data types, rest
of all the data types are immutable data types.
 List Creation
• List can be created in following ways-
• Empty list -
L=[]
• list can also be created with the following statement-
L = list( )

• Long lists-
even = [0, 2, 4, 6, 8, 10 ,12 ,14 ,16 ,18 ,20 ] This is a Tuple
• Nested list -
L = [ 3, 4, [ 5, 6 ], 7]

Another method
 List Creation
-As we have seen in the example
That when we have supplied
values as numbers to a list even
then
They have automatically
converted to string

– If we want to pass
values to a list in numeric
form then we have to
eval ( ) function identifies type of the passed string and then return it.
write
following function -
eval(input())
Another example
L=eval(input(“Enter list to be added “))
String Values
 Accessing a List
• First we will see the similarities between a List and a String.
• List is a sequence like a string.
• List also has index of each of its element.
• Like string, list also has 2 index, one for forward indexing (from
0, 1, 2, 3, ….to n-1) and one for backward indexing(from -n to
- 1).
• In a list, values can be accessed like string.
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Forward index
List R E S P O N S I B I L I T Y
Backward -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
index
 Accessing a List
• len( ) function is used to get the length of a list.

• L[ i ] will return the values exists at i index.

• L [ i : j ] will return a new list with the values from i index to j index excluding
j index.

.
 Difference between a List and a String
• Main difference between a List and a string is that string
is
immutable whereas list is mutable.
• Individual values in string can’t be change whereas it
is possible with list.

Value didn’t
change in string.
Error shown. Value got changed
in list specifying
list is mutable

40
 Traversal of a list
• Traversal of a list means to access and process each
and every element of that list.
• Traversal of a list is very simple with for loop –

for <item> in
<list>:

*Python supports UNICODE therefore

output in Hindi is also possible
 List Operations (+, *)
• Main operations that can be performed on lists are joining list,
replicating list and list slicing.
• To join Lists,+ operator , is used which joins a list at the end of
other list. With + operator, both the operands should be of list
type otherwise error will be generated.

• To replicate a list, * operator , is used.

 List Operations (Slicing)
• To slice a List, syntax is seq = list [ start : stop ]

• Another syntax for List slicing is –

seq=list[start:stop:step]
 Use of slicing for list Modification
• Look carefully at following examples-

New value is being assigned here.

Here also, new value is being assigned.

See the difference between both the results.

144 is a value and not a sequence.

 List Functions and Methods
– Python provides some built-in functions for list manipulation
– Syntax is like <list-object>.<method-name>
Function Details

List.index(<item>) Returns the index of passed items.

List.append(<item>) Adds the passed item at the end of list.

List.extend(<list>) Append the list (passed in the form of argument) at the end of list
with which function is called.

List.insert(<pos>,<item>) Insert the passed element at the passed position.

List.pop(<index>) Delete and return the element of passed index. Index passing is
optional, if not passed, element from last will be deleted.

List.remove(<value>) It will delete the first occurrence of passed value but does not
return the deleted value.
 List Functions and Methods
Function Details

List.clear ( ) It will delete all values of list and gives an empty list.

List.count (<item>) It will count and return number of occurrences of the passed element.

List.reverse ( ) It will reverse the list and it does not create a new list.

List.sort ( ) It will sort the list in ascending order. To sort the list in descending
order, we need to write----- list.sort(reverse =True).
 Creation of Tuple
• In Python, “( )” parenthesis are used for tuple
( ) creation. empty tuple
( 1, 2, 3) integers tuple
( 1, 2.5, 3.7, 7) numbers tuple
(‘a’, ’b’, ’c’ ) characters tuple
( ‘a’, 1, ‘b’, 3.5, mixed values tuple
‘zero’) string tuple
(‘one’, ’two’,
’three’, ’four’)
*Tuple is an immutable sequence whose values can not be changed.
 Creation of Tuple
Look at following examples of tuple creation carefully-
• Empty tuple:

• Single element tuple:

• Long tuple:

• Nested tuple:
 Creation of Tuple
tuple() function is used to create a tuple from other sequences.
See examples-
Tuple creation from string Tuple creation from list

Tuple creation from input

All these elements are of

character type. To have
these in different types,
need to write following
statement.-
Tuple=eval(input(“Enter
elements”))
 Accessing a Tuple
• In Python, the process of tuple accessing is same as
with list. Like a list, we can access each and every
element of a tuple.
• Similarity with List- like list, tuple also has index. All
functionality of a list and a tuple is same except mutability.
Forward index 0 1 2 3 4 5 6 7 8 9 10 11 12 13
Tupl R E S P O N S I B I L I T Y
e Backward -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
index
• len ( ) function is used to get the length of tuple.
 Accessing a Tuple
• Indexing and Slicing:
• T[ i ] returns the item present at index i.
• T[ i : j ] returns a new tuple having all the items of T from
index i to j.
• T[i:j:n] returns a new tuple having difference of n elements
of T from index i to j.
index i to j.

• Membership operator:
• Working of membership operator “in” and “not in” is same as
in a list. (for details see the chapter- list manipulation).
• Concatenation and Replication operators:
• + operator adds second tuple at the end of first tuple. * operator repeats
elements of tuple.
 Accessing a Tuple
• Accessing Individual elements-

• Traversal of a Tuple –
for <item> in <tuple>:
#to process every element.

OUTPUT
 Tuple Operations
• Tuple joining
• Both the tuples should be there to add
with +.

Some errors in tuple joining-

• In Tuple + number
• In Tuple + complex number
• In Tuple + string
• In Tuple + list
• Tuple + (5) will also generate error because when adding a tuple with
a single value, tuple will also be considered as a value and not a
tuple..

• Tuple Replication-
 Tuple Slicing

Tuple will show till last element of list irrespective of upper

limit.

Every alternate element will be shown.

Every third element will be shown.

 Dictionary Creation
• To create a dictionary, it is needed to collect pairs
of key:value in “{ }”.
<dictionary-name>={ <key1>:<value1>,<key2>:<value2>,<key3>:<value3>. . . }
Example:
teachers={“Rajeev”:”Math”, “APA”:”Physics”,”APS”:”Chemistry:”SB”:”CS”}
In above given example :
Key-value pair Key Value
“Rajeev”:”Math” “Rajeev” “Math”
“APA”:”Physics” “APA” “Physics”
“APS”:”Chemistry” “APA” “Chemistry”
“SB”:”CS” “SB” “CS”
 Dictionary Creation
• Some examples of Dictionary are-
Dict1= { } # this is an empty dictionary without any element.

DayofMonth= { January”:31, ”February”:28, ”March”:31, ”April”:30, ”May”:31, ”June”:30,

”July”:31, ”August”:31, ”September”:30, ”October”:31, ”November”:30,
”December”:31}

FurnitureCount = { “Table”:10, “Chair”:13, “Desk”:16, “Stool”:15, “Rack”:15 }

– By above examples you can easily understand about the keys

and their values.
– One thing to be taken care of is that keys should always be of
immutable type.
 Dictionary Creation
– Keys should always be of immutable type.

– If you try to make keys as mutable, python shown error in it.

For example-

Here key is a list which is

of mutable type.

Here error shows that you are trying to create a key of

mutable type which is not permitted.
 Accessing a Dictionary
• Toaccess a value from dictionary, we need to use
key similarly as we use an index to access a value from a list.
• We get the key from the pair of Key: value.

teachers={“Rajeev”:”Math”, “APA”:”Physics”,”APS”:”Chemistry:”SB”:”CS”}

• If we execute following statement from above example-

• We have selected key “Rajeev” and on printing it, Math

got printed. Another example-

If we access a non-key, error will come.

 Traversal of a Dictionary
• To traverse a Dictionary, we use for loop. Syntax is-

for <item> in <dictionary>:

Here, notable thing is that every key of each pair of

dictionary d is coming in k variable of loop. After this
we can take output with the given format and with
print statement.
 Traversal of Dictionary
• To access key and value we need to use keys() and
values().for example-

• d.keys( ) function will display only key.

• d.values ( ) function will display value only.
THANK YOU

61