What is List?

Lists are a fundamental data structure in Python used to store collections of items. They are ordered, meaning elements have a defined sequence, and mutable, allowing you to modify their contents after creation.

They are denoted by square brackets [ ], and items within the list are separated by commas.

Examples of lists in Python:

Here are some examples of lists in Python:

Example 1: List of Integers

numbers = [1, 2, 3, 4, 5]
print(numbers)  # Output: [1, 2, 3, 4, 5]

Example 2: List of Strings

fruits = ['apple', 'banana', 'orange', 'kiwi']
print(fruits)  # Output: ['apple', 'banana', 'orange', 'kiwi']

Example 3: List of Mixed Data Types

mixed_list = [1, 'apple', True, 3.14]
print(mixed_list)  # Output: [1, 'apple', True, 3.14]

Example 4: Nested Lists

nested_list = [[1, 2, 3], ['a', 'b', 'c'], [True, False]]
print(nested_list)  # Output: [[1, 2, 3], ['a', 'b', 'c'], [True, False]]

Example 5: List with Repeated Elements

repeated_list = [0] * 5
print(repeated_list)  # Output: [0, 0, 0, 0, 0]

Example 6: List Comprehension

squares = [x**2 for x in range(1, 6)]
print(squares)  # Output: [1, 4, 9, 16, 25]

Example 7: List Slicing

numbers = [1, 2, 3, 4, 5]
subset = numbers[1:4]  # Get elements from index 1 to index 3 (exclusive)
print(subset)  # Output: [2, 3, 4]

Example 8: Modifying Lists

numbers = [1, 2, 3, 4, 5]
numbers[2] = 10 # Change the value at index 2
print(numbers) # Output: [1, 2, 10, 4, 5]

Operations and Operators:-

Modifying, Adding, Removing, Deleting Contents in a List

Modifying the contents of a list in Python is straightforward due to the mutable nature of lists. You can change, add, or remove elements from a list using various methods and operations. Here’s a detailed explanation of how you can modify a list in Python:

1. Modifying/Removing Elements:

You can modify individual elements of a list by directly assigning new values to them using their indices.

numbers = [1, 2, 3, 4, 5]
numbers[2] = 10  # Change the value at index 2
print(numbers)  # Output: [1, 2, 10, 4, 5]

2. Adding Elements:

You can add elements to a list using various methods:

• append(): Adds an element to the end of the list.
• insert(): Inserts an element at a specified position.
• extend(): Extends the list by appending elements from another list.

numbers = [1, 2, 3]
numbers.append(4)  # Add 4 to the end of the list
print(numbers)  # Output: [1, 2, 3, 4]

numbers.insert(1, 5)  # Insert 5 at index 1
print(numbers)  # Output: [1, 5, 2, 3, 4]

more_numbers = [6, 7]
numbers.extend(more_numbers)  # Extend the list with elements from more_numbers
print(numbers)  # Output: [1, 5, 2, 3, 4, 6, 7]

3. Removing Elements:

You can remove elements from a list using various methods:

• remove(): Removes the first occurrence of a specified value.
• pop(): Removes an element at a specified index and returns it.
• del: Removes an element or slice from the list by index or slice.

numbers = [1, 2, 3, 4, 5]
numbers.remove(3)  # Remove the value 3
print(numbers)  # Output: [1, 2, 4, 5]

element = numbers.pop(2)  # Remove and return the element at index 2
print(element)  # Output: 4
print(numbers)  # Output: [1, 2, 5]

del numbers[0]  # Remove the element at index 0
print(numbers)  # Output: [2, 5]

del numbers[1:3]  # Remove elements from index 1 to index 2 (exclusive)
print(numbers)  # Output: [2]

4. Other Modifications:

You can also modify lists using other operations such as sorting, reversing, and clearing.

numbers = [3, 1, 4, 1, 5, 9, 2]

numbers.sort()  # Sort the list in ascending order
print(numbers)  # Output: [1, 1, 2, 3, 4, 5, 9]

numbers.reverse()  # Reverse the list
print(numbers)  # Output: [9, 5, 4, 3, 2, 1, 1]

numbers.clear()  # Clear all elements from the list
print(numbers)  # Output: []

Tuples in Python

Tuples in Python are ordered collections of items, similar to lists. However, unlike lists, tuples are immutable, meaning their elements cannot be changed after creation. Tuples are denoted by parentheses (), and items within the tuple are separated by commas. Tuples are commonly used for representing fixed collections of items, such as coordinates or records.

Strings Vs Lists Vs Tuples

strings and lists are both examples of sequences. Strings are sequences of characters, and are immutable. Lists are sequences of elements of any data type, and are mutable. The third sequence type is the tuple. Tuples are like lists, since they can contain elements of any data type. But unlike lists, tuples are immutable. They’re specified using parentheses instead of square brackets.

here’s a comprehensive explanation of strings, lists, and tuples in Python, highlighting their key differences and use cases:

Strings

• Immutable: Strings are unchangeable once created. You cannot modify the characters within a string.
• Ordered: Characters in a string have a defined sequence and can be accessed using indexing (starting from 0).
• Used for: Representing text data, storing names, URLs, file paths, etc.

Example:

name = "Alice"
message = "Hello, world!"

# Trying to modify a character in a string will result in a TypeError
# name[0] = 'B'  # This will cause a TypeError

Lists

• Mutable: Lists can be modified after creation. You can add, remove, or change elements after the list is created.
• Ordered: Elements in a list have a defined order and are accessed using zero-based indexing.
• Used for: Storing collections of items of any data type, representing sequences that can change.

Example:

fruits = ["apple", "banana", "cherry"]

# Add a new element
fruits.append("kiwi")
print(fruits)  # Output: ["apple", "banana", "cherry", "kiwi"]

# Modify an element
fruits[1] = "mango"
print(fruits)  # Output: ["apple", "mango", "cherry", "kiwi"]

Tuples

• Immutable: Tuples are similar to lists but cannot be modified after creation.
• Ordered: Elements in a tuple have a defined order and are accessed using indexing.
• Used for: Representing fixed data sets, storing data collections that shouldn’t be changed, passing arguments to functions where the data shouldn’t be modified accidentally.

Example:

coordinates = (10, 20)

# Trying to modify an element in a tuple will result in a TypeError
# coordinates[0] = 15  # This will cause a TypeError

# You can create tuples without parentheses for simple cases
person = "Alice", 30, "New York"  # This is also a tuple

Key Differences:

Feature	String	List	Tuple
Mutability	Immutable	Mutable	Immutable
Ordering	Ordered	Ordered	Ordered
Use Cases	Text data, names, URLs, file paths	Collections of items, sequences that can change	Fixed data sets, data that shouldn’t be changed

Choosing the Right Data Structure:

• Use strings when you need to store text data that shouldn’t be modified.
• Use lists when you need to store a collection of items that you might need to change later.
• Use tuples when you need a fixed data set that shouldn’t be modified after creation. Tuples can also be useful when you want to pass arguments to a function and ensure the data isn’t accidentally changed.

---

Here’s an overview of tuples in Python:

1. Creating Tuples:

You can create tuples in Python using parentheses () and separating elements with commas.

Example 1: Tuple of Integers
numbers = (1, 2, 3, 4, 5)

# Example 2: Tuple of Strings
fruits = ('apple', 'banana', 'orange', 'kiwi')

# Example 3: Mixed Data Types
mixed_tuple = (1, 'apple', True, 3.14)

# Example 4: Singleton Tuple (Tuple with one element)
singleton_tuple = (42,)  # Note the comma after the single element

2. Accessing Elements:

You can access individual elements of a tuple using their indices, similar to lists.

numbers = (1, 2, 3, 4, 5)
print(numbers[0])  # Output: 1
print(numbers[-1])  # Output: 5 (negative index counts from the end)

3. Immutable Nature:

Tuples are immutable, meaning you cannot modify their elements after creation. Attempts to modify a tuple will result in an error.

numbers = (1, 2, 3)
numbers[1] = 10  # This will raise a TypeError

4. Tuple Operations:

Although tuples are immutable, you can perform various operations on them, such as concatenation and repetition.

Concatenation
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined_tuple = tuple1 + tuple2  # Output: (1, 2, 3, 4, 5, 6)

# Repetition
repeated_tuple = (0,) * 5  # Output: (0, 0, 0, 0, 0)

5. Tuple Unpacking:

You can unpack a tuple into individual variables.

coordinates = (3, 5)
x, y = coordinates
print(x)  # Output: 3
print(y)  # Output: 5

6. Use Cases:

Tuples are commonly used for:

• Returning multiple values from functions.
• Representing fixed collections of data (e.g., coordinates, RGB colors).
• Immutable keys in dictionaries.
• Namedtuples for creating lightweight data structures.

Iterating over lists and tuples in Python

Iterating over lists and tuples in Python is straightforward using loops or list comprehensions. Both lists and tuples are iterable objects, meaning you can loop through their elements one by one. Here’s how you can iterate over lists and tuples:

1. Using a For Loop:

You can use a for loop to iterate over each element in a list or tuple.

Example with a List:

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

Example with a Tuple:

coordinates = (3, 5)
for coord in coordinates:
    print(coord)

2. Using List Comprehensions:

List comprehensions provide a concise way to iterate over lists and tuples and perform operations on their elements.

Example with a List:

numbers = [1, 2, 3, 4, 5]
squared_numbers = [num ** 2 for num in numbers]
print(squared_numbers)

Example with a Tuple:

coordinates = ((1, 2), (3, 4), (5, 6))
sum_of_coordinates = [sum(coord) for coord in coordinates]
print(sum_of_coordinates)

3. Using Enumerate:

The enumerate() function can be used to iterate over both the indices and elements of a list or tuple simultaneously.

Example with a List:

fruits = ['apple', 'banana', 'orange']
for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

Example with a Tuple:

coordinates = ((1, 2), (3, 4), (5, 6))
for index, coord in enumerate(coordinates):
    print(f"Index {index}: {coord}")

4. Using Zip:

The zip() function allows you to iterate over corresponding elements of multiple lists or tuples simultaneously.

Example with Lists:

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

Example with Tuples:

coordinates = ((1, 2), (3, 4), (5, 6))
for x, y in coordinates:
    print(f"X: {x}, Y: {y}")

List comprehensions with if-else statements

List comprehensions with if-else statements are a concise way to create lists in Python based on certain conditions. Here’s the syntax:

new_list = [expression_if_condition_true if condition else expression_if_condition_false for item in iterable]

Here’s an example to illustrate this:

# Example 1: Creating a list of squares for even numbers and cubes for odd numbers from 1 to 10
numbers = range(1, 11)
result = [x**2 if x % 2 == 0 else x**3 for x in numbers]
print(result)
# Output: [1, 4, 27, 16, 125, 36, 343, 64, 729, 100]

# Example 2: Filtering even numbers from a list and adding 1 to odd numbers
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = [x + 1 if x % 2 != 0 else x for x in numbers if x % 3 == 0]
print(result)
# Output: [4, 7, 10]

# Example 3: Creating a list of strings with lengths and "long" or "short" labels
words = ["apple", "banana", "grape", "watermelon", "orange"]
result = [f"{word}: long" if len(word) > 6 else f"{word}: short" for word in words]
print(result)
# Output: ['apple: short', 'banana: short', 'grape: short', 'watermelon: long', 'orange: short']

In these examples:

• We iterate over each element in the iterable (numbers, words).
• We apply a condition (if x % 2 == 0, if x % 3 == 0, if len(word) > 6).
• If the condition is True, the expression before if is evaluated (x**2, x + 1, f"{word}: long").
• If the condition is False, the expression after else is evaluated (x**3, x, f"{word}: short").
• The resulting values are appended to the list (result).

Can we achieve List comprehension type functionality in case of tuple

We can achieve a similar concept of list comprehension in Python with tuples. However, because tuples are immutable, you won’t be able to modify them in place like you can with lists. You can use tuple comprehension to create new tuples based on existing tuples or other iterables. Here’s how you can do it:

# Tuple comprehension syntax: (expression for item in iterable if condition)

# Example 1: Creating a tuple of squares from a list
numbers = [1, 2, 3, 4, 5]
squares_tuple = tuple(x ** 2 for x in numbers)
print(squares_tuple)  # Output: (1, 4, 9, 16, 25)

# Example 2: Filtering even numbers from a tuple
mixed_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
even_numbers_tuple = tuple(x for x in mixed_tuple if x % 2 == 0)
print(even_numbers_tuple)  # Output: (2, 4, 6, 8, 10)

# Example 3: Creating a tuple of tuples from a list of lists
list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
tuple_of_tuples = tuple(tuple(row) for row in list_of_lists)
print(tuple_of_tuples)  # Output: ((1, 2, 3), (4, 5, 6), (7, 8, 9))

In these examples, we are using tuple comprehension to generate new tuples based on the elements of existing iterables (lists, tuples, etc.). Just like list comprehensions, tuple comprehensions also support optional conditional expressions for filtering elements.

Remember that tuple comprehension creates a new tuple rather than modifying the original one, as tuples are immutable in Python.