Data Type 3. – List

The list is a versatile and fundamental data type in Python used to store a collection of items. Lists are ordered, mutable (modifiable), and can contain elements of various data types, including numbers, strings, other lists, and more. Here are the key features and operations associated with the list data type in Python:

List Storage in Python

Let’s delve into how lists are stored in memory:

1. Dynamic Array:
   • Internally, a list is often implemented as a dynamic array. A dynamic array is a contiguous block of memory that can resize itself as needed to accommodate more elements.
   • When you create a list, Python allocates memory to hold a certain number of elements initially. If the list grows beyond its capacity, Python allocates a larger chunk of memory and copies the existing elements to the new memory block.
2. Elements and Indices:
   • Each element in a list is assigned an index based on its position, starting from 0 for the first element.
   • To access an element, Python calculates the memory address based on the index and retrieves the value stored at that address.
3. Memory Efficiency:
   • Lists in Python may use more memory than other data structures for storing the same number of elements due to additional memory required for dynamic resizing.
   • Lists can hold elements of different data types, so additional memory is used for type information and pointers.
4. Memory Allocation:
   • Initially, memory is allocated for a small number of elements when creating a list. As elements are added, the list may need to allocate more memory to accommodate the new elements.
   • Memory allocation strategies vary based on the implementation and version of Python, but they generally aim to optimize performance and memory usage.
5. Appending Elements:
   • When appending an element to the end of a list using the append() method, Python will resize the list if necessary, allocating additional memory for the new element.

Understanding how lists are stored in memory helps you optimize your code for efficient memory usage and better performance.

1. Introduction to Lists

In Python, a list is an ordered collection of objects or elements. Lists are dynamic and can store items of different data types, including numbers, strings, other lists, and more.

Lists are defined by enclosing elements within square brackets [ ].

my_list = [1, 2, 3, 'hello', True]

2. Creating Lists

• Lists are defined by enclosing elements within square brackets [ ].
• Elements within a list are separated by commas.

my_list = [1, 2, 3, 'hello', True]

3. List Operations

a. Indexing & Slicing

• Indexing involves accessing individual elements in a sequence using zero-based indices, e.g., my_list[0] to access the first element.
• Slicing allows you to extract a portion of a sequence by specifying a range of indices, like my_list[1:4] to get elements from index 1 to 3.

# Indexing
my_list = [10, 20, 30, 40, 50]

# Accessing elements using indices
print(my_list[0])  # Output: 10 (first element)
print(my_list[-1])  # Output: 50 (last element)

# Slicing
# Extracting a portion of the list
print(my_list[1:4])  # Output: [20, 30, 40] (elements from index 1 to 3)
print(my_list[:3])    # Output: [10, 20, 30] (elements up to index 2)
print(my_list[2:])    # Output: [30, 40, 50] (elements from index 2 to the end)

10
50
[20, 30, 40]
[10, 20, 30]
[30, 40, 50]

b. Iteration

i. for loop:

my_list = [10, 20, 30, 40, 50]

for item in my_list:
    print(item)

10
20
30
40
50

ii. for loop with range

my_list = [10, 20, 30, 40, 50]

for i in range(len(my_list)):
    print(my_list[i])

10
20
30
40
50

iii. while loop

my_list = [10, 20, 30, 40, 50]
length = len(my_list)
i = 0

while i < length:
    print(my_list[i])
    i += 1

10
20
30
40
50

c. Concatenation(+)

List concatenation is the process of combining two or more lists to create a new list that contains all the elements from the original lists. In Python, you can use the + operator to concatenate lists.

Here’s a code example demonstrating list concatenation:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]

concatenated_list = list1 + list2 + list3
print("Concatenated List:", concatenated_list)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

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

d. Repetition(*)

Using the * operator on a list in Python allows you to create a new list by repeating the elements of the original list a specified number of times.

Here’s an example of using the * operator on a list:

original_list = [1, 2, 3]
repeated_list = original_list * 3  # Repeat the elements 3 times

print("Original List:", original_list)  # Output: [1, 2, 3]
print("Repeated List:", repeated_list)  # Output: [1, 2, 3, 1, 2, 3, 1, 2, 3]

[1,2,3]
[1, 2, 3, 1, 2, 3, 1, 2, 3]

e. Comparison Operators

When using comparison operators on lists in Python, the comparisons are performed element-wise. Here are examples of comparison operators used with lists:

# Equality
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2)  # Output: True

# Inequality
list3 = [1, 2, 4]
print(list1 != list3)  # Output: True

# Less than
print(list1 < list3)  # Output: True

# Greater than
print(list1 > list3)  # Output: False

True
True
True
False

4. List Functions

• len()
  • len() Returns the number of elements in a list.
• max():
  • max() Returns the maximum element in a list.
• min():
  • min() Returns the minimum element in a list.
• sum():
  • sum() Returns the sum of all elements in a list.
• sorted():
  • sorted() Returns a sorted version of the list without modifying the original list.
• reversed():
  • reversed() Returns an iterator that iterates over the elements of the list in reverse order.

# len()
my_list = [10, 20, 30, 40, 50]
print("Length of the list:", len(my_list))  # Output: 5

# max()
print("Maximum element:", max(my_list))  # Output: 50

# min()
print("Minimum element:", min(my_list))  # Output: 10

# sum()
print("Sum of elements:", sum(my_list))  # Output: 150

# sorted()
my_list = [50, 20, 40, 10, 30]
sorted_list = sorted(my_list)
print("Sorted list:", sorted_list)  # Output: [10, 20, 30, 40, 50]

# reversed()
my_list = [10, 20, 30, 40, 50]
reversed_list = list(reversed(my_list))
print("Reversed list:", reversed_list)  # Output: [50, 40, 30, 20, 10]

5
50
10
150
[10, 20, 30, 40, 50]
[50, 40, 30, 20, 10]

5. List Methods

These methods are essential for modifying, organizing, and manipulating lists in Python:

1. append(element):
   • Adds the specified element to the end of the list.
2. extend(iterable):
   • Appends elements from the given iterable (e.g., another list) to the end of the list.
3. insert(index, element):
   • Inserts the specified element at the given index in the list.
4. remove(element):
   • Removes the first occurrence of the specified element from the list.
5. pop(index=-1):
   • Removes and returns the element at the specified index. If no index is provided, removes and returns the last element.
6. clear():
   • Removes all elements from the list.
7. count(element):
   • Returns the number of occurrences of the specified element in the list.
8. index(element):
   • Returns the index of the first occurrence of the specified element in the list.
9. reverse():
   • Reverses the order of elements in the list in place.
10. sort(key=None, reverse=False):
    • Sorts the elements of the list in place. You can specify a key function to customize the sort order, and reverse controls whether to sort in descending order.
11. copy():
    • Returns a shallow copy of the list. Changes to the copy won’t affect the original list.

# Initial list
my_list = [1, 2, 3]

# append()
my_list.append(4)
print("After append:", my_list)  # Output: [1, 2, 3, 4]

# extend()
my_list.extend([5, 6, 7])
print("After extend:", my_list)  # Output: [1, 2, 3, 4, 5, 6, 7]

# insert()
my_list.insert(2, 10)
print("After insert:", my_list)  # Output: [1, 2, 10, 3, 4, 5, 6, 7]

# remove()
my_list.remove(3)
print("After remove:", my_list)  # Output: [1, 2, 10, 4, 5, 6, 7]

# pop()
popped_element = my_list.pop(2)
print("Popped Element:", popped_element)  # Output: 10
print("Updated List:", my_list)  # Output: [1, 2, 4, 5, 6, 7]

# clear()
my_list.clear()
print("After clear:", my_list)  # Output: []

# count()
my_list = [1, 2, 2, 3, 2]
count_of_2 = my_list.count(2)
print("Count of 2:", count_of_2)  # Output: 3

# index()
index_of_3 = my_list.index(3)
print("Index of 3:", index_of_3)  # Output: 3

# reverse()
my_list.reverse()
print("After reverse:", my_list)  # Output: [2, 3, 2, 2, 1]

# sort()
my_list.sort()
print("After sort:", my_list)  # Output: [1, 2, 2, 2, 3]

# copy()
my_list_copy = my_list.copy()
print("Copy of the list:", my_list_copy)

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

6. List Comprehension

List comprehension is a concise way to create lists in Python by applying an expression to each item in an iterable or generating elements based on certain conditions. It follows the syntax [expression for item in iterable if condition]. Here’s a brief explanation and examples:

1. Basic List Comprehension:
   • Create a list of squares for numbers from 1 to 5.

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

[1, 4, 9, 16, 25]

2. List Comprehension with Condition:
   • Create a list of even numbers from 1 to 10.

even_numbers = [x for x in range(1, 11) if x % 2 == 0]
print(even_numbers)  # Output: [2, 4, 6, 8, 10]

[2, 4, 6, 8, 10]

3. Nested List Comprehension:
   • Create a list of tuples containing pairs of numbers.

pairs = [(x, y) for x in [1, 2, 3] for y in [10, 20, 30]]
print(pairs)  # Output: [(1, 10), (1, 20), (1, 30), (2, 10), (2, 20), (2, 30), (3, 10), (3, 20), (3, 30)]

[(1, 10), (1, 20), (1, 30), (2, 10), (2, 20), (2, 30), (3, 10), (3, 20), (3, 30)]

4. Conditional Expression in List Comprehension:
   • Create a list of positive and negative labels for a given set of numbers.

numbers = [10, -5, 20, -15, 30]
labels = ["positive" if x >= 0 else "negative" for x in numbers]
print(labels)  # Output: ['positive', 'negative', 'positive', 'negative', 'positive']

['positive', 'negative', 'positive', 'negative', 'positive']

7. Mutable Nature of Lists

Lists in Python are mutable, meaning that you can modify their elements after creation. Here are some examples illustrating the mutable nature of lists:

1. Modifying Elements:
   • You can change the value of a specific element by accessing its index.
2. Appending and Extending:
   • You can add elements to the list using the append() and extend() methods.
3. Inserting Elements:
   • You can insert elements at specific positions using the insert() method.
4. Removing Elements:
   • You can remove elements using the remove() and pop() methods.

my_list = [1, 2, 3]
my_list[1] = 10  # Modify the second element
print(my_list)  # Output: [1, 10, 3]

my_list = [1, 2, 3]
my_list.append(4)  # Append an element
print(my_list)  # Output: [1, 2, 3, 4]

my_list.extend([5, 6, 7])  # Extend with more elements
print(my_list)  # Output: [1, 2, 3, 4, 5, 6, 7]

my_list = [1, 2, 3]
my_list.insert(1, 10)  # Insert at index 1
print(my_list)  # Output: [1, 10, 2, 3]

my_list = [1, 2, 3]
my_list.remove(2)  # Remove element 2
print(my_list)  # Output: [1, 3]

popped_element = my_list.pop(0)  # Remove and return the first element
print("Popped Element:", popped_element)  # Output: 1
print("Updated List:", my_list)  # Output: [3]

The ability to modify lists in-place makes them mutable, and this feature is fundamental for various programming tasks where you need to change the content of a list during the program’s execution.