NotesNeo

Unit 1: Introduction to Python Programming

Syllabus:
Introduction: Installing Python; basic syntax, interactive shell, editing, saving, and running
a script; data types; variables, assignments; numerical types; arithmetic operators and
expressions; Loops and selection statements, Control statements.
String manipulations: subscript operator, indexing, slicing a string; text files:
reading/writing text and numbers from/to a file; creating and reading a formatted file.

Section 1: Introduction to Python Programming

● Programming refers to the process of writing, designing, and creating sets of instructions
(code) that a computer can execute to perform specific tasks or solve problems. These
instructions are written in a programming language, which serves as a means of
communication between humans and computers.
● Python is a dynamically typed, general purpose programming language that supports an
object-oriented programming approach as well as a functional programming approach.
● Python is a high-level and interpreted programming language known for its simplicity and
readability.

Features of Python
● Python is simple and easy to understand.
● It is Interpreted and platform-independent which makes debugging very easy.
● Python is dynamically typed, so no need to declare a data type explicitly.
● Python is an open-source programming language.
● Python provides very big library support. Some of the popular libraries include NumPy,
Tensorflow, Selenium, OpenCV, etc.
● It is possible to integrate other programming languages within python.

Interpreted
● There are no separate compilation and execution steps like C and C++.
● Directly run the program from the source code.
● Internally, Python converts the source code into an intermediate form called bytecodes
which is then translated into native language of a specific computer to run it.
● Python is often considered a scripting language because of its interpreted nature.

Platform Independent
● Python programs can be developed and executed on multiple operating system platforms.
● Python can be used on Linux, Windows, Macintosh, Solaris and many more.

Free and Open Source; Redistributable

High-level Language
● In Python, no need to take care about low-level details such as managing the memory used
by the program.
Simple
● Closer to English language;Easy to Learn

2
 NotesNeo
● More emphasis on the solution to the problem rather than the syntax

Embeddable
● Python can be used within C/C++ program to give scripting capabilities for the program’s
users.

Robust
● Exceptional handling features
● Memory management techniques in built

Rich Library Support

● The Python Standard Library is very vast.
● Known as the “batteries included” philosophy of Python ;It can help do various things
involving regular expressions, documentation generation, unit testing, threading,
databases, web browsers, CGI, email, XML, HTML, WAV files, cryptography, GUI and many
more.
● Besides the standard library, there are various other high-quality libraries such as the
Python Imaging Library which is an amazingly simple image manipulation library.

What is Python used for

● Python is used in Data Visualization to create plots and graphical representations.
● Python helps in Data Analytics to analyse and understand raw data for insights and trends.
● It is used in AI and Machine Learning to simulate human behaviour and to learn from past
data without hard coding.
● It is used to create web applications.
● It can be used to handle databases.

Installing Python
● You can download Python from the official website ([Link]
and follow the installation instructions for your operating system.

Basic Syntax
● The basic syntax of Python is straightforward and designed to be easy to read and write.
● Here are some key points:
○ Statements are terminated by newline \n character.
○ Python uses indentation (whitespace or tab at the beginning of a line) to indicate the
block of code instead of braces { } or keywords like begin and end.
○ Typically, four spaces are used for each level of indentation.
○ Correct indentation is crucial for code structure.
○ Comments start with the # symbol and continue to the end of the line.
● Example:
print("Hello, World!") # This is a comment

Interactive Shell
● Interactive shell is a user interface that allows user to interact with a programming language
or a software environment in real-time.
● The interactive shell, often referred to as the Python REPL (Read-Evaluate-Print Loop),
allows you to execute Python code line by line interactively.

3
 NotesNeo
● You can access it by simply typing python or python3 in your terminal. It provides a way to
experiment with code, test small snippets, and get immediate feedback.
● The command to clear the Python shell depends on the environment. On most systems,
you can use clear (Linux/Mac) or cls (Windows).
● Example:
>>> print("Hello, interactive shell!")
Hello, interactive shell!

Command Line Arguments

● Command line arguments are values provided to a program when it is executed through the
command line or terminal. These arguments allow users to customize the behavior of a
program at runtime by providing input values from the command line.
● In Python, the sys module provides access to command line arguments through the argv
attribute.
● getopt() is a module for parsing command-line options. It provides a flexible way to process
command-line arguments.
● Python program that demonstrates command-line arguments:

import sys

# Accessing command line arguments

arguments = [Link]

# Displaying command line arguments

print("Command line arguments:", arguments)

Save this script as, for example, [Link]

When you run this script from the command line, it will display the script name along with
any additional arguments you provide. For example:
$ python [Link] arg1 arg2 arg3
Output:
Command line arguments: ['[Link]', 'arg1', 'arg2', 'arg3']

In this example, arg1, arg2, and arg3 are command-line arguments. When the script is
executed, it prints the script name and displays the provided command-line arguments.

Keep in mind that the first element in [Link] is always the script name, and subsequent
elements are the command-line arguments. The script checks if there are additional
arguments and then processes and displays them accordingly.

Editing, Saving and Running a Script

1. Editing a Script:
● Use a text editor or an integrated development environment (IDE) to write Python
scripts.
2. Saving a Script:
● Save the script with a meaningful name and the .py extension, e.g., [Link].
3. Running a Script:
● To run a script, open your command prompt or terminal, navigate to the script's
directory, and use the python command followed by the script's filename:

4
 NotesNeo
python [Link]
This executes the Python script, and any output or errors will be displayed in the terminal.

Section 2: The Concept of Data Types

Data Types
● Data types define the nature of data that can be stored and manipulated in Python.
● Python is dynamically typed, meaning you don't need to declare a data type explicitly; it's
determined at runtime.
○ int: Represents integers (whole numbers), e.g., 5, -10.
○ float: Represents floating-point numbers (decimal numbers), e.g., 3.14, -0.5.
○ str: Represents strings, which are sequences of characters enclosed in single (') or
double (") quotes, e.g., "Hello, Python!".
○ list: Represents ordered collections of items, e.g., [1, 2, 3], ["apple", "banana",
"cherry"].
○ tuple: Represents immutable ordered collections, similar to lists but cannot be
modified, e.g., (1, 2, 3).
○ dict: Represents dictionaries, which store key-value pairs, e.g., {"name": "Deep",
"age": 20}.
○ bool: Represents boolean values True and False.

Mutable Data Types:

● Objects of mutable data types can be modified after creation.
● Changes made to the object will affect the object itself.
● Lists, dictionaries, and sets are examples of mutable data types.

Example with a list:

list = [1, 2, 3]
list[0] = 99
print(list) # Outputs: [99, 2, 3]

Immutable Data Types:

● Objects of immutable data types cannot be modified after creation.
● Any operation that appears to modify the object creates a new object.
● Tuples, strings, and integers, booleans are examples of immutable data types.

Examples with tuple and string:

tuple = (1, 2, 3)
# tuple[0] = 99 # Error since tuples are immutable

string = "hello"
# string[0] = 'H' # Error since strings are immutable

Integer (int)
● Definition: The int data type represents integers, which are whole numbers. Integers can be
positive, negative, or zero.
● Syntax: Assigning an integer value to a variable.
variable_name = integer_value

5
 NotesNeo
● Example:
age = 25
count = -10
population = 7000000000 # 7 billion

Floating-Point Number (float)

● Definition: The float data type represents floating-point numbers, which are real numbers
with a decimal point. Floats can also be expressed in scientific notation.
● Syntax: Assigning a floating-point value to a variable.
variable_name = float_value
● Example:
pi = 3.14159265359
temperature = -10.5
scientific_notation = 2e3 # 2 x 10^3 = 2000.0

String (str)
● Definition: The str data type represents strings, which are sequences of characters. Strings
are enclosed in single (') or double (") quotes.
● Syntax: Assigning a string value to a variable.
variable_name = "string_value"
● Example:
name = "Deepak"
greeting = 'Hello, World!'

List
● Definition: Lists are a data type used to store ordered collections of items. Lists can contain
elements of different data types, and they are mutable, meaning you can modify their
contents.
● Syntax: Creating a list by enclosing items in square brackets [].
variable_name = [item1, item2, item3, ...]
● Example:
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed_list = [1, "apple", 3.14, True]

Tuple
● Definition: Tuples are similar to lists but are immutable, meaning their contents cannot be
changed after creation. Tuples are defined using parentheses ().
● Syntax: Creating a tuple by enclosing items in parentheses.
variable_name = (item1, item2, item3, ...)
● Example:
dimensions = (10, 20, 30)
coordinates = (5.5, 7.0)

Dictionary (dict)
● Definition: Dictionaries are used to store key-value pairs. Each key in a dictionary is unique,
and you can access values using their keys.
● Syntax: Creating a dictionary by using curly braces {} and specifying key-value pairs.
variable_name = {"key1": value1, "key2": value2, ...}

6
 NotesNeo
● Example:
person = {"name": "Alice", "age": 30, "city": "New York"}
student_grades = {"Math": 90, "Science": 85, "History": 88}

Boolean (bool)
● Definition: The bool data type represents boolean values, which can be either True or
False. Booleans are often used in conditional statements and logical operations.
● Syntax: Assigning a boolean value to a variable.
variable_name = True # or False
● Example:
is_adult = True
has_permission = False

Numerical Types
● Python provides two primary numerical types:
○ int (Integer): Represents integers (positive or negative whole numbers).
○ float (Floating-point): Represents floating-point numbers (real numbers with a
decimal point).

Section 3: Variables and Assignments

● Variables are used to store and reference data in a program. They are identifiers that
represent a memory location where a value is stored. Variables must be declared before
they are used.
● Variable is like a container that holds data very similar to how our containers in the kitchen
hold sugar, salt etc. Creating a variable is like creating a placeholder in memory and
assigning it some value.
● Variables may be local or global depending upon the scope.
● Python is dynamically typed, so no need to declare a data type of variable explicitly.
● The assignment operator "=" is used to assign a value to a variable.

x = 5 # Assigning the integer 5 to the variable x

name = "Deepak" # Assigning a string to the variable name
pi = 3.14 # Assigning a floating-point number to the variable pi
numbers = [1, 2, 3, 4, 5] # List variable

Note: In Python, variable names should follow certain rules:

1. Variable names must start with a letter (a-z, A-Z) or an underscore _.
2. The rest of the variable name can contain letters, numbers (0-9), and underscores.
3. Variable names are case-sensitive, so myVar and myvar are different variables.
4. Reserved words (keywords) can’t be used as variable names. For example, we cannot
name a variable if, else, while, etc.
5. Follow a consistent case convention: use snake_case for variable names (e.g.,
my_variable) and CamelCase for class names (e.g., MyClass).

● Identifiers: Names given to entities (variables, functions, etc.).

● Keywords: Reserved words with special meanings (e.g., if, else).
● Statements: Executable units of code (e.g., assignments, loops).
● Expressions: Combinations of values and operators (e.g., x + y).

7
 NotesNeo
● Variables: Containers for storing data.

Identifiers:
Identifiers are names given to entities in Python, such as variables, functions, classes, modules,
etc. They help in uniquely identifying these entities in the code. Here are some rules for identifiers:
● Must begin with a letter (a-z, A-Z) or an underscore (_).
● The subsequent characters can be letters, numbers(0-9), or underscores.
● Case-sensitive (e.g., myVar and MyVar are different identifiers).
● Cannot be a keyword (reserved word).

Examples of identifiers:
variable_name = 42
function_name = "hello"
_class_name = "MyClass"

Keywords:
Keywords are reserved words in Python that have special meanings and cannot be used as
identifiers. They form the core of the language's syntax and structure.
Examples of keywords:
if, else, while, for, break, continue, return, def, class, True, False, None, and,
or, not, import, from, as, with, try, except, finally, global, nonlocal, lambda

Scope of Variables in Python:

● The scope of a variable defines where in the code the variable can be accessed or
modified.
● Python has local scope (inside functions or blocks) and global scope (outside functions or
blocks).
● Local Variables:
○ Defined inside a function or a block.
○ Accessible only within the function or block where they are defined.
● Global Variables:
○ Defined outside any function or block.
○ Accessible throughout the entire program.

x = 10 # Global variable

def func():
y = 5 # Local variable
print(x, y) # Accessible: x (global), y (local) Output: 10 5

func()
# print(y) # Error: y is not defined outside the function

Lifetime of Variables in Python:

● The lifetime of a variable is the duration during which the variable exists in memory.
● Local variables have a shorter lifetime, as they are created when the function or block is
entered and destroyed when it is exited.
● Global variables have a longer lifetime, persisting throughout the program's execution.

8
 NotesNeo

Section 3: Operators and Expressions

The operators are special symbols or keywords that perform operations on operands. Operands
can be variables, constants, or expressions.
There are several types of operators in Python, categorized based on their functionality.

1. Arithmetic Operators:
● Arithmetic Operators are used to perform mathematical operations on numerical data.
● Arithmetic Expressions are combinations of values and arithmetic operators that evaluate
to a single value. These expressions are commonly used in calculations and are essential
in programming.
● Common arithmetic operators include:
○ + (addition)
○ - (subtraction)
○ * (multiplication)
○ / (division)
○ % (modulus, remainder)
○ ** (exponentiation)
○ // (floor division)
● Examples:
#Arithmetic Operations
x = 10
y = 3
result = x + y # Addition: 10 + 3 = 13
result = x - y # Subtraction: 10 - 3 = 7
result = x * y # Multiplication: 10 * 3 = 30
result = x / y # Division: 10 / 3 = 3.333...
result = x % y # Modulus (remainder): 10 % 3 = 1
result = x // y # Floor Division (quotient): 10 // 3 = 3
result = x ** y # Exponentiation: 10^3 = 1000

2. Comparison (Relational) Operators:

● Compare two values and return a Boolean result (True or False).
● Example: == (equal to), != (not equal to), < (less than), > (greater than), <= (less than or
equal to), >= (greater than or equal to).

x = 5
y = 10
print(x == y) # False
print(x != y) # True
print(x < y) # True
print(x > y) # False
print(x <= y) # True
print(x >= y) # False

3. Logical Operators:
● Perform logical operations on Boolean values.
● Example: and (logical AND), or (logical OR), not (logical NOT).

9
 NotesNeo
p = True
q = False
print(p and q) # False
print(p or q) # True
print(not p) # False

4. Assignment Operators:
● Assign values to variables and perform assignments with arithmetic operations.
● Example: = (assignment), += (addition assignment), -= (subtraction assignment), *=
(multiplication assignment), /= (division assignment), %= (modulo assignment), **=
(exponentiation assignment), //= (floor division assignment).

x = 5
x += 2 # equivalent to x = x + 2
print(x) # 7

5. Bitwise Operators:
● Perform bit-level operations on integers.
● Example: & (bitwise AND), | (bitwise OR), ^ (bitwise XOR), ~ (bitwise NOT), << (left shift),
>> (right shift).

a = 5 # binary: 0101
b = 3 # binary: 0011
print(a & b) # 1 (bitwise AND)
print(a | b) # 7 (bitwise OR)
print(a ^ b) # 6 (bitwise XOR)
print(~a) # -6 (bitwise NOT)
print(a << 1) # 10 (left shift by 1)
print(a >> 1) # 2 (right shift by 1)

6. Membership Operators:
● Test whether a value is a member of a sequence (e.g., a string, list, or tuple).
● Example: in (True if value is found in the sequence), not in (True if value is not found in the
sequence).

my_list = [1, 2, 3, 4, 5]
print(3 in my_list) # True
print(5 not in my_list) # False

7. Identity Operators:
● Compare the memory locations of two objects.
● Example: is (True if both variables reference the same object), is not (True if variables
reference different objects).

a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a is b) # False
print(a is not b) # True

10
 NotesNeo
print(a is c) # True

Precedence and Associativity of Operators in Python

The operators with higher precedence are evaluated before operators with lower precedence. The
associativity indicates whether the operators are evaluated from left to right or right to left when
they have the same precedence. [PEABCL]

Precedence Operators Associativity

1 Parentheses () Left to Right

2 Exponentiation ** Right to Left

3 Unary Operators +, -, ~ Right to Left

4 Multiplication, Division, Floor Division, Modulo *, /, //, % Left to Right

5 Addition and Subtraction +, - Left to Right

6 Bitwise Shifts <<, >> Left to Right

7 Bitwise AND & Left to Right

8 Bitwise XOR ^ Left to Right

9 Bitwise OR ` `

10 Comparison Operators <, <=, >, >=, ==, != Left to Right

11 Boolean NOT not Right to Left

12 Boolean AND and Left to Right

13 Boolean OR or Left to Right

Section 4: Comments in the Program

● Comments are non-executable lines in your code that provide explanations, notes, or
documentation.
● Python ignores comments during program execution.
● They are essential for making your code more understandable to yourself and others.

Syntax for Comments

● Single-line comments start with a # symbol.
● Multi-line comments are enclosed in triple-quotes (''' or """).
● Examples:
# This is a single-line comment

'''
This is a
multi-line comment
'''

11
 NotesNeo

Section 5: Understanding Error Messages

Error Messages:
● Python provides error messages to help you identify and fix issues in your code.
● Common types of errors include:
○ SyntaxError: Occurs when there's a syntax mistake in your code.
print("Hello World" # This will raise a SyntaxError
○ NameError: Occurs when you try to use a variable or function that hasn't been
defined.
print(age) # This will raise a NameError
○ TypeError: Occurs when you perform an operation on data of the wrong type, e.g.,
trying to add a string and an integer.
x = 10
y = "5"
result = x + y # This will raise a TypeError

● When you encounter an error, Python will provide an error message that includes a
description of the problem and the line number where it occurred. Understanding these
messages is crucial for debugging your code.

Section 6: Conditional Statements

Conditional statements in Python allow you to execute different blocks of code based on specified
conditions. The primary constructs for conditional statements are:

1. if Statement:
● The if statement is used to execute a block of code if a specified condition is true.
if condition:
# Code to run if the condition is True
● Example:
x = 10
if x > 0:
print("Positive")

2. else Statement:
● The else statement is used to specify a block of code to be executed if the condition
in the initial if statement is false.
if condition:
# Code to run if the condition is True
else:
# Code to run if the condition is False
● Example:
x = -5
if x > 0:
print("Positive")
else:
print("Negative")

12
 NotesNeo
3. elif Statement (else if ladder):
● The elif statement is used for testing multiple conditions after the initial if statement.
It allows you to check additional conditions if the initial condition is false.
if condition1:
# Code to run if condition1 is True
elif condition2:
# Code to run if condition2 is True
# Additional elif clauses
● Example:
x = 0
if x > 0:
print("Positive")
elif x < 0:
print("Negative")
else:
print("Zero")

4. Match case Statement:

● The match statement compares a given value against a set of patterns and
executes the code block associated with the first matching pattern. Each pattern can
include literals, names, sequences, and more.
match value:
case pattern1:
# Code to run if value matches pattern1
case pattern2:
# Code to run if value matches pattern2
case _:
# Code to run if no pattern matches
● Note: The match statement is available in Python 3.10 and later.
● Example: Simple calculator using the match case statement

while True:
# Get user input for operation
operator = input("Enter an operator (+, -, *, /) or 'exit' to quit:
")

# Check if the user wants to exit

if [Link]() == 'exit':
print("Calculator exiting. Goodbye!")
break

# Get user input for numbers

num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Perform calculation using match case statement

match operator:
case '+':
result = num1 + num2
print(f"{num1} + {num2} = {result}")

13
 NotesNeo
case '-':
result = num1 - num2
print(f"{num1} - {num2} = {result}")
case '*':
result = num1 * num2
print(f"{num1} * {num2} = {result}")
case '/':
if num2 != 0:
result = num1 / num2
print(f"{num1} / {num2} = {result}")
else:
print("Cannot divide by zero.")
case _:
print("Invalid operator. Please enter +, -, *, /, or
'exit'.")

Section 7: Iterative Statements

Iterative statements, or loops, allow you to repeat a block of code multiple times. Python supports
two primary types of loops: for and while.

1. for Loop
● The for loop is used for iterating over sequences such as lists, tuples, and strings.
● It executes a block of code for each item in the sequence.
● Syntax:
for item in sequence:
# Code to run for each item in the sequence
● Example:
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
Output:
apple
banana
cherry

● Example:
for i in range(0, 5):
print(i)
Output:
0
1
2
3
4

2. while Loop
● The while loop is used for repeated execution of a block of code as long as a
specified condition is True.
● Syntax:

14
 NotesNeo
while condition:
# Code to run while the condition is True
● Example:
i = 0
while i < 5:
print(i)
i+= 1
Output:
0
1
2
3
4

Section 8: Control Statements

The continue, break, and pass are statements in Python that are collectively named as control
statements. These statements are used to alter the flow of control in a program, providing
additional control structures beyond the basic if, elif, else, for, and while constructs.

1. continue:
● The continue statement is used inside a loop to skip the rest of the code inside the
loop for the current iteration and move on to the next iteration. It is often used when
a specific condition is met, and you want to skip the remaining code for that
particular iteration.
● Example:
for i in range(5):
if i == 3:
continue # Skip the iteration when i is 3
print(i)
​
● In this example, when i is equal to 3, the continue statement is encountered, and the
rest of the loop code for that iteration is skipped. So, the output will be:
0
1
2
4

2. break:
● The break statement is used to exit a loop prematurely, regardless of whether the
loop condition is still true. It is often used when a specific condition is met, and you
want to terminate the loop.
● Example:
for i in range(5):
if i == 3:
break # Exit the loop when i is 3
print(i)

● In this example, when i is equal to 3, the break statement is encountered, and the
loop is terminated. The output will be:

15
 NotesNeo
0
1
2

3. pass:
● The pass statement is a no-operation statement. It is used as a placeholder when
syntactically some code is required, but you don't want to perform any action.
● Example:
for i in range(5):
if i == 3:
pass # Do nothing when i is 3
print(i)

● In this example, when i is equal to 3, the pass statement is encountered, and

nothing happens. The loop continues to the next iteration. The output will be:
0
1
2
3
4

Section 9: Strings

String
A string is a sequence of characters enclosed within single (' '), double (" "), or
triple (''' ''' or """ """) quotes in Python. Strings are immutable, which means their values cannot be
changed once they are assigned.
Example:
name = 'Decoders'
print( name) # Output : Decoders
print("Hello " + name) # Output : Hello Decoders

If our string has multiple lines, we can create them like this:
a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."""
print(a)

Idexing
Strings can be accessed using the subscript operator [], which uses zero-based indexing. Each
character in a string has a unique index, starting from 0 for the first character and going up to n-1
for the last character. For example, my_string[2] accesses the third character in my_string.
Example:
my_string = "Python"
print(my_string[2]) # Output: 't'

str = "Hello Decoders"

print(str[0]) # Output: 'H'

16
 NotesNeo
print(str[1]) # Output: 'e'
print(str[6]) # Output: 'D'
print(str[13]) # Output: 's'
print(str[14]) # Output: IndexError: string index out of range

Negative indexing in Python allows you to access elements from the end of a sequence, including
strings. Negative indices count backward from the end, with -1 representing the last element, -2
representing the second-to-last element, and so on.
Example:
str = "Hello Decoders"
print(str[-1]) # Output: 's'
# Similar to print(str[len(str)-1])
print(str[-2]) # Output: 'r'
print(str[-8]) # Output: 'D'
print(str[-14]) # Output: 'H'
Negative indexes are useful when you need to access elements from the end without knowing the
length of the string.

Slicing a String
String slicing in Python allows to extract a portion (sub-string) of a string by specifying a range of
indices. The basic syntax for string slicing is: string[start:stop:step]
● start: The index from which the slicing begins (inclusive).
● stop: The index at which the slicing stops (exclusive).
● step: The jump or increment between the indices.

Here's a breakdown of each parameter:

● If start is omitted, it defaults to the beginning of the string (0).
● If stop is omitted, it defaults to the end of the string.
● If step is omitted, it defaults to 1.

Example of string slicing :

str = "Hello Decoders"

# Basic slicing
print(str[0:5]) # Hello
print(str[6:14]) # Decoders
print(str[8:13]) # coder

# Omitting start or stop

print(str[:5]) # Hello
print(str[6:]) # Decoders
print(str[:]) # Hello Decoders

# Using step
print(str[::2]) # HloDcdr
print(str[6:14:2]) # Dcdr

# Using negative indices

print(str[-14:-9]) # Hello

17
 NotesNeo
# Similar to print(str[len(str)-14:len(str)-9])
print(str[-8:]) # Decoders
print(str[:-1]) # Hello Decoder
print(str[-6:-1]) # coder
print(str[::-1]) # sredoceD olleH (reverse)
print(str[-1]) # s

# Combining positive and negative indexing

print(str[0:-9]) # Hello
print(str[-8:13]) # Decoder

String Manipulations

Accessing Characters of a String

In Python, string is like an array of characters. We can access parts of string by using its index
which starts from 0.
Square brackets can be used to access elements of the string.
print(name[0])
print(name[1])

Length of a String
We can find the length of a string using len() function.
Example:
fruit = "Mango"
len1 = len(fruit)
print("Mango is a", len1, "letter word.")
Output:
Mango is a 5 letter word.

Looping through the string

We can loop through strings using a for loop like this:
for character in name:
print(character)
Above code prints all the characters in the string name one by one.

Concatenating Two Strings

In Python, you can concatenate (join) two strings using the + operator or by using the join()
method. Here are examples of both approaches:

Using the + Operator:

string1 = "Hello"
string2 = "World"

# Concatenation using the + operator

result = string1 + " " + string2

print(result)
Output:
Hello World

18
 NotesNeo
In this example, the + operator is used to concatenate string1, a space, and string2.

Using the join() Method:

string1 = "Hello"
string2 = "World”

# Concatenation using the join() method

result = " ".join([string1, string2])

print(result)
Output:
Hello World
In this example, the join() method is used to concatenate string1 and string2 with a space in
between.

Printing in the same line

To print in the same line in Python, you can use the end parameter of the print() function. By
default, print() adds a newline character (\n) at the end, but you can change this behavior.

Example:
print("Python")
print("Hello", end=" ")
print("World!")

Output:
Python
Hello World!
In this example, the end=" " parameter ensures that the next print() statement continues on the
same line, separated by a space.

Slicing Example:
pie = "ApplePie"
print(pie[:5]) # Slicing from Start
print(pie[5:]) # Slicing till End
print(pie[2:6]) # Slicing in between
print(pie[-8:]) # Slicing using negative index
print(pie[2:6:2]) # Slicing using step
Output:
Apple
Pie
pleP
ApplePie
pe

Loop through a String:

Strings are basically character arrays and arrays are iterable. Thus we can loop through strings.
Example:
alphabets = "ABCDE"
for i in alphabets:
print(i)

19
 NotesNeo
Output:
A
B
C
D
E

String is Immutable
Strings in Python are immutable, which means that once a string object is created, its contents
cannot be modified or changed. Any operation that appears to modify a string actually creates a
new string object.

my_string = "Hello"
# Attempt to modify the string
my_string[0] = "M" # TypeError: 'str' object does not support item assignment

This error occurs because strings are immutable, and individual characters of a string cannot be
changed directly using indexing and assignment.

String methods
Python provides a set of built-in methods that we can use to alter and modify the strings.

upper() :
The upper() method converts a string to upper case.
Example:
str1 = "AbcDEfghIJ"
print([Link]())
Output:
ABCDEFGHIJ

lower()
The lower() method converts a string to lower case.
Example:
str1 = "AbcDEfghIJ"
print([Link]())
Output:
abcdefghij

strip() :
The strip() method removes any white spaces before and after the string.
Example:
str2 = " Silver Spoon "
print([Link])
Output:
Silver Spoon

rstrip() :
the rstrip() removes any trailing characters. Example:
str3 = "Hello !!!"

20
 NotesNeo
print([Link]("!"))
Output:
Hello

replace() :
The replace() method replaces all occurrences of a string with another string. Example:
str2 = "Silver Spoon"
print([Link]("Sp", "M"))
Output:
Silver Moon

split() :
The split() method splits the given string at the specified instance and returns the separated strings
as list items.
Example:
str2 = "Silver Spoon"
print([Link](" ")) # Splits the string at the whitespace " "
Output:
['Silver', 'Spoon']

join() :
The join() method concatenates the given elements of a list into a single string and returns the
resulting string.
Example:
list1 = ['Silver', 'Spoon']
print(" ".join(list1 )) # Joins the list items with a whitespace " "
Output:
Silver Spoon

There are various other string methods that we can use to modify our strings.

capitalize() :
The capitalize() method turns only the first character of the string to uppercase and the rest other
characters of the string are turned to lowercase. The string has no effect if the first character is
already uppercase.
Example:
str1 = "hello"
print([Link]())
str2 = "hello WorlD"
print([Link]())
Output:
Hello
Hello world

title() :
The title() method capitalizes each letter of the word within the string.
Example:
str1 = "He's name is Dan. Dan is an honest man."
print([Link]())

21
 NotesNeo
Output:
He'S Name Is Dan. Dan Is An Honest Man.

center() :
The center() method aligns the string to the center as per the parameters given by the user.
Example:
str1 = "Welcome to the Console!!!"
print([Link](50))
Output:
Welcome to the Console!!!
We can also provide padding character. It will fill the rest of the fill characters provided by the user.
Example:
str1 = "Welcome to the Console!!!"
print([Link](50, "."))
Output:
............Welcome to the Console!!!.............

count() :
The count() method returns the number of times the given value has occurred within the given
string.
Example:
str2 = "Abracadabra"
print([Link]("a"))
Output:
4

endswith() :
The endswith() method checks if the string ends with a given value. If yes then return True, else
return False.
Example :
str1 = "Welcome to the Console !!!"
print([Link]("!!!"))
Output:
True

We can even also check for a value in-between the string by providing start and end index
positions.
Example:
str1 = "Welcome to the Console !!!"
print([Link]("to", 4, 10))
Output:
True

find() :
The find() method searches for the first occurrence of the given value and returns the index where
it is present. If the given value is absent from the string then return -1.
Example:
str1 = "He's name is Dan. He is an honest man."
print([Link]("is"))
Output:
22
 NotesNeo
10

As we can see, this method is somewhat similar to the index() method. The major difference being
that index() raises an exception if value is absent whereas find() does not.
Example:
str1 = "He's name is Dan. He is an honest man."
print([Link]("Daniel"))
Output:
-1

index() :
The index() method searches for the first occurrence of the given value and returns the index
where it is present. If given value is absent from the string then raise an exception.
Example:
str1 = "He's name is Dan. Dan is an honest man."
print([Link]("Dan"))
Output:
13

As we can see, this method is somewhat similar to the find() method. The major difference being
that index() raises an exception if value is absent whereas find() does not.
Example:
str1 = "He's name is Dan. Dan is an honest man."
print([Link]("Daniel"))
Output:
ValueError: substring not found

isalnum() :
The isalnum() method returns True only if the entire string only consists of A-Z, a-z, 0-9. If any
other characters or punctuations are present, then it returns False.
Example :
str1 = "WelcomeToTheConsole"
print([Link]())
Output:
True

isalpha() :
The isalnum() method returns True only if the entire string only consists of A-Z, a-z. If any other
characters or punctuations or numbers(0-9) are present, then it returns False.
Example :
str1 = "Welcome"
print([Link]())
Output:
True

islower() :
The islower() method returns True if all the characters in the string are lower case, else it returns
False.
Example:
str1 = "hello world"

23
 NotesNeo
print([Link]())
Output:
True

isprintable() :
The isprintable() method returns True if all the values within the given string are printable, if not,
then return False.
Example :
str1 = "We wish you a Merry Christmas"
print([Link]())
Output:
True

isspace() :
The isspace() method returns True only and only if the string contains white spaces, else returns
False.
Example:
str1 = " " #using Spacebar
print([Link]())
str2 = " " #using Tab
print([Link]())
Output:
True
True

istitle() :
The istitile() returns True only if the first letter of each word of the string is capitalized, else it
returns False.
Example:
str1 = "World Health Organization"
print([Link]())
Output:
True

Example:
str2 = "To kill a Mocking bird"
print([Link]())
Output:
False

isupper() :
The isupper() method returns True if all the characters in the string are upper case, else it returns
False.
Example :
str1 = "WORLD HEALTH ORGANIZATION"
print([Link]())
Output:
True

24
 NotesNeo
startswith() :
The endswith() method checks if the string starts with a given value. If yes then return True, else
return False.
Example :
str1 = "Python is a Interpreted Language"
print([Link]("Python"))
Output:
True

swapcase() :
The swapcase() method changes the character casing of the string. Upper case are converted to
lower case and lower case to upper case.
Example:
str1 = "Python is a Interpreted Language"
print([Link]())
Output:
pYTHON IS A iNTERPRETED lANGUAGE

Strings and Number System

Python allows you to convert strings to numbers (integers or floats) and vice versa.

● Converting Strings to Numbers:

○ int(): Converts a string to an integer.
○ float(): Converts a string to a floating-point number.
● Example:
num_str = "42"
num_int = int(num_str)
num_float = float(num_str)

● Converting Numbers to Strings:

○ str(): Converts a number to a string.
● Example:
num_int = 42
num_str = str(num_int)

Binary, Octal, Hexadecimal Numbers:

Binary Numbers
Explanation: Binary numbers are a base-2 numbering system, consisting of only two digits: 0 and
1. In Python, you can represent binary numbers using the 0b prefix.
Example:
binary_num = 0b1010 # Represents the decimal number 10 in binary

Octal Numbers
Explanation: Octal numbers are a base-8 numbering system, using digits 0 through 7. In Python,
you can represent octal numbers using the 0o prefix.
Example:
octal_num = 0o12 # Represents the decimal number 10 in octal

25
 NotesNeo
Hexadecimal Numbers
Explanation: Hexadecimal numbers are a base-16 numbering system, using digits 0-9 and letters
A-F to represent values 10-15. In Python, you can represent hexadecimal numbers using the 0x
prefix.
Example:
hex_num = 0x1A # Represents the decimal number 26 in hexadecimal

Conversion of Numbers
● Python supports the conversion of numbers to and from binary, octal, and hexadecimal
representations using built-in functions like bin(), oct(), and hex().
● Example:
num = 42
bin_num = bin(num) # Binary: '0b101010'
oct_num = oct(num) # Octal: '0o52'
hex_num = hex(num) # Hexadecimal: '0x2a'

Section 10: File Handling

● Text Files : Text files are a common type of file used to store data in a human-readable
format. They are used to store information like text, numbers, and structured data.
● In Python, you can work with text files to read data from them (input) or write data to them
(output). This is essential for tasks like reading configuration files, processing data from
external sources, and storing program output.
● Syntax to Create, Open, and Close a File:
# Create a new file
file = open("[Link]", "w")

# Open an existing file

file = open("[Link]", "r")

# Close the file

[Link]()

Reading from Text Files

● open() Function: To interact with a text file in Python, you typically use the open() function.
This function takes two arguments: the file name and the mode in which you want to open
the file.
● The modes include:
● 'r': Read (default mode) - Opens the file for reading.
● 'w': Write - Opens the file for writing. Creates a new file if it doesn't exist; overwrites
the file if it does.
● 'a': Append - Opens the file for writing. Creates a new file if it doesn't exist; appends
to the file if it does.
● 'x': Exclusive creation - Opens the file for writing but raises an error if the file already
exists.
● 'b': Binary mode - Reads or writes the file in binary mode, indicated by appending 'b'
to the mode (e.g., 'rb' or 'wb').
● To read from a text file, you can use open() and read() methods.

26
 NotesNeo
● Example - Reading from a File:
# Open a file for reading
with open("[Link]", "r") as file:
content = [Link]()
print(content)
In this example, we use the with statement to open the file "[Link]" in read mode ("r"). The
as keyword assigns the file object to the variable file. We then use the .read() method
to read the entire content of the file into the content variable.
The with statement ensures that the file is properly closed after it is no longer needed.

● readline() Method: We can read one line at a time from a text file using the .readline()
method.
Example - Reading One Line at a Time:
with open("[Link]", "r") as file:
line = [Link]()
print(line)
In this example, the with statement is used to open the file in read mode, and .readline()
reads the first line of the file into the line variable. If we call .readline() again, it will read the
next line, and so on until the end of the file is reached.

Writing to Text Files

● open() Function: To write data to a text file, you open the file in write mode ('w'). If the file
already exists, opening it in write mode will overwrite its contents. If the file doesn't exist, a
new file will be created.
● To write to a text file, you can use open() with the "w" mode and write() methods.
Example - Writing to a File:
# Open a file for writing
with open("[Link]", "w") as file:
[Link]("Hello World!")
In this example, we open "[Link]" in write mode and use the .write() method to write the
text "Hello World!" into the file. If the file already had contents, they would be replaced.

● Append Mode: To add new content to an existing file without erasing its previous contents,
you can open the file in append mode ('a').
Example - Appending to a Text File:
with open("[Link]", "a") as file:
[Link]("\nAppending more text.")
In this example, we use the 'a' mode to open the file and add the text "Appending more
text." to the end of the file without deleting the existing content.

Deleting a Text File

The [Link]() function in the os module is used to delete the file.
import os

# Specify the file path

file_path = "[Link]"

27
 NotesNeo
# Check if the file exists before deleting
if [Link](file_path):
[Link](file_path)
print(f"The file '{file_path}' has been deleted.")
else:
print(f"The file '{file_path}' does not exist.")

Creating and Reading a Formatted File (CSV or Tab-Separated):

Creating and reading a formatted file, whether it's in CSV (Comma-Separated Values) or
tab-separated format, is a common task in data processing and storage.

CSV Files
Comma-Separated Values (CSV) files are a common way to store structured data. In a CSV file,
data is separated by commas, and each line represents a record. Python has a built-in csv module
to work with CSV files.
CSV files are widely used for storing structured data, such as spreadsheets, databases, or any
data that can be organized into rows and columns. In CSV files, data is separated by commas, and
each line typically represents a row of data.
● Example - Writing to a CSV File:
import csv
data = [['Name', 'Age'], ['Alice', 25], ['Bob', 30]]
with open('[Link]', 'w', newline='') as file:
writer = [Link](file)
[Link](data)
● Example - Reading to a CSV File:
import csv
with open('[Link]', 'r') as file:
reader = [Link](file)
for row in reader:
print(row)

Tab-Separated Files
If you want to work with tab-separated files, where data is separated by tabs instead of commas,
you can use the same csv module, but specify the delimiter as a tab character ("\t"):

📌For Coding Solutions, refer to this github Repo :

Python/MDU [Link] at main · decodewithdeepak/Python ([Link])

28
 NotesNeo
MDU PYQs
1. What are the key features of the Python ?
2. Explain about the need for learning python programming language and its importance.
3. Is Python scripting language ? Justify it.
4. Name the command to clear the python shell.
5. Explain command line arguments and write a program to demonstrate it.
6. Explain getopt() function in python.
7. What are mutable and immutable datatypes in python ?
8. What are the common built-in datatypes in Python ?
9. How can we declare local and global variable in Python ?
10. Explain the concept of scope and lifetime of variables in Python with example.
11. List the rules to declare a variable in Python. Demonstrate at least three different types of
variable uses with an example program.
12. Explain the Identifiers, Keywords , Statements, Expressions and Variables with examples.
13. Define arithmetic operators and expressions in Python.
14. Describe arithmetic operators, assignment operators, comparison operators, logical
operators and bitwise operators in detail with example.
15. Explain the rules of precedence used by Python to evaluate an expression.
16. Illustrate the different types of control flow statements available in Python with flowcharts.
Explain with suitable examples.
17. Discuss the for and while loop in Python with syntax.
18. Demonstrate the use of break, continue and pass keywords in looping structure.
19. Give a note on each of the below Python constructs :
a. Quotes (single, double and triple)
b. Multiline statements
c. Indentation
20. What is string ? List and explain any two built in string manipulation function supported by
Python.
21. List out all useful string methods which supports in Python.
22. Explain the concept of slicing and indexing with proper examples. What are negative
indexes and why are they need ?
23. Explain string slicing in Python with the example.
24. Explain how to concatenate two strings in Python with examples.
25. How to print in same line in Python explain with suitable example ?
26. Describe why strings are immutable with an example.
27. How to convert the strings to numbers and vice versa in Python ?
28. Write the name of methods used to convert list to string in Python with suitable example.
29. Explain the use of join() and split() string methods with examples.
30. Write the syntax to create, open and close a file. List out different types of modes in python
with suitable example.
31. How to read / write text and numbers from the file in Python?
32. Explain how to delete a file in Python ?

33. Write a Python program to check if a number is positive, negative or 0.

34. Write a program that takes the radius of a sphere (a floating-point number) as input and
then outputs the sphere’s diameter, circumference, surface area and volume.
35. Write a Python program to input information for n number for students as given below:
a. Name
b. Registration Number

29
 NotesNeo
c. Total Marks
36. Write a python program to find the best of two test average marks out of three test marks
accepted from user.
37. Write a program that accepts the lengths of three slides of a triangle as inputs. The program
output should indicate whether or not the triangle is a right triangle.
38. Write a python code to find the factorial of a number.
39. Write a Python program to print all the factorial numbers less than or equal to an input
number n.
40. Write a Python program to check if a three digit number is Armstrong number or not.
41. What is strong number in Python? Consider the number 145 and check whether it is strong
or not.
42. Write a Python code to check whether the given number is strong number. Strong numbers
are numbers whose factorial of digits is equal to the original number.

43. Write a Python program to accept the sentence from the user and display the longest word
of that sentence along with its length.
44. Write a Python code to display the last six characters of the string: “The breakfast is ready”
to the console.
45. Write a Python code to display the last six characters of the string: “waiting for COVID-19
Third Phase” to the console.
46. Assume that the variable data refers to the string “Python rocks!”.
Use a string method to perform the following tasks:
a. Obtain a list of the words in the string.
b. Convert the string to uppercase.
c. Locate the position of the string “rocks”.
d. Replace the exclamation point with a question mark.
47. Write a Python program that reads a text file and changes the file capitalising each
character of the file.
48. Write a Python program to count the frequency of words in a file.

Assignment 1
1. Explain the rules of precedence to evaluate an expression in Python.
2. Explain the built-in string manipulation function methods with examples.
3. Explain the data types in Python using examples?
4. What is the difference between tuples and dictionaries using examples?
5. What are arithmetic operators in Python? (Write code also).
6. Write the algorithm and Python program to check if the number is positive, negative, or
zero.
7. Write a Python program to find the best of two test average marks out of three test marks
accepted by the user.
8. How many types of comments are in Python? Also write the algorithm to find the sum of n
numbers.
9. What are Control statements? Explain with example.
10. Demonstrate the use of break and continue keywords in a looping structure.
11. What is the difference between while and for loop in Python using examples?

30