Unit No – 1:

1. What are the characteristics of Python that make it a popular programming language?

• Easy to Learn and Use: Python has a simple syntax similar to English, making it easy to learn
and use.
• Interpreted Language: Python is an interpreted language, meaning the code is executed line
by line.
• Dynamically Typed: You don't need to declare the type of variable; Python automatically
assigns the data type.
• Extensive Libraries: Python has a rich set of libraries and frameworks for various
applications.
• Open Source: Python is free to use and distribute, even for commercial purposes.
• Portability: Python code can run on different platforms without requiring changes

2. Why choose Python for beginners compared to other languages?

1. Simple and Readable: Easy-to-understand syntax.

2. Quick Learning: Fast to pick up programming basics.
3. Libraries and Frameworks: Tons of tools for various tasks.
4. Community Support: Lots of tutorials and help available.
5. Versatility: Useful in many fields, from web development to AI.

3. What is the purpose of the ‘print’ statement and ‘input’ statement in Python?

Purpose of print Statement

The print statement is used to display output to the console. It's crucial for debugging, showing re
sults, and interacting with users. For example:
print("Hello, world!")

Purpose of input Statement

The input statement is used to take user input from the console. It pauses the program until the us
er enters data, which can then be processed. For example:
name = input("Enter your name: ")
print(f"Hello, {name}!")

4. How to write single line comment and multiple line comment in Python code? Explain
their importance with the help of examples.

Single Line Comment

To write a singleline comment in Python, you use the # symbol. Anything following the #on that
line will be considered a comment.
Example:
# This is a single-line comment
print("Hello, world!") # This prints a message to the console.
Multi-line Comment
For multi-line comments, you can use triple quotes ''' or """. These can span multiple lines.
Example:
"""
This is a multi-line comment.
It can span multiple lines.
Used to explain code in detail or temporarily disable a block of code.
"""
print("Hello, world!")

Importance of Comments
• Improving Readability: Comments make the code easier to understand for others (or yo
urself in the future).
• Explaining Complex Logic: Helpful to explain why specific solutions or algorithms wer
e used.
• Debugging: Can be used to temporarily disable parts of the code for troubleshooting.

Example:
# Calculate the area of a rectangle
length = 5
breadth = 3

# Formula: area = length * breadth

area = length * breadth # Multiplying length and breadth to get area

print(f"The area of the rectangle is: {area}")

5. What are variables in Python, and how are they declared? Explain with two variable and
calculates their sum, difference.

Variables in Python are essentially storage locations in memory with a name, used to hold a value
. They allow you to store data, which can then be used and manipulated throughout your code.
Declaring Variables
In Python, you simply assign a value to a variable name using the = operator. There's no need to e
xplicitly declare the type.
Example:
a = 10
b=5
sum_ab = a + b
difference_ab = a - b
print(f"Sum of {a} and {b} is: {sum_ab}")
print(f"Difference of {a} and {b} is: {difference_ab}")
6. List the basic data types commonly used in Python with examples.

1. Integer (int)
• Represents whole numbers.
• Example: x = 10
2. Float (float)
• Represents decimal numbers.
• Example: y = 3.14

3. String (str)
• Represents sequences of characters.
• Example: name = "Alice"
4. Boolean (bool)
• Represents True or False.
• Example: is_valid = True
5. List (list)
• Represents an ordered collection of items.
• Example: numbers = [1, 2, 3, 4, 5]
6. Tuple (tuple)
• Represents an ordered, immutable collection of items.
• Example: coordinates = (10.0, 20.0)
7. Dictionary (dict)
• Represents a collection of key-value pairs.
• Example: person = {“name”: “Alice”, “age”: 30}
8. Set (set)
• Represents an unordered collection of unique items.
• Example: unique_numbers = {1, 2, 3, 4, 5}

7. List the various Operators and explain each operator in short with example.

Various Operators in Python

• Arithmetic Operators: Perform basic math operations.
o Addition (+): 5 + 3 = 8
o Subtraction (-): 5 - 3 = 2
o Multiplication ():* 5 * 3 = 15
o Division (/): 10 / 2 = 5.0
o Modulus (%): 5 % 2 = 1
o Exponentiation ():** 2 ** 3 = 8
o Floor Division (//): 7 // 2 = 3
• Comparison Operators: Compare values and return Boolean results.
o Equal to (==): 5 == 5 is True
o Not equal to (!=): 5 != 3 is True
o Greater than (>): 5 > 3 is True
o Less than (<): 3 < 5 is True
o Greater than or equal to (>=): 5 >= 5 is True
o Less than or equal to (<=): 3 <= 5 is True
• Logical Operators: Combine conditional statements.
o and: True and False is False
o or: True or False is True
o not: not True is False
• Bitwise Operators: Operate on binary numbers.
AND (&): 5 & 3 is 1 (binary 0101 & 0011 = 0001)
OR (|): 5 | 3 is 7 (binary 0101 | 0011 = 0111)
XOR (^): 5 ^ 3 is 6 (binary 0101 ^ 0011 = 0110)
NOT (~): ~5 is -6 (binary ~0101 = 1010 in 2's complement)
Left Shift (<<): 5 << 1 is 10 (binary 0101 << 1 = 1010)
Right Shift (>>): 5 >> 1 is 2 (binary 0101 >> 1 = 0010)

8. Explain the use and purpose of arithmetic, comparison, and logical operators in Python.

• Arithmetic Operators: Used for performing mathematical calculations.

o Example: sum = 5 + 3 calculates the sum of 5 and 3.
• Comparison Operators: Used to compare two values.
o Example: result = (5 > 3) evaluates to True.
• Logical Operators: Used to combine multiple conditions.
o Example: result = (5 > 3) and (4 < 2) evaluates to False.

9. List and explain Bitwise Operators with example using truth table.

Let's use 5 (0101) and 3 (0011) as examples:

Operator Result Explanation

5&3 0001 1 (Only 1 in both bits)
`5 3` 0111 7 (1 in either bit)
5^3 0110 6 (1 if bits are different)
~5 1010 -6 (Inverts bits)
5 << 1 1010 10 (Shift left by 1)
5 >> 1 0010 2 (Shift right by 1)

10. Explain the difference between global and local variables.

Global Variables: Declared outside any function and accessible everywhere in the program.
Example:
x = 10 # Global variable

def foo():
print(x) # Can access global variable

foo() # Prints 10

Local Variables: Declared inside a function and accessible only within that function.
Example:
def foo():
x = 20 # Local variable
print(x)

foo() # Prints 20
print(x)
11. Describe the concept of indentation in Python and its role.

Indentation in Python is crucial because it defines the structure of the code blocks. Unlike other la
nguages that use curly braces {}, Python uses indentation to indicate code blocks, such as in loop
s, functions, and conditionals.
Example:
if True:
print("This is indented") # Inside if block
if True:
print("Nested block") # Nested inside the first if block
print("Still inside the outer if")
print("Outside the if block")

Role:
• Readability: Clearly shows the logical structure and flow of the program.
• Syntax Enforcement: Prevents ambiguity in code blocks, making Python code cleaner
and more consistent.

12. Create a program that takes two numbers as input and calculates their sum, difference,
product, and quotient (division).

a = float(input("Enter the value of a: "))

b = float(input("Enter the value of b: "))
sum = a+b
difference = a-b
product = a*b
quotient = a/b
print(f"The sum of the two digits is: {sum}")
print(f"The difference of the two digits is: {difference}")
print(f"The product of the two digits is: {product}")
print(f"The quotient of the two digits is: {quotient}")

13. Write a program to demonstrate the use of Membership and Identity operators.

my_list = [1,2,3,4,5]
print(3 in my_list)
print(6 not in my_list)

a = 10
b = 10
c = a
print(a is b)
print(a is not c)

Output:
True
True
True
False
14. Develop a Python program that calculates the area and perimeter of a rectangle given
its length and width.

l = float(input("Enter the length of rectangle: "))

b = float(input("Enter the breadth of rectangle: "))
area = l*b
perimeter = 2*(l+b)
print(f"The area of rectangle is: {area} and perimeter of rectangle is:
{perimeter}")

15. Create a program to find the largest of three numbers entered by the user using ‘max’
function.

num1 = float(input("Enter the num1: "))

num2 = float(input("Enter the num2: "))
num3 = float(input("Enter the num3: "))
largest = max(num1 ,num2 ,num3)
print(f"The largest number is: {largest}")

16. Develop a Python program to calculate the simple interest for a given principal amount,
time period, and interest rate.

p = int(input("Enter the principal amount:"))

t = float(input("Enter the time period:"))
i = float(input("Enter the intrest rate:"))
s = (p*i*t)/100
print(f"The simple intrest will be: {s}")

17. Create a program to convert Celsius temperature to Fahrenheit (F = (C * 9/5) + 32).

c = float(input("Enter the value of temperature in celsius: "))

f = (c*9/5)+32
print(f"The value of temperature in fahrenheit is: {f}")
Unit No – 2

1. What are data structures in Python? Give example and explain their importance in
programming.

Data structures are ways to organize and store data for efficient access and modification. They are
essential because they influence how data is accessed and manipulated, impacting the efficiency
and performance of algorithms.
Examples:
• List: Stores a collection of items that can be of different types. Supports indexing and slic
ing.
• Dictionary: Stores key-value pairs. Allows for quick lookup by keys.
• Tuple: Immutable sequence of items. Useful for fixed collections of items.
• Set: Unordered collection of unique items. Useful for membership tests and eliminating d
uplicates.

2. Explain Sequence data types / Data Structures in python.

Sequence types are ordered collections of items. They allow operations like indexing, slicing, and iter
ation.
Examples:
• List: numbers = [1, 2, 3, 4, 5]
• Tuple: coordinates = (10.0, 20.0)
• String: message = "Hello, world!"

3. Explain List in details with example.

Lists are mutable, ordered collections of items. They support various methods and operation
s.
Example:
fruits = ["apple", "banana", "cherry"]
print(fruits[1])

fruits.append("date")
print(fruits)

fruits.remove("banana")
print(fruits)

# Slicing
print(fruits[1:3])
4. Differentiate between lists and set in Python.

LISTS SETS
Ordered: The elements in a list maintain Unordered: The elements in a set do
their order. When you add items, they staynot maintain any particular order.
in the order you added them. When you add items, the order may
not be preserved.
Allows Duplicates: Lists can contain No Duplicates: Sets automatically
duplicate elements. remove duplicate elements.
Mutable: Elements can be added, removed, Mutable: Elements can be added or
or changed. removed, but not changed (since
they are unordered, you can't access
elements via an index).
e.g. my_list = [1, 2, 2, 3] e.g. my_set = {4, 2, 3, 1}

5. Differentiate between tuple and set in Python.

TUPLES SET
Ordered: Tuples maintain the order of Unordered: The elements in a set do
elements. not maintain any particular order.
Immutable: Once created, the elements Mutable: Elements can be added or
in a tuple cannot be changed, added, or removed from a set, but the set
removed. itself does not support indexing or
slicing like lists or tuples.
Allows Duplicates: Tuples can contain No Duplicates: Sets automatically
duplicate elements. remove duplicate elements.
e.g. my_tuple = (1, 2, 2, 3) e.g. my_set = [1, 2, 3]

6. Explain Tuple in details with example.

Tuples are ordered collections of elements, similar to lists, but with one key difference:
tuples are immutable. Once a tuple is created, its elements cannot be modified, added, or
removed. This immutability makes tuples useful for data that should not be changed throughout
the program.

Syntax: Tuples are defined by placing elements inside parentheses () separated by commas.
Example:
my_tuple = (1, 2, 3, "apple", "banana")
print(my_tuple[0]) # Outputs: 1
print(my_tuple[3]) # Outputs: apple

single_element_tuple = (5,)
print(type(single_element_tuple))

a, b, c, d, e = my_tuple
print(a, b, c, d, e)

Key Characteristics:
1. Ordered: Tuples maintain the order of their elements.
2. Immutable: Once created, the elements of a tuple cannot be changed.
3. Heterogeneous: Tuples can contain elements of different data types.
4. Supports Indexing and Slicing: You can access elements using indices and slice tuples.
Use Cases:
• Tuples are often used to store multiple items in a single variable, particularly when you have
related data that shouldn't change.
• They are used for keys in dictionaries (because keys must be immutable).
• Useful in function returns when you want to return multiple values.

7. Explain String in details with example.

String in Python
Strings in Python are sequences of characters enclosed within single quotes (' ') or double quotes
(" "). They are used to represent text data and are immutable, meaning once a string is created, It
cannot be changed. However, you can create new strings based on operations performed on
existing ones.
Basic Example:

single_quoted_string = 'Hello, world!'

double_quoted_string = "Hello, world!"

print(single_quoted_string)
print(double_quoted_string)

8. Explain Dictionary in details with example.

Dictionaries in Python are powerful data structures that store data in key-
value pairs. They are mutable, meaning you can change their contents, and they allow for fast retriev
al of data based on keys. Dictionaries are often used when you need a logical association between a k
ey:value pair of data.
Syntax: Dictionaries are created using curly braces {}, with key-value pairs separated by colons :
Example:

# Creating a dictionary
person = {
"name": "Alice",
"age": 30,
"city": "New York"
}

# Accessing values by keys

print(person["name"]) # Outputs: Alice
print(person["age"]) # Outputs: 30

# Adding a new key-value pair

person["profession"] = "Engineer"
print(person) # Outputs: {'name': 'Alice', 'age': 30, 'city': 'New York', 'profession': 'Engineer'}

# Modifying an existing key-value pair

person["age"] = 31
print(person["age"]) # Outputs: 31

# Removing a key-value pair

del person["city"]
print(person) # Outputs: {'name': 'Alice', 'age': 31, 'profession': 'Engineer'}

Unordered: While dictionaries in Python 3.7+ maintain insertion order, they are conceptually unorde
red collections.
Mutable: The contents of a dictionary can be changed.
Unique Keys: Each key must be unique, but values can be duplicated.
Dynamic: Can grow and shrink as needed.

Nested Dictionary
You can also nest dictionaries within dictionaries, which is useful for representing more complex data
structures.
students = {
"Alice": {"age": 20, "grade": "A"},
"Bob": {"age": 22, "grade": "B"},
"Charlie": {"age": 23, "grade": "C"}
}

# Accessing nested values

print(students["Alice"]["grade"]) # Outputs: A
9. Describe the inbuilt functions and operations you can perform on lists.

Basic Operations
• Creation:
my_list = [1, 2, 3, 4, 5]
• Accessing Elements:
first_element = my_list[0] # Outputs: 1
• Updating Elements:

my_list[1] = 10
print(my_list) # Outputs: [1, 10, 3, 4, 5]

Inbuilt Functions
• len(): Returns the length of the list.

length = len(my_list)
print(length) # Outputs: 5

• append(): Adds an element to the end of the list.

my_list.append(6)
print(my_list) # Outputs: [1, 10, 3, 4, 5, 6]

• extend(): Adds all elements of an iterable to the end of the list.

my_list.extend([7, 8])
print(my_list) # Outputs: [1, 10, 3, 4, 5, 6, 7, 8]

• insert(): Inserts an element at a specified position.

my_list.insert(2, 15)
print(my_list) # Outputs: [1, 10, 15, 3, 4, 5, 6, 7, 8]
• remove(): Removes the first occurrence of an element.

my_list.remove(10)
print(my_list) # Outputs: [1, 15, 3, 4, 5, 6, 7, 8]

• pop(): Removes and returns the element at a specified position (or the last element if no pos
ition is specified).

last_element = my_list.pop()
print(last_element) # Outputs: 8
print(my_list) # Outputs: [1, 15, 3, 4, 5, 6, 7]

• index(): Returns the index of the first occurrence of an element.

index = my_list.index(15)
print(index) # Outputs: 1
• count(): Returns the number of occurrences of an element.

count = my_list.count(3)
print(count) # Outputs: 1

• sort(): Sorts the list in place.

python
Copy
my_list.sort()
print(my_list) # Outputs: [1, 3, 4, 5, 6, 7, 15]

• reverse(): Reverses the elements of the list in place.

python
Copy
my_list.reverse()
print(my_list) # Outputs: [15, 7, 6, 5, 4, 3, 1]

Slicing and Concatenation

• Slicing: Extracts a part of the list.

slice_of_list = my_list[1:4]
print(slice_of_list) # Outputs: [7, 6, 5]

• Concatenation: Combines lists.

another_list = [9, 10]

combined_list = my_list + another_list
print(combined_list) # Outputs: [15, 7, 6, 5, 4, 3, 1, 9,10]

• Repetition: Repeats the elements of the list.

repeated_list = my_list * 2
print(repeated_list) # Outputs: [15, 7, 6, 5, 4, 3, 1, 15, 7, 6, 5, 4, 3, 1]

Copying

• copy(): Returns a shallow copy of the list.

copied_list = my_list.copy()
print(copied_list) # Outputs: [15, 7, 6, 5, 4, 3, 1]

10. Explain how dictionaries work in Python? Explain nested dictionary with example.

Dictionaries in Python are collections of key-

value pairs. Each key is unique and is used to access its corresponding value. Here's a rundown of ho
w they work:
1. Key-Value Pairs: Each element in a dictionary is a pair of a key and its value.
2. Mutable: You can change the dictionary by adding, removing, or updating key-value pairs.
3. Unordered: Prior to Python 3.7, dictionaries did not maintain order, but from Python 3.7 on
ward, they maintain the insertion order.
4. Dynamic: Dictionaries can grow and shrink as needed.
Example:

# Creating a dictionary
person = {
"name": "Alice",
"age": 30,
"city": "New York"
}

# Accessing values
print(person["name"]) # Outputs: Alice
print(person.get("age")) # Outputs: 30

# Adding a new key-value pair

person["profession"] = "Engineer"
print(person) # Outputs: {'name': 'Alice', 'age': 30, 'city': 'New York', 'profession': 'Engineer'}

# Updating an existing value

person["age"] = 31
print(person["age"]) # Outputs: 31

# Removing a key-value pair

del person["city"]
print(person) # Outputs: {'name': 'Alice', 'age': 31, 'profession': 'Engineer'}

Nested Dictionary
A nested dictionary is a dictionary within another dictionary. This allows for more complex data struc
tures, representing hierarchical data.
Example:

# Creating a nested dictionary

students = {
"Alice": {"age": 20, "grade": "A"},
"Bob": {"age": 21, "grade": "B"},
"Charlie": {"age": 23, "grade": "C"}
}

# Accessing values in a nested dictionary

print(students["Alice"]["grade"]) # Outputs: A
print(students["Bob"]["age"]) # Outputs: 21

# Updating a nested value

students["Alice"]["grade"] = "A+"
print(students["Alice"]["grade"]) # Outputs: A+

# Adding a new nested dictionary

students["David"] = {"age": 22, "grade": "B"}
print(students)
# Outputs: {'Alice': {'age': 20, 'grade': 'A+'}, 'Bob': {'age': 21, 'grade': 'B'}, 'Charlie': {'age': 23, 'grade':
'C'}, 'David': {'age': 22, 'grade': 'B'}}
11. What are sets in Python? How do they differ from lists?

Refer from question no. 4.

12. Explain Strings in python.

Refer from question no. 7.

13. Explain string Indexing and slicing in Python.

String Indexing
Indexing allows you to access individual characters in a string using their position, starting from 0 for
the first character.
Example:
greeting = "Hello"
print(greeting[0]) # Outputs: H
print(greeting[1]) # Outputs: e
print(greeting[-1]) # Outputs: o (last character)

String Slicing

Slicing lets you extract a substring from a string by specifying a range of indices. The syntax for sli
cing is [start:stop:step].
• start: The beginning index of the slice.
• stop: The ending index (not included in the slice).
• step: The step size (optional, defaults to 1).
Examples:
greeting = "Hello, world!"

# Extracting 'Hello'
print(greeting[0:5]) # Outputs: Hello

# Extracting 'world'
print(greeting[7:12]) # Outputs: world

# Extracting the whole string

print(greeting[:]) # Outputs: Hello, world!

# Extracting with a step

print(greeting[::2]) # Outputs: Hlo ol!

# Extracting 'world' using negative indexing

print(greeting[-6:-1]) # Outputs: world
• Omitting start: The slice starts from the beginning of the string.

print(greeting[:5]) # Outputs: Hello

• Omitting stop: The slice goes to the end of the string.

print(greeting[7:]) # Outputs: world!

• Negative step: To reverse a string.

print(greeting[::-1]) # Outputs: !dlrow ,olleH

14. Define following :

i. lower( ) ii. upper( ) iii. capitalize( ) iv. len( )

i. lower()

The lower() method converts all the characters in a string to lowercase.

Example:
text = "HELLO, WORLD!"
print(text.lower()) # Outputs: hello, world!

ii. upper()
The upper() method converts all the characters in a string to uppercase.
Example:
text = "hello, world!"
print(text.upper()) # Outputs: HELLO, WORLD!

iii. capitalize()
The capitalize() method converts the first character of a string to uppercase and all other characters t
o lowercase.
Example:
text = "hello, WORLD!"
print(text.capitalize()) # Outputs: Hello, world!

iv. len()
The len() function returns the length of an object (string, list, tuple, etc.).
Example:
text = "Hello, world!"
print(len(text)) # Outputs: 13
15. Write a program to read a string from user and then perform following operation on it and
display result.
i. Find length
ii. Convert to Upper case
iii. Convert to Lower case
iv. Convert to Title

# Read a string from the user

user_string = input("Enter a string: ")

# i. Find length
length_of_string = len(user_string)
print(f"Length of the string: {length_of_string}")

# ii. Convert to Upper case

upper_case_string = user_string.upper()
print(f"String in upper case: {upper_case_string}")

# iii. Convert to Lower case

lower_case_string = user_string.lower()
print(f"String in lower case: {lower_case_string}")

# iv. Convert to Title

title_case_string = user_string.title()
print(f"String in title case: {title_case_string}")

16. Write the output:

Str1 = “I am a Student
i. Str1[4]
ii. Str1[-1]
iii. Str1[-1:0:-1]
iv. Str1[1:9]
v. print(max(Str1))
vi. print(len(Str1))
vii. print(min(Str1))

i. Str1[4]:
Str1[4] # Outputs: 'm'

ii. Str1[-1]
Str1[-1] # Outputs: 't'

iii. Str1[-1:0:-1]:
Str1[-1:0:-1] # Outputs: 'tnedutS a ma '

iv. Str1[1:9]:
Str1[1:9] # Outputs: ' am a St'
v. print(max(Str1)):
print(max(Str1)) # Outputs: 'u' (since 'u' has the highest ASCII value among the characters)

vi. print(len(Str1)):
print(len(Str1)) # Outputs: 14

vii. print(min(Str1)):

print(min(Str1)) # Outputs: ' ' (space has the lowest ASCII value)

17. What do you mean by String.format() ? Explain with example.

The String.format() method in Python is used to format strings in a more readable and manageable
way. It allows you to inject variables into your string and create dynamic text.

Example:

name = "Alice"

age = 30

city = "New York"

formatted_string = "My name is {}. I am {} years old and I live in {}.".format(name, age, city)

print(formatted_string)

Output:

My name is Alice. I am 30 years old and I live in New York.

Explanation

• Placeholders: {} are placeholders in the string where values will be injected.

• Order Matters: The values provided to format() are inserted in the order of the placeholders.

• Named Placeholders: You can also use named placeholders for clarity.

Named Placeholders Example:

formatted_string = "My name is {name}. I am {age} years old and I live in {city}.".format(name=name,
age=age, city=city)

print(formatted_string)
18. Create a program that removes duplicate elements from a given list using sets.

# Sample list with duplicates

original_list = [1, 2, 2, 3, 4, 4, 5, 6, 6, 7]

# Convert the list to a set to remove duplicates

unique_set = set(original_list)

# Convert the set back to a list

unique_list = list(unique_set)

print(f"Original list: {original_list}")

print(f"List with duplicates removed: {unique_list}")

19. Write a function that takes a list of numbers and returns the largest number.

def find_largest_number(numbers):
if not numbers:
return None # Handle case for empty list

largest_number = numbers[0]
for number in numbers:
if number > largest_number:
largest_number = number
return largest_number

# Example usage
numbers = [3, 5, 7, 2, 8, -1, 4]
largest = find_largest_number(numbers)
print(f"The largest number in the list is: {largest}")

Output:
The largest number in the list is: 8

--BEST OF LUCK--