Unit 3,4 ;16 markQuestions

1. List Operations in python.

In Python, a list is a versatile and commonly used data structure that allows you to store and manipulate a collection of elements. Lists are mutable, meaning that you can modify their contents by adding, removing, or changing elements. Here's an elaborate explanation of various operations you can perform on lists in Python

1. Creating a List:

You can create a list by enclosing elements in square brackets [] and separating them with commas.

my_list = [1, 2, 3, 'four', 5.0]

2. Accessing Elements:

Elements in a list can be accessed using their index. Indexing starts from 0.

first_element = my_list[0]  # Access the first element
third_element = my_list[2]  # Access the third element
last_element = my_list[-1]  # Access the last element

3. Slicing:

You can extract a portion of a list using slicing. The syntax is list[start:stop:step].

sub_list = my_list[1:4]  # Extract elements from index 1 to 3

4. Adding Elements:

    >Append:

        Add an element to the end of the list using the append() method.

my_list.append(6)

    >Insert:

        Insert an element at a specific position using the insert() method.

my_list.insert(2, 'new_element')  # Insert at index 2

5. Removing Elements:

    >Remove:

        Remove the first occurrence of a value using the remove() method.

my_list.remove('four')

    >Pop:

        Remove and return an element at a specific index using the pop() method.

popped_element = my_list.pop(1)  # Remove element at index 1

6. Finding Elements:

    >Index:

        Find the index of the first occurrence of a value using the index() method.

index_of_three = my_list.index(3)

    >Count:

        Count the number of occurrences of a value using the count() method.

count_of_elements = my_list.count(2)

7. Sorting and Reversing:

    >Sort:

        Sort the list in ascending order using the sort() method.

my_list.sort()

    >Reverse:

        Reverse the order of elements in the list using the reverse() method.

my_list.reverse()

8. List Concatenation:

Combine two lists using the + operator.

combined_list = my_list + [7, 8, 9]

9. Length of a List:

Find the number of elements in a list using the len() function.

list_length = len(my_list)

10. Checking Membership:

Check if an element is present in a list using the in keyword.

is_present = 'four' in my_list

These are some of the fundamental operations you can perform on lists in Python. Lists provide a flexible and powerful way to work with collections of data in your programs.

11. List Mutability:

You can modify the value of an element in a list by assigning a new value to its index.

my_list = [1, 2, 3]
my_list[1] = 5          # [1, 5, 3]

---

---

2. Control Flow.

Control flow in Python refers to the order in which statements are executed in a program. It is the sequence in which the code is executed based on conditions and loops. Python provides several control flow structures to enable developers to dictate the flow of their programs. The main control flow structures in Python include:

• Conditional Statements
• Iterations

Conditional Statements:

Conditional Statement: (if)

• Conditional statements in Python are used to make decisions based on certain conditions. The primary constructs for conditional statements is 'if' statement. 
• Here's an explanation:The if statement is used to execute a block of code if a specified condition evaluates to True. The syntax is as follows:

x = 10
if x > 0:
    print("Positive")

In this example, the print("Positive") statement will be executed only if the condition x > 0 is True.

Alternative Statement:(if-else)

• The else statement is used to provide a default block of code to be executed when none of the preceding conditions are True. The syntax is as follows:

x = -5
if x > 0:
    print("Positive")
else:
    print("Non-positive")

• In this example, the print("Non-positive") statement will be executed if the if condition is False.

Chained Statement:(if-elif-else)

• The elif statement is used to check additional conditions after the initial if condition. If the if condition is False, the elif condition is checked. If the elif condition is True, the corresponding block of code is executed. The syntax is as follows:

x = 0
if x > 0:
    print("Positive")
elif x < 0:
    print("Negative")
else:
    print("Zero")

• In this example, the print("Zero") statement will be executed if both the if and elif conditions are False.

Nested Conditionals:

Nested conditionals occur when you have conditional statements (if, elif, else) embedded within other conditional statements. This allows you to create more complex decision-making structures based on multiple conditions. Here's an example of nested conditionals:

x = 10
y = -5

if x > 0:
    print("x is positive")
    
    if y > 0:
        print("y is also positive")
    elif y < 0:
        print("y is negative")
    else:
        print("y is zero")

elif x < 0:
    print("x is negative")

    if y > 0:
        print("y is positive")
    elif y < 0:
        print("y is also negative")
    else:
        print("y is zero")

else:
    print("x is zero")

    if y > 0:
        print("y is positive")
    elif y < 0:
        print("y is negative")
    else:
        print("y is also zero")

• In this example, the outer if, elif, and else statements are used to check the value of x. Depending on whether x is positive, negative, or zero, different blocks of code are executed.
• Within each block, there is a nested set of conditional statements to check the value of y. This creates a more detailed decision-making process. The structure ensures that the appropriate message is printed based on both x and y values.
• Keep in mind that while nested conditionals provide flexibility, too many levels of nesting can make code harder to read and understand. In such cases, you might want to consider refactoring the code or using other programming constructs to simplify the logic.

Iteration:

Control flow plays a crucial role in iteration in Python. Iteration involves repeating a set of instructions or a block of code multiple times. Python provides two main constructs for iteration: for loops and while loops. Both of these loops have control flow structures that determine how the loop iterates.

1. For Loops:

• The for loop is used for iterating over a sequence (such as a list, tuple, string, or range) and executing a block of code for each item in the sequence. The control flow is determined by the number of elements in the sequence.

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

    The control flow here is determined by the number of elements in the fruits list.

2. While Loops:

• The while loop is used for repeated execution of a block of code as long as a specified condition is True. The control flow is determined by the truthiness of the condition.

count = 0
while count < 5:
    print(count)
    count += 1

• The control flow here is determined by the condition count < 5.

In both cases, control flow structures such as break and continue can be used to modify the behavior of the loop:

3. Break Statement:

• The break statement is used to exit the loop prematurely, regardless of whether the loop condition is True or not.

for item in sequence:
    if condition:
        break
    # code to execute for each item

4. Continue Statement:

• The continue statement is used to skip the rest of the code in the current iteration and move to the next iteration of the loop.

for item in sequence:
    if condition:
        continue
    # code to execute for each item

    These control flow structures within iteration provide the flexibility to customize the behavior of loops based on specific conditions, enabling more dynamic and responsive code.

---

---

3. String Built-in Functions in python.

Click here to learn String built-in methods.

---

---

4. Types of Functions and its operations.

---

---