In Python, a list is a built-in data type used to store an ordered, mutable collection of elements. Lists are very flexible and can store any type of object, allowing for a mix of multiple data types, and the number of elements can be increased or decreased at any time.
1. Defining and Creating Lists
Methods to Create Lists:
- • Using square brackets []
- • Using the built-in constructor list()
# Empty list
empty_list = []
empty_list2 = list()
# List with elements
numbers = [1, 2, 3, 4, 5] # Storing integers
fruits = ['apple', 'banana', 'cherry'] # Storing strings
mixed = [1, "hello", 3.14, True] # Mixed types
# Creating a list from other iterable objects
list_from_tuple = list((1, 2, 3)) # Creating a list from a tuple
list_from_string = list("hello") # Each character as a separate element2. Basic Characteristics of Lists
Order
- • Lists are ordered, meaning elements are stored in the order they are inserted, and specific elements can be accessed or manipulated via their index.
my_list = [10, 20, 30, 40]
print(my_list[0]) # Output: 10 (first element)
print(my_list[-1]) # Output: 40 (last element)Mutability
- • Lists are mutable, which means we can modify, add, or remove elements.
my_list = [1, 2, 3]
my_list[1] = 200
print(my_list) # Output: [1, 200, 3]Allowing Duplicates
- • Lists can store duplicate elements.
my_list = [1, 1, 2, 3, 3, 3]
print(my_list) # Output: [1, 1, 2, 3, 3, 3]Can Contain Any Type of Elements
- • Lists can contain any type of object and can include different types of objects.
my_list = [1, "hello", 3.14, [5, 6, 7]]
print(my_list) # Output: [1, 'hello', 3.14, [5, 6, 7]]3. Operations and Methods
Accessing Elements
- • Use indexing (starting from 0) to access elements, either with positive or negative indexing (negative indexing starts from -1, indicating from the end).
my_list = [10, 20, 30, 40, 50]
print(my_list[0]) # Output: 10
print(my_list[-1]) # Output: 50Slicing
- • Retrieve a portion of elements from the list using slicing: list[start:stop:step]
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(my_list[2:6]) # Output: [3, 4, 5, 6]
print(my_list[:4]) # Output: [1, 2, 3, 4]
print(my_list[::2]) # Output: [1, 3, 5, 7, 9]
print(my_list[::-1]) # Output: [9, 8, 7, 6, 5, 4, 3, 2, 1] (reversed list)Adding Elements
Using the append() Method
Adds an element to the end of the list.
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # Output: [1, 2, 3, 4]Using the insert() Method
Inserts an element at a specified position.
my_list = [10, 20, 40]
my_list.insert(2, 30) # Insert 30 at index 2
print(my_list) # Output: [10, 20, 30, 40]Using the extend() Method
Adds all elements from another list or iterable to the end of the current list (similar to list concatenation).
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)
print(list1) # Output: [1, 2, 3, 4, 5, 6]Removing Elements
Using the remove() Method
Removes the first occurrence of the specified value.
my_list = [1, 2, 3, 3, 4]
my_list.remove(3)
print(my_list) # Output: [1, 2, 3, 4]Using the pop() Method
- • Removes the element at the specified index (default is the last one) and returns that element.
my_list = [10, 20, 30, 40]
removed = my_list.pop(1) # Remove element 20 at index 1
print(removed) # Output: 20
print(my_list) # Output: [10, 30, 40]Using the del Statement
- • Deletes elements at a specified index or slice, and can also delete the entire list object.
my_list = [10, 20, 30, 40]
del my_list[2] # Delete element at index 2
print(my_list) # Output: [10, 20, 40]
del my_list[:] # Delete all elements
print(my_list) # Output: []Using the clear() Method
- • Empties the list (the list object still exists, but its content is empty).
my_list = [1, 2, 3]
my_list.clear()
print(my_list) # Output: []Other Common Methods
| Method | Functionality |
| len() | Returns the length of the list |
| index(value) | Finds the index of an element, raises an error if not found |
| count(value) | Counts the occurrences of a specific element in the list |
| sort() | Sorts the list in place (ascending), can specify parameters for custom sorting |
| reverse() | Reverses the order of the list |
| copy() | Returns a shallow copy of the current list |
Example:
my_list = [3, 1, 2, 4]
print(len(my_list)) # Output: 4
print(my_list.index(2)) # Output: 2
print(my_list.count(3)) # Output: 1
my_list.sort() # Sort in place
print(my_list) # Output: [1, 2, 3, 4]
my_list.reverse() # Reverse in place
print(my_list) # Output: [4, 3, 2, 1]
copied_list = my_list.copy() # Shallow copy
print(copied_list) # Output: [4, 3, 2, 1]4. Nested Lists
Lists can nest another list to form a multi-dimensional data structure, such as a two-dimensional list (similar to a matrix).
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# Accessing sublist
print(matrix[0]) # Output: [1, 2, 3]
# Accessing elements in a sublist
print(matrix[1][2]) # Output: 65. Lists and Built-in Functions
Python provides many built-in functions to work with lists:
- • sum(list): Calculates the total of all numeric values in the list
- • max(list): Returns the maximum value in the list
- • min(list): Returns the minimum value in the list
- • sorted(list): Returns a new sorted list (does not modify the original list)
- • any(list): Checks if at least one element is true
- • all(list): Checks if all elements are true
numbers = [1, 2, 3, 4, 5]
print(sum(numbers)) # Output: 15
print(max(numbers)) # Output: 5
print(min(numbers)) # Output: 1
print(sorted(numbers)) # Output: [1, 2, 3, 4, 5]6. List Comprehensions
List comprehensions provide a concise syntax for generating new lists.
# Create a list containing numbers from 0 to 9
squared = [x**2 for x in range(10)]
print(squared) # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# Conditional list comprehension
even = [x for x in range(10) if x % 2 == 0]
print(even) # Output: [0, 2, 4, 6, 8]Python’s lists are a powerful and flexible data structure that supports various operations, making them one of the most commonly used data types in programming.