PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS)

SALEM
DEPARTMENT OF COMPUTER SCIENCE AND APPLICATIONS

PYTHON PROGRAMMING

Unit I: Basics of Python Programming: History of Python-Features of Python - Literal - Constants-

Variables - Identifiers–Keywords-Built-in Data Types-Output Statements – Input Statements -
Comments – Indentation- Operators-Expressions-Type conversions. Python Arrays: Defining and
Processing Arrays – Array methods.

Unit II: Control Statements: Selection/Conditional Branching statements: if, if-else, nested if and
if-elif-else statements. Iterative Statements: while loop, for loop, else suite in loop and nested
loops. Jump Statements: break, continue and pass statements.

Unit III: Functions: Function Definition – Function Call – Variable Scope and its Lifetime- Return
Statement. Function Arguments: Required Arguments, Keyword Arguments, Default Arguments
and Variable Length Arguments-Recursion. Python Strings: String operations- Immutable Strings
- Built-in String Methods and Functions
- String Comparison. Modules: import statement- The Python module – dir() function – Modules
and Namespace – Defining our own modules.

Unit IV: Lists: Creating a list -Access values in List-Updating values in Lists-Nested lists – Basic list
operations-List Methods. Tuples: Creating, Accessing, Updating and Deleting Elements in a
tuple – Nested tuples– Difference between lists and tuples. Dictionaries:
Creating, Accessing, Updating and Deleting Elements in a Dictionary – Dictionary Functionsand
Methods - Difference between Lists and Dictionaries.

Unit V: Python File Handling: Types of files in Python - Opening and Closing files- Readingand
Writing files: write() and writelines() methods- append() method –read() and readlines()
methods – with keyword – Splitting words – File methods - File Positions- Renaming and deleting
files.

Textbooks:

1. ReemaThareja, “Python Programming using problem solving approach”, First

Edition,2017, Oxford University Press.

2. Dr. R. NageswaraRao, “Core Python Programming”, First Edition, 2017, Dream

techPublishers.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Basics of Python Programming:
History of Python:
 Python was first developed by Guido van Rossum in the late 80‟s and
early 90‟s at the National Research Institute for Mathematics and
Computer Science in the Netherlands.
 It has been derived from many languages such as ABC, Modula-3, C,
C++, Algol- 68, SmallTalk, UNIX shell and other scripting languages.
 Since early 90‟s Python has been improved tremendously. Its version 1.0
was released in 1991, which introduced several new functional
programming tools.
 While version 2.0included list comprehension was released in 2000 by the
Be Open Python Labs team.
 Python 2.7 which is still used today will be supported till 2020.
 Currently Python 3.6.4 is already available. The newer versions have better
features like flexible string representation e.t.c,
 Although Python is copyrighted, its source code is available under GNU
General Public License (GPL) like that Perl.
 Python is currently maintained by a core development team at the
institute which is directed by Guido Van Rossum.
 These days, from data to web development, Python has emerged as very
powerful and popular language. It would be surprising to know that python
is actually older than Java, R and JavaScript.

Features of Python:

 Simple: Reading a program written in Python feels almost like reading

english. The main strength of Python which allows programmer to
concentrate on the solution to the problem rather than language itself.
 Easy to Learn: Python program is clearly defined and easily readable.
The structure of the program is simple. It uses few keywords and clearly

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 defined syntax.
 Versatile: Python supports development of wide range of applications such
as simple text processing, WWW browsers and games etc..
 Free and Open Source: It is a Open Source Software. So, anyone can
freely distribute it, read the source code, edit it, and even use the code to
write new (free) programs.
 High-level Language: While writing programs in Python we do not worry
about the low-level details like managing memory used by the program.
 Interactive: Programs in Python work in interactive mode which allows
interactive testing and debugging of pieces of code. Programmer can easily
interact with the interpreter directly at the python prompt to write their
programs.
 Portable: It is a portable language and hence the programs behave the
same on wide variety of hardware platforms with different operating
systems.
 Object Oriented: Python supports object-oriented as well as procedure-
oriented style of ]
 programming. While object-oriented technique encapsulates data and
functionality with in objects, Procedure oriented at other hand, builds
programs around procedure or functions.
 Interpreted: Python is processed at runtime by interpreter. So, there is
no need to compile a program before executing it. You can simply run the
program. Basically python converts source program into intermediate
form called byte code.
 Dynamic and strongly typed language: Python is strongly typed as the
interpreter keeps track of all variables types. It's also very dynamic as it
rarely uses what it knows to limit variable usage.
 Extensible: Since Python is an open source software, anyone can add low-
level modules to the python interpreter. These modules enable
programmers to add to or customize their tools to work more efficiently.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  Embeddable: Programmers can embed Python within their C, C++, COM,
ActiveX, CORBA and Java Programs to give „scripting „capability for
users.
 Extensive Libraries: Python has huge set of libraries that is easily portable
across different platforms with different operating systems.
 Easy maintenance: Code Written in Python is easy to maintain.
 Secure: This Programming language is secure for tampering. Modules can
be distributed to prevent altering of source code. Additionally, Security
checks can be easily added to implement additional security features.
 Robust: Python Programmers cannot manipulate memory directly, errors
are raised as exceptions that can be catch and handled by the program
code. For every syntactical mistake, a simple and easy to interpret message
is displayed. All these make python robust.
 Multi-threaded: Python supports executing more than one process of a
program simultaneously with the help of Multi Threading.
 Garbage Collection: The Python run-time environment handles garbage
collection of all python objects. For this, a reference counter is maintained
to assure that no object that is currently in use is deleted.

Applications of Python:

 Embedded scripting language: Python is used as an embedded scripting

language for various testing/ building/ deployment/ monitoring
frameworks, scientific apps, and quick scripts.
 3D Software: 3D software like Maya uses Python for automating small
user tasks, or for doing more complex integration such as talking to
databases and asset management systems.
 Web development: Python is an easily extensible language that provides
good integration with database and other web standards.
 GUI-based desktop applications: Simple syntax, modular architecture, rich
text processing tools and the ability to work on multiple operating systems

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 makes Python a preferred choice for developing desktop-based applications.
 Image processing and graphic design applications: Python is used to make
2D imaging software such as Inkscape, GIMP, Paint Shop Pro and Scribus. It
is also used to make 3D animation packages, like Blender, 3ds Max, Cinema
4D, Houdini, Light wave and Maya.
Scientific and Computational applications: Features like high speed,
productivity and availability of tools, such as Scientific Python and Numeric
Python, have made Python a preferred language to perform computation
and processing of scientific data. 3D modeling software, such as FreeCAD,
and finite element method software, like Abaqus, are coded in Python.
 Games: Python has various modules, libraries, and platforms that support
development of games. Games like Civilization-IV, Disney's Toontown
Online, Vega Strike, etc. are coded using Python.
 Enterprise and Business applications: Simple and reliable syntax, modules
and libraries, extensibility, scalability together make Python a suitable
coding language for customizing larger applications. For example, Reddit
which was originally written in Common Lips, was rewritten in Python in
2005. A large part of Youtube code is also written in Python.
 Operating Systems: Python forms an integral part of Linux distributions.

Literal Constants:
 In programming constants are referred to variables that cannot be
changed.
 Generally Literal constants are classified in to three types.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Numeric Literals
 The value of a literal constant can be used directly in programs. For
example, 7, 3.9, 'A', and "Hello" are literal constants.
 Numbers refers to a numeric value. You can use four types of numbers
in Python program- integers, long integers, floating point and
complex numbers.
 Numbers like 5 or other whole numbers are referred to as integers.
Bigger whole numbers are called long integers. For example,
535633629843L is a long integer.
 Numbers like are 3.23 and 91.5E-2 are termed as floating point numbers.
 Numbers of a + bj form (like -3 + 7j) are complex numbers.

Boolean Literals
 A Literals Boolean type can have one of the two values- True or False.

Examples:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

String Literals
 A string is a group of characters.
 Using Single Quotes ('): For example, a string can be written as 'HELLO'.
 Using Double Quotes ("): Strings in double quotes are exactly same as
those in single quotes. Therefore, 'HELLO' is same as "HELLO".
 Using Triple Quotes (''' '''): You can specify multi-line strings using triple
quotes. You can use as many single quotes and double quotes as you
want in a string within triple quotes.
Examples:

Unicode Strings:

 Unicode is a standard way of writing international text. That is,if you

want to write some text in your native language like hindi,then you
need to have a Unicode-enable text editor.
 Python allows you to specify Unicode text by prefixing the string with a u
or U.
 For Example: u”Sample Unicode string”
Note :The „U‟ prefix specifies that the file contains text written in
language other than English.

Escape Sequences

 Some characters (like ", \) cannot be directly included in a string.

Such characters must be escaped by placing a backslash before them.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Raw Strings

 If you want to specify a string that should not handle any escape
sequences and want to display exactly as specified, then you need to
specify that string as a raw string. A raw string is specified by
prefixing r or R to the string.

Example:

Variables and Identifiers:

Variables:
 Variable means its value can vary. You can store any piece of
information in a variable.
 Variables are nothing but just parts of your computer‟s memory where
information is stored. To identify a variable easily, each variable is given
an appropriate name.

Identifiers:
Identifiers are names given to identify something. This something can
be a variable, function, class, module or other object. For naming any
identifier, there are some basic rules like:

 The first character of an identifier must be an underscore ('_') or a

letter (upper or lowercase).
 The rest of the identifier name can be underscores ('_'), letters

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 (upper or lowercase), or digits (0-9).
 Identifier names are case-sensitive. For example, myvar and myVar
are not the same.
 Punctuation characters such as @, $, and % are not allowed within
identifiers.
 Examples of valid identifier names are sum, my_var, num1, r,
var_20, First, etc.
 Examples of invalid identifier names are 1num, my-var, %check,
Basic Sal, H#R&A, etc.,

Keyword in Python:
 Keywords are the reserved words in Python. We cannot use a
keyword as variable name, function name or any other identifier.
 Here's a list of all keywords in Python Programming.
 There are 33 keywords in Python 3.3. This number can vary slightly
in course of time.
 All the keywords except True, False and None are in lowercase and
they must be written as it is. The list of all the keywords are given
below.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Built in Data types:

 The variables can hold values of different type called Data Type.
 Data type is a set of values and the allowable operations on those values.
 Python has a great set of useful data types. Python's data types are
built in the core of the language. They are easy to use and
straightforward.
 Example a person age is stored in a number ,his name is made
only with characters, and his address is made with mixture of
numbers and characters.
 Python ha various standard data types to define the operations
possible on them and storage method for each of them.
 Python supports the following five standard data types.

Note: Python is pure object oriented programming [Link] refers

to everything as an object including numbers and strings.

 The Following Diagram shows the classification of Python Data

Types.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Assigning or Initializing Values to Variables:

 In Python, programmers need not explicitly declare variables to reserve

memory space. The declaration is done automatically when a value is
assigned to the variable using the equal sign (=). The operand on the left
side of equal sign is the name of the variable and the operand on its
right side is the value to be stored in that variable.

 Example: Program to display data of different types using variables

and literal constants.

 In Python , you can reassign variables as many times as you want to

change the value stored in them. You may even store value of one

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 data type in a statement and other data type in subsequent statement.
This is possible because Python variables do not have specific types, i.e.,
we can assign integer to the variable, later we assign string to the
same variable.
Example:Program to reassign value to

a variable val = “Hello‟

Multiple Assignments:
 Python allows programmers to assign single value to more than one
variable simultaneously.
 For example
>>>sum = flag = a = b
=0

 In the above statement, all four integer variables are assigned a

value [Link] can also assign different values to multiple variables
simultaneously as shown below
 For example
>>>sum, a, b, mesg = 0, 3, 5, “Result”

Here, variable sum,a and b are integers(numbers) and mesg is

assigned “Result”.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Note: Removing a variable means that the reference from the name to
the value has been [Link], deleted variables can be used again in
the code if and only if you reassign them some value.

Boolean Type:
A variable of Boolean type can have one of the two values- True or False.

Similar to other variables, the Boolean variables are also created while

we assign a value to them or when we use a relational operator on them.

Numbers:

 In Python, numeric data type is used to hold numeric values. Integers, floating-
point numbers and complex numbers fall under Python numbers category.

 They are defined as int, float and complex classes in Python. int - holds signed
integers of non-limited length. float - holds floating decimal points and it's
accurate up to 15 decimal places. complex - holds complex numbers.

Strings:

 The sequence of characters in the quotation marks can be used to describe the
string.

 A string can be defined in Python using single (‘ ‘) , double (“ “), or triple quotes
(‘ ‘ ‘ ‘ ‘ ‘).

 The operator + is used in the string to concatenate two strings

 The operator * is used to repeat the string values.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Tuples:

 A tuple is similar to the list as it also consists of a number of values

separated by commas and enclosed within parentheses.
 The main difference between lists and tuples is that you can change
the values in a list but not in a tuple. This means that while tuple is a
read only data type, the list is not.

Lists:

 Lists are the most versatile data type of Python language.

 A list consist of items separated by commas and enclosed within square
brackets The values stored in a list are accessed using indexes.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  The index of the first element being 0 and n-1 as that of the last
element, where n is the total number of elements in the list. Like
strings, you can alsouse the slice, concatenation and repetition
operations on lists.
 Example program to demonstrate
operations on lists list = ['a', 'bc', 78, 1.23]

Dic
tionary:

 Python‟s dictionaries stores data in key-value pairs.

 The key values are usually strings and value can be of any data type. The key
value pairs are enclosed with curly braces ({ }).

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  Each key value pair separated from the other using a colon (:). To
access any value in the dictionary, you just need to specify its key in
square braces ([]).Basically dictionaries are used for fast retrieval of data.

Example

Output Statement:

 To take input from the users, Python makes use of the input( ) function.
Theinput(
) function prompts the user to provide some information on which
theprogram can work and give the result.
 However, we must always remember that the input function takes
user‟s input as a string.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Example:

Comments:

 Comments are the non-executable statements in a program. They are

just added to describe the statements in the program code.
 Comments make the program easily readable and understandable by the
programmer as well as other users who are seeing the code. The
interpreter simply ignores the comments.
 In Python, a hash sign (#) that is not inside a string literal begins a
comment. All characters following the # and up to the end of the line
are part of the comment

 Note: For writing Multi line comments. Make sure to indent the
leading „ „
„ appropriately to avoid an Indentation Error
„„„

This is a multiline

comment.

„„„

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Indentation:
 Whitespace at the beginning of the line is called indentation. These
whitespaces or the indentation are very important in Python.
 In a Python program, the leading whitespace including spaces and
tabs at the beginning of the logical line determines the indentation
level of that logical line.

Example:

Operators:
 Operators are special symbols in Python that carry out arithmetic
or logical computation. The value that the operator operates on is
called the operand.
 For example:
>>> 2+3

5
Here, + is the operator that performs addition. 2 and 3 are the operands and 5 is the output
of the operation.
 Python supports the following operators
1. Arithmetic operators
2. Comparison (Relational) operators
3. Unary Operators
4. Bitwise operators
5. Shift Operators
6. Logical Operators
7. Membership and Identity Operators
8. Assignment operators

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 9. Special operators
Arithmetic Operators:

 Arithmetic operators are used to perform mathematical

operations like addition, subtraction, multiplication etc.
 This operator will work on two operands.
 Example: If a=100 and b=200 then look at the table below, to see
the result of arithmetic operations.

Comparision (Relational) Operators:

 A Relational or Comparison operator checks the relationship between
two operands. If the relation is true, it returns 1; if the relation is false, it
returns value 0.
 For Example assuming a=100 and b=2000,we can use the comparison
operators on them as specified in the following table.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Unary Operator
 Unary operators act on single operands. Python supports unary
minus operator.
 Unary minus operator is strikingly different from the arithmetic operator
that operates on two operands and subtracts the second operand from
the first operand.
 When an operand is preceded by a minus sign, the unary operator
negates its value.
 For example, if a number is positive, it becomes negative when preceded
with a unary minus operator. Similarly, if the number is negative, it
becomes positive after applying the unary minus operator. Consider
the given example.
b = 10 a = -(b)

 The result of this expression, is a = -10, because variable b has a

positivevalue. After applying unary minus operator (-) on the operand
b, the value becomes - 10, which indicates it as a negative value.

Bitwise Operators

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  As the name suggests, bitwise operators perform operations at the bit
level.
 These operators include bitwise AND, bitwise OR, bitwise
XOR, and shift operators.
 Bitwise operators expect their operands to be of integers and treat
them as a sequence of bits.
 The truth tables of these bitwise operators are given below.

 Example: If a=60 and b=13 then look at the table below, to see the
result of Bitwise operations.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Shift Operators:
 Python supports two bitwise shift operators. They are shift left
(<<) and shift right (>>).
 These operations are used to shift bits to the left or to the right. The
syntax for a shift operation can be given as follows:

Examples:

Logical Operators:

 Logical operators are used to simultaneously evaluate two

conditions or expressions with relational operators.
 Logical AND (and) If expressions on both the sides (left and right
side) of the logical operator are true, then the whole expression is true.
For example, If we have an expression (a>b) and (b>c), then the
whole expression is true only if both expressions are true. That is, if
b is greater than a and c.
 Logical OR (or) operator is used to simultaneously evaluate two

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 conditions or expressions with relational operators. If one or both the
expressions of the logical operator is true, then the whole expression
is true.
For example, If we have an expression (a>b) or (b>c), then the whole
expression is true if either b is greater than a or b is greater than c.

 Logical NOT (not) operator takes a single expression and negates the
value of the expression. Logical NOT produces a zero if the expression
evaluates to a non- zero value and produces a 1 if the expression
produces a zero. In other words, it just reverses the value of the
expression.
For example, a = 10; b = not a; Now, the value of b = 0.
Membership and Identity Operators:
Membership Operator

Python supports two types of membership operators–in and not in. These
operators, test for membership in a sequence such as strings, lists, or
tuples.

 in Operator: The operator returns true if a variable is found in the

specified sequence and false otherwise. For example, a in nums returns
1, if a is a member of nums.
 not in Operator: The operator returns true if a variable is not found in
the specified sequence and false otherwise. For example, a not in
nums returns 1,if a is not a member of nums.

Identity Operators

 is Operator: Returns true if operands or values on both sides of the

operator point to the same object and false otherwise. For example, if a
is b returns 1, if id(a) is same as id(b).
 is not Operator: Returns true if operands or values on both sides of the
operator does not point to the same object and false otherwise. For
example, ifa is not b returns 1, if id(a) is not same as id(b).


PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Assignment Operators:

 Assignment operators are used in Python to assign values to variables.

 a = 5 is a simple assignment operator that assigns the value 5 on
the right to the variable a on the left.
 There are various compound operators in Python like a += 5 that
adds to the variable and later assigns the same. It is equivalent
to a = a + 5.

Assignment operators in Python

Operator Example Equivatent 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

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 ^= x ^= 5 x=x^5

>>= x >>= 5 x = x >> 5

Operator Precedence:
 The operator precedence in Python are listed in the following
table. It is in descending order, upper group has higher precedence
than the lower ones.

Operator precedence rule in Python

Operators Meaning

() Parentheses

** Exponent

+x, -x, ~x Unary plus, Unary minus, Bitwise NOT

Multiplication, Division, Floor division, Modulus

*, /, //, %

+, - Addition, Subtraction

<<, >> Bitwise shift operators

& Bitwise AND

^ Bitwise XOR

| Bitwise OR

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 ==, !=, >, >=, <, <=, is,
Comparison, Identity, Membership operators
is not, in, not in

Expressions:
 An expression is any legal combination of symbols (like variables,
constants and operators) that represents a value.
 In Python, an expression must have at least one operand (variable or
constant) and can have one or more operators. On evaluating an
expression, we get a value. Operand is the value on which operator is
applied.
 Generally Expressions are divided into the following types
1. Constant Expressions: One that involves only
constants. Example: 8 + 9 – 2

2. Integral Expressions: One that produces an integer result after

evaluating the expression.
Example:a = 10

3. Floating Point Expressions: One that produces floating

point results. Example: a * b / 2.0

4. Relational Expressions: One that returns either true or false value.

Example: c = a>b

5. Logical Expressions: One that combines two or more relational

expressions and returns a value as True or False.
Example: a>b and y! = 0

6. Bitwise Expressions: One that manipulates data

at bit level. Example: x = y&z

7. Assignment Expressions: One that assigns a value

to a variable. Example: c = a + b or c = 10

Example Program:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Give the output for the following statements.( April 2018 Regular)

a = 20

b = 10

c = 15

d=5

print ("a:%d b:%d c:%d d:%d" %

(a,b,c,d )) e = (a + b) * c / d

print ("Value of (a + b) *

c / d is ", e) e = ((a + b)

* c) / d

print ("Value of ((a + b) *

c) / d is ", e) e = (a + b) * (c

/ d)

print ("Value of (a + b) *

(c / d) is ", e) e = a + (b *

c) / d

print ("Value of a + (b * c) / d is ", e)

Output:

a:20 b:10 c:15 d:5

Value of (a + b) * c /

d is 90.0 Value of ((a

+ b) * c) / d is 90.0

Value of (a + b) * (c /

d) is 90.0 Value of a

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 + (b * c) / d is 50.0

Type Conversion:
 In Python, it is just not possible to complete certain operations
that involves different types of data.
 For example, it is not possible to perform "2" + 4 since one
operand is an integer and the other is of string type.
>>>”20” + “30” >>> int(“2”) + int(“3”)

Output Output

„2030‟ 5

 Another situation in which type conversion is must when we want to

accept a non string value(integer or float) as an [Link] know that
input function returns string,so we must typecast the input to numbers
to performcalculations on them.
 Example1:
x=input(“Enter the first

number”)

y=input(“Enter the

second number”)

print(x+y)

output

Enter the first

number 6 Enter

the second

number 7 67

 Example2:
x=int(input(“Enter the

firstnumber))

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 y=int(input(“Enterthesecondnumb

er)) print(x+y)

Output

Enterthefirst

number6

Entertheseco

ndnumber7

13

 Python provides various built-in functions to convert value from one

data type to another [Link] following are the functions return
new object representing the coverted value. Some of them are given

in the following table.

print(str("The sum of two numbers

is"))

print(str(num1)+"+"+str(num2)+"="+st

r(res))

Arrays :

 An array is a collection of items stored at contiguous memory locations.

 The idea is to store multiple items of the same type together.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  Array in Python can be created by importing array module.
array(data_type,value_list) is used to create an array with datatype and value list
specified in its arguments.
 Array Representation

 syntax for creating an array: variable_name=array(typecode,[elements])

 variable_name would be the name of the array.

 The typecode specifies what kind of elements would be stored in the array.

Whether it would be an array of integers, an array of floats or an array of any

other Python data type. all elements should be of the same data type.

 Inside square brackets the elements that would be stored in the array is

mentioned with each element being separated by a comma.

 An empty array can be created as follows writing variable_name =

array(typecode) alone, without any elements.

 The following are the different typecodes that can be used with the different

data types when defining Python arrays:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Example : import array as arr numbers = [Link]('i',[10,20,30]) print(numbers) .
 First the array module is included, in this case with import array as arr .
 Then, a numbers array is created. o [Link]() is used, because of import array as arr.
 Inside the array() constructor, first I is included, for signed integer.
 Signed integer means that the array can include positive and negative values.
 Unsigned integer, with H for example, would mean that no negative values are
allowed.
 At Last, the values to be stored in the array in square brackets is included.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
 UNIT-II

Control Statements:
 A control statement is a statement that determines the control flow
of a set of instructions, i.e., it decides the sequence in which the
instructions in a program are to be executed.

 Types of Control Statements —

 Selection/Conditional Control: To execute only a

selected set of statements.

 Iterative Control: To execute a set of statements repeatedly.

 Un-conditional Control:

1. Selection /Conditional Branching Statements:

 Python language supports different types of conditional branching

statements which are as follows:

 if Statement

 if-else Statement

 Nested if statement

 if-elif-else statement.
1. if Statement:

 An if statement is a selection control statement which is based

on the value of a given Boolean Expression.
Syntax:

if test_expression:

statement 1

.....
statement n
statement x
 if structure may include 1 or n statements enclosed within if block.

 First, test expression is evaluated. If the test expression is

true, the statement of if block (statement 1 to n) are
executed, otherwise these statements will be skipped and
the execution will jump to statement x.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 if else Statement:
 The if.........else statement executes a group of statements when a test
expression is true; otherwise, it will execute another group of
statements.
Syntax:

if (test expression):
statement_block 1

else:
statement_block 2
statement x
 If the condition is true, then it will execute statement
block 1 and if the condition is false then it will execute
statement block 2.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Flowchart:

Example: Write a program to determine whether a person is eligible to vote:

Nested if Statements :
 A statement that contains other statements is called a compound
statement.

 To perform more complex checks, if statements can be

nested, that is, can be placed one inside the other.

 In such a case, the inner if statement is the statement part of the

outer one.

 Nested if statements are used to check if more than one

conditions are satisfied.

 if statements can be nested resulting in multi-

way selection. var = 100

if var < 200:

print( "Expression value is

less than 200") if var == 150:
print
("Which is

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 150‖) elif
var ==
100:
print
("Which is
100") elif
var == 50:
print
("Which is
50") elif
var < 50:
print ("Expression value is
less than 50") else:
print ("Could not find true
expression") print ("Good bye!")
Output:-

Expression value is
less than 200 Which
is 100
Good bye!
if-elif-else Statement :
 Python supports if-elif-else statements to test additional
conditions apart from the initial test expression.
 The if-elif-else construct works in the same way as a usual if-else
statement.

 If-elif-else construct is also known as nested-if construct.

 A series of if and elif statements have a final else block, which

is executed if none of the if or elif expressions is True.

Syntax:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 if (test expression 1):
statement block1

elif (test expression 2):

statement
block2
. . . . . . . . . . . . . . ..
elif( test expression N):

statement
block N

else:
statement block X

Flowchart:

Program: To test whether a number entered by the user is negative, positive,

or zero

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Looping Statements/Iterative Structure:
 Iterative statements are decision control statements that are used
to repeat the execution of a list of statements.

 Python supports 2 types of iterative statements-while loop and for loop.

while Loop :
 The While loop provides a mechanism to repeat one or more
statements while a particular condition is TRUE.
Syntax:

Statement x

while (condition):

Statement block

Statement y

 In while loop, the condition is tested before any of the

statements in the statement block is executed.
 If the condition is TRUE, only then the statements will be
executed otherwise if the condition is False, the control will
jump to statement y, that is the immediate statement outside
the while loop block.

Flowchart:

Example: Program to print first 10 numbers using a

while loop i=0

while(i<=10):

print
(i,
end=

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 ‖ ―)
i=i+1
Output: 0 1 2 3 4 5 6 7 8 9 10

for Loop:

 For loop provides a mechanism to repeat a task until a

particular condition is True. It is usually known as a
determinate or definite loop because the programmer knows
exactly how many times the loop will repeat.
 The for...in statement is a looping statement used in Python to
iterate over a sequence of objects.

Syntax:

for loop_control_var in sequence:

statement block

Flowchart:

for Loop and range() Function :

o The range( ) function is a built-in function in Python that is
used to iterate over a sequence of numbers.

Syntax:

range(beg, end, [step])

o The range( ) produces a sequence of numbers starting with
beg (inclusive) and ending with one less than the number end.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 o The step argument is option (that is why it is placed in
brackets). By default, every number in the range is incremented
by 1 but we can specify a different increment using step. It
can be both negative and positive, but not zero.
Example: Program to print first n numbers using the range() in a for loop

o If range( ) function is given a single argument, it produces an

object with values from 0 to argument-1. For example:
range(10) is equal to writing range(0, 10).
o If range( ) is called with two arguments, it produces values from
the first to the second. For example, range(0, 10) gives 0-9.
o If range( ) has three arguments then the third argument
specifies the interval of the sequence produced. In this case,
the third argument must be an integer. For example, range(1,
20, 3) gives 1, 4, 7, 10, 13, 16, 19.
Example:

1. Program that accepts an integer (n) and computes the value

of n+nn+nnn. (Eg. If n=5, find 5+55+555).

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Nested Loops :
 Python allows its users to have nested loops, that is,
loops that can be placed inside other loops.
 Although this feature will work with any loop like while loop
as well as for loop.

 A for loop can be used to control the number of times a

particular set of statements will be executed.
 Another outer loop could be used to control the number of
times that a whole loop is repeated.
 Loops should be properly indented to identify which
statements are contained within each for statement.

Example:

1. Program to print the following pattern

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 2. Program to display multiplication tables from 1 to 10
for i in range(1, 11):

for j in range(1, 11):

print(i, '*', j, '=', i*j)

Condition-controlled and Counter-controlled Loops :

The Break Statement:

 The break statement is used to terminate the execution
of the nearest enclosing loop in which it appears.

 The break statement is widely used with for loop and while loop.

 When compiler encounters a break statement, the control

passes to the statement that follows the loop in which the
break statement appears.

Example: Program to demonstrate the break statement

 Above code is meant to print first 10 numbers using a

while loop, but it will actually print only numbers from 0 to 4.
As soon as i becomes equal to 5, the break statement is
executed and the control jumps to the following while loop.
 Hence, the break statement is used to exit a loop from any
point with in its body, by passing its normal termination

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 expression. Below, Figure shows the transfer of control when
the break statement is encountered.

The Continue Statement:

 Like the break statement, the continue statement can only
appear in the body of a loop.
 When the compiler encounters a continue statement then
the rest of the statements in the loop are skipped and the
control is unconditionally transferred to the loop-
continuation portion of the nearest enclosing loop.

The Pass Statement:

 Pass statement is used when a statement is required
syntactically but no command or code has to be executed.
 It specified a null operation or simply No Operation
(NOP) statement. Nothing happens when the pass
statement is executed.

 The difference between a comment and pass statement is

that while the interpreter ignores a comment entirely,
pass is not ignored.

 Comment is not executed but pass statement is

executed but nothing happens.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  Pass is a null statement.
Example:

1. Program to demonstrate pass statement

Difference between break, continue and pass

 The break statement terminates the execution of the nearest
enclosing loop in which it appears.

 The continue statement skips the rest of the statements in the

loop transfer the control un-conditionally to the loop-
continuation portion of the nearest enclosing loop.

 The pass statement is a do-nothing statement in a loop. It is

just added to make the loop syntactically correct. i.e, a pass
statement is written as we can not have an empty body of
the loop.

The Else Statement Used With Loops:

 In Python you can have the else statement associated
with a loop statements.
 If the else statement is used with a for loop, the else
statement is executed when the loop has completed iterating.
 But when used with the while loop, the else statement is
executed when the condition becomes false.
Examples:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Unit-III

Functions:
 A function is a block of organized and reusable program code
that performs a single, specific, and well-defined task.
 Python enables its programmers to break up a program into
functions, each of which can be written more or less independently
of the others. Therefore, the code of one function is completely
insulated from the codes of the other functions.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Figure 1: Calling a function
 In figure 1 which explains how a function func1() is called to
perform a well- defined task. As soon as func1() is called, the
program control is passed to the first statement in the function.
All the statements in the function are executed and then the
program control is passed to the statement following the one that
called the function.

Figure 2: Function calling another function

In figure 2 func1() calls function named func2(). Therefore,
func1() is known as the calling function and func2() is known as
the called function. The moment the compiler encounters a
function call, instead of executing the next statement in the
calling function, the control jumps to the statements that are a
part of the called function. After called function is executed, the
control is returned back to the calling program.
 It is not necessary that the func1() can call only one function,
it can call as many functions as it wants and as many times as
it wants. For example, a function call placed within for loop or
while loop may call the same function multiple times until the
condition holds true.
Need for Functions:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Figure 3: Top-down approach of solving a problem
 Each function to be written and tested separately.
 Understanding, coding and testing multiple separate functions
are far easier than doing the same for one huge function.
 When a big program is broken into comparatively smaller
functions, then different programmers working on that project
can divide the workload by writing different functions.
 All the libraries in Python contain pre-defined and pre-tested
functions which the programmers are free to use directly in their
programs, without worrying about their code details. This speed up
program development.
 Like Python libraries, programmers can also make their own
functions and use them from different points in the main
program or any other program that needs its functionalities.
So code reuse is one of the most prominent reasons to use
functions.

Function Declaration and Definition:

• A function, f that uses another function g, is known as the calling
function and g is known as the called function.
• The inputs that the function takes are known as arguments/parameters.
• When a called function returns some result back to the calling function, it
is said to return that result.
• The calling function may or may not pass parameters to the called
function. If the called function accepts arguments, the calling function
will pass parameters, else not.
• Function declaration is a declaration statement that identifies a
function with its name, a list of arguments that it accepts and the
type of data it returns.
• Function definition consists of a function header that identifies
the function, followed by the body of the function containing the
executable code for that function.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Function Definition:
There are two basic types of functions
1. built-in functions eg: dir(), len(), abs() etc.,
2. user defined functions.
 Function blocks starts with the keyword def.
 The keyword is followed by the function name and parentheses (( )).
 After the parentheses a colon (:) is placed.
 Parameters or arguments that the function accept are
placed within parentheses.
 The first statement of a function can be an optional statement - the
Docstring describe what the function does.
 The code block within the function is properly indented to form the
block code.
 A function may have a return[expression] statement. That
is, the return statement is optional.
 You can assign the function name to a variable. Doing this will
allow you to call same function using the name of that variable.

Figure 4: Program that subtracts two numbers using a function.

Figure 5: The syntax of a function definition.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Function Call:
 Defining a function means specifying its name,
parameters that are expected, and the set of
instructions.
 The function call statement invokes the function. When a
function is invoked the program control jumps to the called
function to execute the statements that are a part of that
function. Once the called function is executed, the program
control passes back to the calling function.
Function Parameters:
 A function can take parameters which are nothing but some values
that are passed to it so that the function can manipulate them to
produce the desired result. These parameters are normal variables
with a small difference that the values of these variables are
defined (initialized) when we call the function and are then passed
to the function.
 Function name and the number and type of arguments in the
function call must be same as that given in the function
definition.
 If the data type of the argument passed does not matches with
that expected in function then an error is generated.

Figure 6: a function that displays string repeatedly.

Figure 7: Program to demonstrate mismatch of name of function

parameters and arguments.
Note: Names of variables in function call and header of function definition
may vary.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Figure 8: Arguments may be passed in the form of expressions to the called
function.

Figure 9: Program to add two integers using functions.

Variable scope and lifetime:

In python, you cannot just access any variable from any part of your
program. Some of the variables may not even exist for the entire
duration of the program. In which part of the program you can access a
variable and in which parts of the program a variable exits depends on
how the variable has been declared. Therefore, we need to understand
these two things:
1. Scope of the variable: Part of the program in which a variable is
accessible is called its scope.
2. Lifetime of the variable: Duration for which the variable exits it‟s called its
lifetime.
Local and Global variables:
 A variable which is defined within a function is local to that
function. A local variable can be accessed from the point of its

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 definition until the end of the function in which it is defined.

 It exists as long as the function is executing. Function parameters

behave like local variables in the function. Moreover, whenever we
use the assignment operator (=) inside a function, a new local
variable is created.

 Global variables are those variables which are defined in the main
body of the program file.

 They are visible throughout the program file. As a good

programming habit, you must try to avoid the use of global
variables because they may get altered by mistake and then result
in erroneous output.

Figure 10: lists the differences between global and local variables.
Comparison between global and local variables:

Global variables Local variables

They are defined in the main body of They are defined within a function and
the program file. is local to that function.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 They can be accessed throughout the They can be accessed from the point of
program life. its definition until the end of the block
in which it is defined.
Global variables are accessible to all They are not related in any way to
functions in the program. other variables with the same names
used outside the function.
Using the Global Statement
 To define a variable defined inside a function as global, you must use
the global statement.

 This declares the local or the inner variable of the function to have
module scope.
Key points to remember:
 You can have a variable with the same name as that of a global variable in
the program.
 In such a case a new local variable of that name is created which is
different from the global variable.

Resolution of names
 Scope defines the visibility of a name within a block. If a local variable is
defined in a block, its scope is that particular block. If it is defined in a
function, then its scope is all blocks within that function.

 When a variable name is used in a code block, it is resolved using

the nearest enclosing scope. If no variable of that name is found, then
a NameError is raised.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  In the code given below, str is a global string because it has been
defined before calling the function.

Figure 12: Program that demonstrates using a variable defined in global

namespace.
The Return Statement:
The syntax of return statement is,
return [expression]
 The expression is written in brackets because it is optional. If the
expression is present, it is evaluated and the resultant value is
returned to the calling function. However, if no expression is
specified then the function will return none.
 The return statement is used for two things.

• Return a value to the caller

• To end and exit a function and go back to its caller

Function Argument:
1. Required arguments
2. Keyword arguments

3. Default arguments
4. Variable-length arguments
Required Arguments
In the required arguments, the arguments are passed to a function in correct

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

positional order. Also, the number of arguments in the function call should
exactly match with the number of arguments specified in the function definition
Example:

Keyword Arguments
When we call a function with some values, the values are assigned to
the arguments based on their position. Python also allow functions to
be called using keyword arguments in which the order (or position) of
the arguments can be changed. The values are not assigned to
arguments according to their position but based on their name (or
keyword).
Keyword arguments are beneficial in two cases.
• First, if you skip arguments.
• Second, if in the function call you change the order
of parameters. Example:

Default Arguments
Python allows users to specify function arguments that can have default
values. This means that a function can be called with fewer arguments
than it is defined to have. That is, if the function accepts three
parameters, but function call provides only two arguments, then the
third parameter will be assigned the default (already specified) value.
The default value to an argument is provided by using the assignment
operator (=). Users can specify adefault value for one or more

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 arguments.
Example:

Variable-length Arguments
In some situations, it is not known in advance how many arguments will
be passed to a function. In such cases, Python allows programmers to make
function calls with arbitrary (or any) number of arguments.
When we use arbitrary arguments or variable length arguments, then
the function definition use an asterisk (*) before the parameter name.
The syntax for a function using variable arguments can be given as,

Example:

Recursion Functions
A recursion function is defined as a function that calls itself to solve a
smaller version of its task until a final call is made which does not
require a call to itself. Every recursive solution has two major cases,
which are as follows:
• base case, in which the problem is simple enough to be solved

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 directly without making any further calls to the same function.
• recursive case, in which first the problem at hand is divided into
simpler sub parts. Recursion utilized divide and conquer technique of
problem solving.

Strings:

 Python treats strings as contiguous series of characters delimited

by single, double or even triple quotes. Python has a built-in string
class named "str" that has many useful features. We can
simultaneously declare and define a string by creating a variable of
string type. This can be done in several ways which are as follows:
 name = "India" graduate = 'N' country = name nationality = str("Indian")

 Indexing: Individual characters in a string are accessed using the

subscript ([ ]) operator. The expression in brackets is called an
index. The index specifies a member of an ordered set and in this
case it specifies the character we want to access from the given set
of characters in the string.
 The index of the first character is 0 and that of the last character is n-
1 where n is the number of characters in the string. If you try to exceed
the bounds (below 0 or above n-1), then an error is raised.
 Traversing a String: A string can be traversed by accessing
character(s) from one index to another. For example, the following
program uses indexing to traverse a string from first character to the
last.
Example:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Concatenating, Appending and Multiplying Strings
Example: Program to concatenate two strings using + operator

String Operation:
Python offers a wide range of operations and built-in methods for working with
strings, which are fundamental data types for representing textual information.
Here's a breakdown of common string operations:
1. Creating strings

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Strings are created by enclosing characters in single quotes ( ' ' ), double quotes ( " " ), or triple

quotes ( ''' ''' or """ """ ).

 Triple quotes are particularly useful for defining multi-line strings or strings containing both single
and double quotes.

2. Accessing characters
 Individual characters in a string can be accessed using indexing, with the first character at index 0.

 Negative indexing allows access from the end of the string, where -1 refers to the last character.

 String slicing extracts a portion of a string using the syntax string[start:stop:step] , where start is

inclusive, stop is exclusive, and step is optional.

3. Combining and repeating strings

 The + operator concatenates two or more strings.

 The * operator repeats a string.

 The join() method combines elements of an iterable into a single string using a specified

separator.

4. String manipulation methods

Python's built-in string methods return new, modified strings because strings are immutable.
Some common methods include:

 Case conversion: upper() , lower() , capitalize() , title() , swapcase() .

 Trimming: strip() (removes leading/trailing whitespace), lstrip() , rstrip() .

 Search and replace: find() , replace() , startswith() , endswith() .

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  Splitting and joining: split() (splits into a list), join() (joins iterable elements).

 Checking string properties: isalnum() , isdigit() , islower() , isupper() .

5. String formatting

Formatted strings can be created using the % operator (older style), the format() method, or f-

strings (Python 3.6+).

6. String comparison

Strings can be compared using == and != for identity and < , <= , > , >= for lexicographical

order. Case-insensitive comparison can be done by converting both strings to the same case using

methods like lower() or casefold() .

7. Other important operations

Other operations include reversing a string using slicing [::-1] , counting substrings with

count() , finding substrings with methods like find() and index() , and checking for substring

existence using the in operator.

Mastering these operations is crucial for effective text data handling in Python

Strings are Immutable:

Python strings are immutable which means that once created they
cannot be changed. Whenever you try to modify an existing string
variable, a new string is created.
Example:

String Formatting Operator

 The % operator takes a format string on the left (that has %d, %s,
etc) and the corresponding values in a tuple on the right. The
format operator, % allow users to construct strings, replacing

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 parts of the strings with the data stored in variables. The syntax
for the string formatting operation is:
 "<Format>" % (<Values>)
Example:

Built-in String Methods and Functions:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
String Comparison:
Python supports several operators for string comparison, including ==, !=, <, <=, >,
and >=. These operators allow for both equality and lexicographical (alphabetical
order) comparisons, which is useful when sorting or arranging strings.
Let’s start with a simple example to illustrate these operators.

s1 = "apple"

s2 = "banana"

# "apple" is not equal to "banana", therefore it is False

print(s1 == s2)

# "apple" is different from "banana", therefore it is True

print(s1 != s2)

# "apple" comes before "banana" lexicographically, therefore it is True

print(s1 < s2)

Output
False

True

True

== Operator for Equality Check:

The == operator is a simple way to check if two strings are identical. If both strings are
equal, it returns True; otherwise, it returns False.

s1 = "Python"

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

s2 = "Python"

# Since both strings are identical, therefore it is True

print(s1 == s2)
Output
True

!= Operator for Inequality Check:

The != operator helps to verify if two strings are different. If the strings are different
then it will return True, otherwise returns False.

s1 = "Python"

s2 = "Java"

# "Python" is different from "Java", therefore it is True

print(s1 != s2)
Output
True

Lexicographical Comparison:
Lexicographical comparison checks if one string appears before or after another in
alphabetical order. This is especially useful for sorting.

s1 = "apple"

s2 = "banana"

# "apple" appears before "banana" alphabetically, therefore it is True

print(s1 < s2)

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

# "banana" comes after "apple", therefore it is True

print(s2 > s1)

Output
True

True

Case-Insensitive Comparison
Strings in Python can be compared case-insensitively by converting both strings to
either lowercase or uppercase.

s1 = "Apple"

s2 = "apple"

# Both strings are same ignoring case, therefore it is True

print([Link]() == [Link]())
Output
True

Modules:
 We have seen that functions help us to reuse a particular
piece of code. Module goes a step ahead. It allows you to reuse
one or more functions in your programs, even in the programs
in which those functions have not been defined.
 Putting simply, module is a file with [Link] extension that has
definitions of all functions and variables that you would like to use
even in other programs.
 The program in which you want to use functions or variables
defined in the module will simply import that particular module

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 (or .py file).
 Modules are pre-written pieces of code that are used to perform
common tasks like generating random numbers, performing
mathematical operations, etc.

 The basic way to use a module is to add import module_name as

the first line of your program and then writing module_name.var
to access functions and values with the name var in the module
The from…import Statement
A module may contain definition for many variables and functions.
When you import a module, you can use any variable or function defined
in that module. But if you want to use only selected variables or
functions, then you can use the from...import statement. For example, in
the aforementioned program you are using only the path variable in the
sys module, so you could have better written from sys import path.
Example:

To import more than one item from a module, use a comma

separated list. For example, to import the value of pi and sqrt() from
the math module you can write,

Making your own Modules

Every Python program is a module, that is, every file that you save as .py
extension is a module.

 Modules should be placed in the same directory as that of the

program in which it is imported. It can also be stored in one of
the directories listed in [Link].

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 The dir() function
dir() is a built-in function that lists the identifiers defined in a module.
These identifiers may include functions, classes and variables. If no
name is specified, the dir() will return the list of names defined in the
current module.
Example: demonstrate the use of dir() function.

The Python Module:

 We have seen that a Python module is a file that contains some
definitions and statements. When a Python file is executed
directly, it is considered the main module of a program.
 Main modules are given the special name main and provide
the basis for a complete Python program.
 The main module may import any number of other modules
which may in turn import other modules. But the main module of
a Python program cannot be imported into other modules.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Modules and Namespaces
 A namespace is a container that provides a named context for
identifiers.
 Two identifiers with the same name in the same scope will lead to
a name clash.
 In simple terms, Python does not allow programmers to have two
different identifiers with the same name.
 However, in some situations we need to have same name
identifiers.
 To cater to such situations, namespaces is the keyword.
Namespaces enable programs to avoid potential name clashes by
associating each identifier with the namespace from which it
originates.
Example:

Local, Global, and Built-in Namespaces

 During a program‟s execution, there are three main namespaces
that are referenced- the built-in namespace, the global namespace,
and the local namespace.

 The built-in namespace, as the name suggests contains names of

all the built-in functions, constants, etc that are already defined in
Python.

 The global namespace contains identifiers of the currently

executing module and the local namespace has identifiers defined
in the currently executing function (if any).

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  When the Python interpreter sees an identifier, it first searches the
local namespace, then the global namespace, and finally the built-in
namespace.

 Therefore, if two identifiers with same name are defined in more

than one of these namespaces, it becomes masked.
Example: Program to demonstrate name clashes in different namespaces.

Module Private Variables

 In Python, all identifiers defined in a module are public by
default. This means that all identifiers are accessible by any
other module that imports it. But, if you want some variables or
functions in a module to be privately used within the module,
but not to be accessed from outside it, then you need to declare
those identifiers as private.
 In Python identifiers whose name starts with two underscores (
) are known as private identifiers. These identifiers can be used
only within the module. In no way, they can be accessed from
outside the module.
 Therefore, when the module is imported using the import * form
modulename, all the identifiers of a module‟s namespace is
imported except the private ones (ones beginning with double
underscores). Thus, private identifiers become inaccessible from
within the importing module.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 Advantages of Modules:
 Python modules provide all the benefits of modular software
design. These modules provide services and functionality that
can be reused in other programs.

 Even the standard library of Python contains a set of modules.

It allows you to logically organize the code so that it becomes
easier to understand and use.

Defining Our Own Modules:

[Link] the module file

 Create a new Python file (e.g., [Link] ).

 Inside this file, define your functions, variables, classes, or any other code you want to make
available.

 For instance, [Link] could contain the following:

[Link] the module into another file

 In another Python file where you want to use the module (e.g., [Link] ), use
the import statement followed by the module's name (without the .py extension).

 For example:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 [Link] elements from the module:
 After importing, you can access the functions, variables, or classes defined in the module using
dot notation: module_name.element_name .

 Alternatively, use the from keyword to import only specific elements from the module without
needing to prefix with the module name. For example:

[Link] a module
 You can create an alias for a module using the as keyword during import to shorten the module
name for easier use. For instance:

[Link] dir()
 The built-in dir() function can be used to list all the defined names (functions, variables, etc.)
within a module, including both built-in and user-defined modules. Example:

In essence, defining your own module in Python involves creating a .py file with your

reusable code and importing it into other scripts, promoting organization, code
reusability, and maintainability.
UNIT-IV

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

LISTS:

 The most basic data structure in Python is the sequence. Each element of a
sequence is assigned a number - its position or index.

 The first index is zero, the second index is one, and so forth. There are certain things
you can do with all sequence types. These operations include indexing, slicing,
adding, multiplying, and checking for membership.

Creating a List:

 Creating a list is as simple as putting different comma-separated values between

square brackets. Similar to string indices, list indices start at 0, and lists can be
sliced, concatenated and so on.

Syntax:

List_variable = [val1,val2,…]

Example:
list_A =[1,2,3,4]
print(list_A)

Output:
[1,2,3,4]

Accessing values in lists:

 Similar to strings, lists can be sliced and concatenated.
 To access values in lists, square brackets are used to slice along
with index or indices to get value stored at that index.
syntax

s=list[start:stop:step]
Example 1:

num_list=[1,2,3,4,5,6,7,8,9,10]

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 print(“num_list is:”,num_list)

print(“first element in the list

is”,num_list[0])

print(“num_list[2:5]=”,num_list[2:5])

print(“num_list[::2]=”,num_list[::2])

print(“num_list[1::3]=”,num_list[1::3])

Output:

num_list is:

[1,2,3,4,5,6,7,8,9,10]

first elemnent in the

list is 1 num_list[2:5]=

[3,4,5]

num_list[::2]= [1,3,5,7,9]

num_list[1::3]= [2,5,8]

Updating values in the lists:

 once created, one or more elements of a list can be easily updated by

giving the slice on the left-hand side of the assignment operator.
 You can also append new values in the list and remove existing values
from the list using the append( ) method and del statement
respectively.

Example:

num_list= [1,2,3,4,5,6,7,8,9,10]
print(“list is:”,num_list) num_list[5]=100

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 print(“List after updation is:”,num_list) num_list.append(200)
print(“List after appending a value is: “,num_list) del num_list[3]
print(“List after deleting a value is:”,num_list)

Output:

list is: [1,2,3,4,5,6,7,8,9,10]

List after updation is: [1,2,3,4,5,100,7,8,9,10]

List after appending a value is:

[1,2,3,4,5,100,7,8,9,10,200] List after deleting a

value is: [1,2,3,5,100,7,8,9,10,200]

Nested Lists:

 Nested list in Python allow a list to contain multiple sub lists. Items in each sub list may be
of various data types.
 Comma-separated sub lists and items can be combined to create them. The inner lists can
again contain other lists thus creating multiple levels of nesting.
 The nested lists in Python can be used to create hierarchical data structures, matrices or
simply a list of lists.
 Python has tools for handling nested lists effortlessly and applying standard functions to
the nested lists.
How to Create a List in Python
You can create a list using square brackets [] and then add elements inside the brackets,
separated by commas. Let's take a look at an example.
vegetables = ["carrot", "broccoli", "spinach", "tomato", "cucumber"]
print(vegetables)

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Example of the Nested List in Python:-
The example below creates a nested list ‘mat’ containing two inner lists which represents a 2x3
matrix.
mat = [[i for i in range(3)] for j in range(2)]
# Displaying Nested List
print(mat)

Accessing Element of the Nested List:

A nested list has multiple indexes that you can use to access specific items. It resembles indexing
in a list where the index begins with 0 and ends with list length-1.
num = [1, 2, [3, 4, [5, 6]], 7, 8]

print(num[2])
# Prints [3, 4, [5, 6]]

print(num[2][2])
# Prints [5, 6]

print(num[2][2][0])
# Prints 5

Inserting Element of Nested List:

 We can use either the append function or the insert function to add items to a nested list.
 The element or list is appended to the end of the list by the append() function, which
accepts it as a parameter.
 The position at which the item is to be inserted and the element or list to be inserted are
the two parameters required by the insert() function.

num = [1, 2, [3, 4, [5, 6]], 7, 8]

[Link]([8,9,10])
print(num)

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Displaying Element of the Nested List:
Let's say we want to show every item in a list. We can use the for or while loop to repeatedly
iterate over the elements.
num = [1, 2, [3, 4, [5, 6]], 7, 8]
i=0
for j in num:
# Printing element key wise
print(f"{i}: {j}")
i=i+1

Deleting Element of the Nested List:

The Python pop() function or del keyword can remove items or lists from nested lists.
In Python, the del keyword is used to delete objects, including variables and lists. The pop
function removes the final element of a nested list without requiring any parameters.
num = [1, 2, [3, 4, [5, 6]], 7, 8]

# Deleting the third index element

del num[3]
print(num)

# Deleting last element in the list

[Link]()
print(num)

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Flattening Element of the Nested List:
It is the method of converting a nested list into a single uniform list. These nested lists are
accessed for specific elements by utilizing a filtering condition.
num = [[1] ,[2, 4], [3,2,1], [7,5,6,9]]

# Flattening the nested list

f_list = [value for sub in num for value in sub]

print(f_list)

Advantages of Nested list:

Nested lists offer several advantages for data organization and manipulation:
 Hierarchical Data Representation: They excel at representing data with inherent hierarchies.
Imagine an organizational chart, family tree, or bill of materials. Each level of the hierarchy
can be a sublist within the main list.
 Complex Data Structures: Nested lists can create intricate data structures that go beyond
simple flat lists. For example, a list of students can have sublists containing their names,
grades, and course information.
 Flexible Data Storage: Each element in the outer list can hold various data types, including
other lists. This versatility allows you to store diverse datasets within a single nested list
structure.
 Multi-dimensional Arrays: Nested lists can effectively represent multi-dimensional arrays,
like matrices or grids. The outer list represents rows, and inner lists represent columns.
Disadvantages of Nested Lists:
While powerful, nested lists also have some drawbacks:
 Increased Complexity: Deeply nested lists can become complex and challenging to navigate
and understand, especially for larger datasets.
 Potential for Errors: Accessing and manipulating elements within nested structures can be
error-prone, requiring careful indexing to avoid mistakes.
 Performance Overhead: Nested lists might have slower performance compared to
specialized data structures like NumPy arrays for numerical computations due to memory
management.
 Readability: Very nested lists can become difficult to read and maintain, especially for
someone unfamiliar with the data structure.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Basic list operations:

Operatio n Description Example Output

len Returns length of list len([1,2,3,4,5,6,7,8,9,1 10

0])

concatenation Joins two lists [1,2,3,4,5]+[6,7,8,9,10] [1,2,3,4,5,6,7,8,9,10]

repetition Repeats elements in the “Hello”,”World”*2 [„Hello‟,‟World‟,‟H

lists ello‟
,‟World‟]
in Checks if the value is „a‟ True
present in the list in[„a‟,‟e‟,‟i‟,‟o‟,‟u‟]
not in Checks if the value is not 3 not in [0,2,4,6,8] True
present in the list
max Returns maximum value num_list=[6,3,7,0,1,2, 4,9] 9
in the list print(max(num_list))
min Returns minimum value num_list=[6,3,7,0,1,2, 4,9] 0
in the list print(min(num_list))
sum Adds the values in the num_list=[1,2,3,4,5,6, SUM=55
list that has numbers 7,8,9,10]
print(“SUM=”,sum(nu
m_list))
all Returns True if all num_list=[0,1,2,3] False
elements of the list are print(all(num_list))
true(or if the list is
empty)
any Returns True if any num_list=[6,3,7,0,1,2, 4,9] True
element of the list is print(any(num_list))
true. if the list is empty
return false
list Converts list1=list(“HELLO”) [„H‟,‟E‟,‟L‟,‟L‟,‟O‟
iterable(tuple,string,set, print(list1) ]
d ictionary)
sorted Returns a new sorted list1=[3,4,1,2,7,8] [1,2,3,4,7,8]
list. The original list not list2=sorted(list1)
sorted print(list2)

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

List Methods:
 There are several built-in list Methods in python. It is used to used to do operation in
python's list.

 There are methods like append(), pop(), insert() and many more.

 These methods helps developers to efficiently to modify data structures to meet their
programming needs.

[Link]():

o Syntax: [Link](element)
o Description: Appends an element to the end of the list.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
Tuple Definition:

1. A tuple is a sequence of immutable objects. That is, you can

change the value of one or more items in a list; you cannot change
the values in a tuple.

2. Tuples use parenthesis to define its elements. Whereas lists use square
brackets.
Creating a Tuple:

Creating a tuple is as simple as putting different comma-separated

values. Optionally you can put these comma-separated values between
parentheses.

Syntax: Tup1=(val1,val2,….)

Where val (or values) can be an integer, a floating number, a character, or a

string.

Examples:

1) Tup1=( ) #creates

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 an empty tuple.
print(Tup1)

output:

note: no ouput will be displayed.

2) Tup1=(5) #creates a tuple with

single element print(Tup1)

Output:

5
Accessing values of tuples:

 Like strings and lists tuples indices also starts with 0.

 The operations performed are slice, concatenate etc.,
 To access values in tuple, slice operation is used along with the index.

The tuple values can be accessed using square brackets:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Updating tuples:

As we all know tuples are immutable objects so we cannot update the

values but we can just extract the values from a tuple to form another
tuple.

Deleting elements of a tuple:

1. Deleting a single element in a tuple is not possible as we know tuple is

a immutable object.

Hence there is another option to delete a single element of a tuple

i.e..,you can create a new tuple that has all elements in your tuple
except the ones you don‟t want.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Nested tuples:

Tuples can contain other tuples as elements, which are known as nested tuples. Accessing
elements in nested tuples requires additional indexing.

Creating Nested Tuples

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Explanation: By looping through the outer tuple and unpacking each inner tuple,
we can access all the nested elements.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Difference between lists and tuples:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Dictionaries:
 It is a data structure in which we store values as a pair of key and value.
 Each key is separated from its value by a colon (:), and consecutive items are
separated by commas.
 The entire items in a dictionary are enclosed in curly brackets ({}).
Syntax:

dictionary_name = {key_1: value_1, key_2: value_2, key_3: value_3}

o Keys in the dictionary must be unique and be of any immutable data

type (like Strings, numbers, or tuples), there is no strict requirement
for uniqueness and type of values.
o Values of a key can be of any type.
o Dictionaries are not Sequences, rather they are mappings.
o Mappings are collections of objects that are store objects by key
instead of by relative position.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Creating a Dictionary:
o The Syntax to create an empty dictionary can be given as:
Dictionary_variable= { }
o The Syntax to create a dictionary with key-value pair is:
Dictionary_variable= {key1:val1, key2:val2……}
o A dictionary can be also created by specifying key-value
pairs separated

o by a colon in curly brackets as shown below.

o Note that one key value pair is separated from the other using a
comma.
Example:
d={'roll_no':'18/001','Name:':'Arav','Course':'[Link]'}
print(d)
Output:
{'Name:': 'Arav', 'Course': '[Link]', 'roll_no': '18/001'}

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM
Dictionary Functions and Methods:
 clear() method removes all items from the dictionary.

Example:

d = {1: "one", 2: "two"}

[Link]()

print('d =', d)

Output:

d = {}

 copy() method returns a shallow copy of the dictionary.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Example:

original = {1:'one', 2:'two'}

new = [Link]()

print('Orignal: ', original)

print('New: ', new)

Output:

Orignal: {1: 'one', 2: 'two'}

New: {1: 'one', 2: 'two'}

 fromkeys(sequence[, value]) method creates a new dictionary from the given sequence
of elements with a value provided by the user.

sequence - sequence of elements which is to be used as keys for the new dictionary

value (Optional) - value which is set to each each element of the dictionary

Example:

# vowels keys

keys = {'a', 'e', 'i', 'o', 'u' }

vals = ‘vowels’

vowels = [Link](keys)

print(vowels)

Output: {'i': None, 'a': None, 'u': None, 'o': None, 'e': None}

 get(key[, value]) - returns the value for the specified key if key is in dictionary

key - key to be searched in the dictionary

value (optional) - Value to be returned if the key is not found. The default value is None

Example:

person = {'name': 'Phill', 'age': 22}

print('Name: ', [Link]('name'))

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

print('Age: ', [Link]('age'))

# value is not provided

print('Salary: ', [Link]('salary'))

# value is provided

print('Salary: ', [Link]('salary', 0.0))

 items() method returns a view object that displays a dictionary of dictionary's (key, value)
tuple pairs

Example:

# random sales dictionary

sales = { 'apple': 2, 'orange': 3, 'grapes': 4 } print([Link]())

Output:

dict_items([('apple', 2), ('orange', 3), ('grapes', 4)])

 keys() method returns a view object that displays a dictionary of all the keys in the
dictionary

Example:

person = {'name': 'Phill', 'age': 22, 'salary': 3500.0}

print([Link]())

empty_dict = {}

print(empty_dict.keys())

Output:

dict_keys(['name', 'salary', 'age'])

dict_keys([])

 popitem() method removes and returns the last element (key, value) pair inserted into
the dictionary

 Returns the latest inserted element (key,value) pair from the dictionary and removes the
returned element pair from the dictionary.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Example:

person = {'name': 'Phill', 'age': 22, 'salary': 3500.0}

# ('salary', 3500.0) is inserted at the last, so it is removed.

result = [Link]()

print('Return Value = ', result)

print('person = ', person)

# inserting a new element pair

person['profession'] = 'Plumber'

# now ('profession', 'Plumber') is the latest element

result = [Link]()

Output

Return Value = ('salary', 3500.0)

person = {'name': 'Phill', 'age': 22} Return Value = ('profession', 'Plumber') person =
{'name': 'Phill', 'age': 22}

The popitem() method raises a KeyError error if the dictionary is empty

 setdefault(key[, default_value]) -- method returns the value of a key (if the key is in
dictionary). If not, it inserts key with a value to the dictionary.

 key - the key to be searched in the dictionary

 default_value (optional) - key with a value default_value is inserted to the dictionary if

the key is not in the dictionary.
If not provided, the default_value will be None

Return Value from setdefault()

setdefault() returns:

 value of the key if it is in the dictionary

 None if the key is not in the dictionary and default_value is not specified

 default_value if key is not in the dictionary and default_value is specified

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 person = {'name': 'Phill'}

# key is not in the dictionary

salary = [Link]('salary')

print('person = ',person)

print('salary = ',salary)

# key is not in the dictionary and default_value is provided

age = [Link]('age', 22)

print('person = ',person)

print('age = ',age)

Output:

person = {'name': 'Phill', 'salary': None}

salary = None

person = {'name': 'Phill', 'age': 22, 'salary': None}

age = 22

Dictionary Methods:
 pop(key[, default]) - method removes and returns an element from a dictionary having
the given key

 key - key which is to be searched for removal

default - value which is to be returned when the key is not in the dictionary

Example:

sales = { 'apple': 2, 'orange': 3, 'grapes': 4 }

element = [Link]('apple')

print('The popped element is:', element)

print('The dictionary is:', sales)

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

Output:

The popped element is: 2

The dictionary is: {'orange': 3, 'grapes': 4}

If key is not found and default argument is not specified - KeyError exception is raised

 values() method returns a view object that displays a list of all the values in the dictionary.

Example:

sales = { 'apple': 2, 'orange': 3, 'grapes': 4 } print([Link]())

Output:

dict_values([2, 4, 3])

 update([other]) method updates the dictionary with the elements from the another
dictionary object or from an iterable of key/value pairs

 The update() method takes either a dictionary or an iterable object of key/value pairs
(generally tuples).

 If update() is called without passing parameters, the dictionary remains unchanged.

Example:

d = {1: "one", 2: "three"}

d1 = {2: "two"}

# updates the value of key 2

[Link](d1)

print(d)

d1 = {3: "three"}

# adds element with key 3 d.

update(d1) print(d)

Output:

{1: 'one', 2: 'two'}

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 {1: 'one', 2: 'two', 3: 'three‘}

 Python has some built-in aggregate functions like:

 Len(dict) – returns the length of the given dictionray

o my_dict = { ‘Rollno’ : 101, ‘Name’ : ‘Arav’ , ‘Course’: ‘[Link]’}

o print(len(my_dict)) #output: 3

 all()Return True if all keys of the dictionary are True (or if the dictionary is empty).

 any() function returns True if any element of an iterable is True. If not, any() returns False.

o # 0 is False d = {0: 'False'}

 print(any(d)) # 1 is True d = {0: 'False', 1: 'True'} print(any(d))

Difference between Lists and Dictonaries:

***************************UNIT-4 COMPELETED*********************************

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 UNIT-V
Python File Handling:
 When a program is being executed, its data is stored in RAM. Though RAM
can be accessed faster by the CPU,it is also volatile, which means when the
program ends, or the computer shuts down, all the data is lost.

 If you want to use the data in future,then you need to store this data on a
permanent or non- volatile storage media such as hard disk, USB drive and
DVD e.t.c.,
 A file is a collection of data stored on a secondary storage device like hard
disk.
 A file is basically used because real-life applications involve large amounts of
data and in such situations the console oriented I/O operations pose two
majorproblems:
 First, it becomes cumbersome and time consuming to handle huge amount of
data through terminals.
 Second, when doing I/O using terminal, the entire data is lost when either
the program is terminated or computer is turned off.
 Therefore, it becomes necessary to store data on a permanent storage (the
disks) and read whenever necessary, without destroying the data.

Types of Files in Python:

 Like C and C++,Python also supports two types of files
1. ASCII Text Files
2. Binary Files
ASCII Text Files
 A text file is a stream of characters that can be sequentially
processed by a computer in forward direction. For this reason a
text file is usually opened for only one kind of operation (reading,
writing, or appending) at any given time.
 Because text files can process characters, they can only read or

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 write data one character at a time. In Python, a text stream is
Besides this, other character conversions may also be done to
satisfy the storage requirements of the operating system.
However, these conversions occur transparently to process a
text file. In a text file, each line contains zero or more characters
and ends with one or more characters.
 Another important thing is that when a text file is used, there are
actually two representations of data- internal or external. For
example, an integer value will be represented as a number that
occupies 2 or 4 bytes of memory internally but externally the
integer value will be represented as a string of characters
representing its decimal or hexadecimal value.
Note: In a text file, each line of data ends with a newline character. Each
file ends with a special character called end-of-file (EOF) Marker.
 treated as a special kind of file.
 Depending on the requirements of the operating system and on the
operation that has to be performed (read/write operation) on the
file, the newline characters may be converted to or from carriage-
return/linefeed combinations.
Binary Files
 A binary file is a file which may contain any type of data,
encoded in binary form for computer storage and processing
purposes. It includes files such as word processing documents,
PDFs, images, spreadsheets, videos, zip files and other executable
programs.
 Like a text file, a binary file is a collection of bytes. A binary file is
also referred to as a character stream with following two
essential differences.
 A binary file does not require any special processing of the data
and each byte of data is transferred to or from the disk
unprocessed.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  Python places no constructs on the file, and it may be read from,
or written to, in any manner the programmer wants.
 While text files can be processed sequentially, binary files,
on the other hand, can be either processed sequentially or
randomly depending on the needs of the application.
Note:Binary files store data in the internal representation
[Link], an integer value will be stored in binary form as 2 byte
[Link] same format is used to store data in memory as well as in
[Link] Text files,Binary files also ends with an EOF Marker.
File Path:
 Files that we use are stored on a storage medium like the hard
disk in such a way that they can be easily retrieved as and
when required.
 Every file is identified by its path that begins from the root node
or the root folder. In Windows, C:\ (also known as C drive) is
the root folder but you can also have a path that starts from
other drives like D:\, E:\, etc. The file path is also known as
pathname.
 In order to access a file on a particular disk we have two paths.
1. Absolute Path
2. Relative Path

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  While an absolute path always contains the root and the
complete directory list to specify the exact location the file.
Example:To access BTech_CS.docx,The
absolute path is C:\Students\Under
Graduate\BTech_CS.docx
 Relative path needs to be combined with another path in order
to access a file. It starts with respect to the current working
directory and therefore lacks the leading slashes.
Example: Suppose you are working on current directory Under
Graduate in order to access BTech_CS.docx,The Relative path is
Under Graduate\BTech_CS.docx

Opening A File:
 Before reading from or writing to a file, you must first open it
using Python‟s built-in open() function. This function creates a
file object, which will be used to invoke methods associated with
it.
 The Syntax of open() is:
fileObj = open(file_name [, access_mode])
Where file_name is a string value that specifies name of the file that
you want to access. access_mode indicates the mode in which the file
has to be opened, i.e., read, write, append, etc.
 Example:Write a Program to print the details of file object

Closing A File
 The close() method is used to close the file object. Once a file
object is closed, you cannot further read from or write into the

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 file associated with the file object.
 While closing the file object the close() flushes any unwritten
information. Although, Python automatically closes a file when
the reference object of a file is reassigned to another file, but as
a good programming habit you should always explicitly use the
close() method to close a file.
 The syntax of close() is
[Link]()
 The close() method frees up any system resources such as file
descriptors, file locks, etc. that are associated with the file.
 Once the file is closed using the close() method, any attempt
to use the file object will result in an error.
Example2: Write a Python program to assess if a file is closed or not..

file = open('[Link]','wb')

print('Name of the file :',[Link])

print('File is closed:',[Link])

print('File is now being closed')

[Link]()

print('File is closed',[Link])

print([Link]())

Output:
Name of the file : [Link]
File is closed: False
File is now being closed
File is closed True

Reading and Writing Files:

Write() and Writelines() method:
Write():

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

The write() method writes a specified text to the file.

Where the specified text will be inserted depends on the file mode and stream position.

"a": The text will be inserted at the current file stream position, default at the end of the file.

"w": The file will be emptied before the text will be inserted at the current file stream position,
default 0.

Example:

writeline() method:
The writelines() method is used to write a list of strings.

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 print('file writing successful')
Output:
file writing successful
append() method:
 Once you have stored some data in a file,you can always open
that file again to write more data or append data to it.
 To append a file, you must open it using „a‟ or „ab‟ mode
depending on whether it is text file or binary file.
 Note that if you open a file with „w‟ or „wb‟ mode and then
start writing data into it, then the existing contents would be
overwritten.
Example:Program to append data to an already existing file
file=open('[Link]','a')
[Link]('\nHave a nice day')
[Link]()
print('Data appended successful')

Output:
Data appended successful

Read() and Readline() Methods:

Read () Methods:
 The read() method is used to read a string from an already opened
[Link] said before, the string can include, alphabets, numbers,
characters or other symbols.

The syntax of read() method is [Link]([count])

 Where In the above syntax, count is an optional parameter
which if passed to the read() method specifies the number of
bytes to be read from the opened file.
 The read() method starts reading from the beginning of the file
and if count is missing or has a negative value then, it reads the
entire contents of the file (i.e., till the end of file).

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

readline() Method:
 It is used to read single line from the file.
This method returns an empty string when end of the file has been
reached.

[Link]

hellocsehope to enjoylearningpython programming

Have a nice day

with keyword:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

  It is good programming habit to use the with keyword when
working with file objects.
 This has the advantage that the file is properly closed after it is used
even if an error occurs during read or write operation or even when
you forget to explicitly close the file.

Splitting Words:
 Python allows you to read line(s) from a file and splits the line
(treated as a string) based on a character. By default, this
character is space but you can even specify any other character
to split words in the string.

File Methods:

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

File Positions:
 With every file, the file management system associates a pointer
often known as file pointer that facilitates the movement across
the file for reading and/ or writing data.
 The file pointer specifies a location from where the current read
or write operation is initiated. Once the read/write operation is
completed, the pointer is automatically updated.
 Python has various methods that tells or sets the position of the file
pointer.
 For example, the tell() method tells the current position within the
file at which the next read or write operation will occur. It is

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 specified as number of bytes from the beginning of the file.
 When you just open a file for reading, the file pointer is
positioned at location 0, which is the beginning of the file.

The syntax for seek() function is seek(offset[, from])

 The offset argument indicates the number of bytes to be moved
and the from argument specifies the reference position from
where the bytes are to be moved.

Renaming and Deleting Files:

 The os module in Python has various methods that can be used to perform file-
processing operations like renaming and deleting files.

 To use the methods defined in the os module, you should first import it in your
program then call any related functions.
 The rename() Method: The rename() method takes two
arguments, the current filename and the new filename.
Its syntax is: [Link](old_file_name, new_file_name)
 The remove() Method: This method can be used to delete

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM

 file(s). The method takes a filename (name of the file to be
deleted) as an argument and deletes that file.
Its syntax is: [Link](file_name)

****************UNIT-5 COMPLETED*************

PADMAVANI ARTS AND SCIENCE COLLEGE FOR WOMEN(AUTONOMOUS), SALEM