In Python, a list is a versatile and fundamental data structure used to store an ordered collection of items. Lists are mutable, which means their elements can be modified after creation. They are denoted by enclosing comma-separated items in square brackets `[ ]`. Lists can contain elements of different data types, including integers, floats, strings, booleans, and even other lists or complex objects.
Key properties of Python lists are:
1. Ordered: Lists in Python are ordered collections, meaning that the elements have a specific order that is maintained unless explicitly changed by the programmer. The order in which elements are added to the list is the order in which they are stored and retrieved, and this order can be altered by operations like sorting or reversing the list.
2. Allows Duplicate Members: Lists in Python can contain duplicate elements. That is, the same value can appear more than once in a list.
Creating Lists:
To create a list in Python, you simply enclose the elements you want to include within square brackets `[]`, separated by commas.
# Examples of creating lists
numbers = [1, 2, 3, 4, 5] # A list of integers
names = ["Alice", "Bob", "Charlie"] # A list of strings
mixed = [1, "Alice", True] # A list with mixed data types
nested = [1, [2, 3], 4] # A list with another list as an element
empty_list = [] # An empty list
Using list() Constructor:
You can create a list in Python using the `list()` constructor. This can be useful when you want to create a list from an existing iterable object such as a string, tuple, set, or another list. Here's how you do it:
# Using list() constructor with a string
str_list = list("Hello")
print(str_list) # Outputs: ['H', 'e', 'l', 'l', 'o']
# Using list() constructor with a tuple
tuple_list = list((1, 2, 3, 4))
print(tuple_list) # Outputs: [1, 2, 3, 4]
Also, you can create an empty list by using the `list()` constructor without any arguments:
empty_list = list()
print(empty_list) # Outputs: []
List Length:
In Python, the `len()` function is used to get the number of items (length) of a list.
Here is an example:
numbers = [1, 2, 3, 4, 5]
length = len(numbers)
print(length) # Outputs: 5
Access Items:
List Indexing:
List indexing in Python allows you to access specific elements within a list based on their position, or index.
In Python, indexing is zero-based, which means the first element is at index `0`, the second element is at index `1`, and so forth. To access an element at a specific index, you place the index inside square brackets `[]` immediately following the name of your list.
Here's an example:
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
print(fruits[0]) # Outputs : "apple"
print(fruits[2]) # Outputs : "cherry"
Python also supports negative indexing, where `-1` refers to the last element, `-2` refers to the second last, and so on. Negative indexing is helpful when you want to access elements from the end of the list without knowing the exact size of the list.
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
print(fruits[-1]) # Outputs : "elderberry"
print(fruits[-3]) # Outputs : "cherry"
Range of Indexes:
In Python, you can access a range of items in a list by using the slicing operator `:`. When you specify two indices separated by a colon, Python returns all the elements starting from the first index up to, but not including, the second index. This is known as slicing.
Here's how you can slice a list:
fruits = ["apple", "banana", "cherry", "date", "elderberry", "fig", "grape"]
# Get elements from index 2 to 4
print(fruits[2:5]) # Outputs: ["cherry", "date", "elderberry"]
In the above example, the slice starts at index `2` (inclusive) and ends at index `5` (exclusive).
If you leave out the first index, Python will start at the beginning of the list. Likewise, if you leave out the second index, Python will go all the way to the end of the list.
# Get all elements from the beginning to index 3 (exclusive)
print(fruits[:3]) # Outputs: ["apple", "banana", "cherry"]
# Get all elements from index 4 to the end of the list
print(fruits[4:]) # Outputs: ["elderberry", "fig", "grape"]
Negative indices can be used in slicing as well. They count from the end of the list towards the beginning.
# Get the last 3 elements of the list
print(fruits[-3:]) # Outputs: ["elderberry", "fig", "grape"]
You can also specify a step value to skip elements within the slice. For instance, `[start:stop:step]` will return every `step` element from `start` to `stop`.
# Get every other element in the list
print(fruits[::2]) # Outputs: ["apple", "cherry", "elderberry", "grape"]
In this example, the `::2` slice starts at the beginning of the list, goes until the end, and selects every second element. The output includes every other fruit from the original list.
Check Items:
To check if an item exists in a list, you can use the `in` keyword. If the item is in the list, `in` will return `True`; otherwise, it returns `False`.
Here's an example:
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
if "banana" in fruits :
print("Yes, 'banana' is in the fruits list") # This will be printed
if "mango" in fruits :
print("Yes, 'mango' is in the fruits list") # This will not be printed
Change Item Value:
In Python, you can modify an existing item in a list by referring to its index. This is because lists in Python are mutable, meaning their contents can be changed after they are created.
Here's how you can change an item:
fruits = ["apple", "banana", "cherry"]
fruits[1] = "blueberry"
print(fruits) # Outputs: ['apple', 'blueberry', 'cherry']
You can also change a range of item values by specifying a slice of indices on the left-hand side of the assignment operator:
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
fruits[1:3] = ["blueberry", "citrus"]
print(fruits) # Outputs: ['apple', 'blueberry', 'citrus', 'date', 'elderberry']
In this example, the slice `fruits[1:3]` represents the second and third items in the list (`"banana"` and `"cherry"`). The slice is replaced by a new list, `["blueberry", "citrus"]`.
It's worth noting that the number of elements inserted need not be equal to the number replaced. Python will automatically adjust the size of the list.
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
fruits[1:3] = ["blueberry", "citrus", "dragonfruit"]
print(fruits) # Outputs: ['apple', 'blueberry', 'citrus', 'dragonfruit', 'date', 'elderberry']
In this case, two elements are replaced by three new elements, so the size of the list increases from 5 to 6.
Add Items:
Adding items to a list in Python can be done in several ways, depending on where and how you want to add the items. The following methods are commonly used:
Append Items:
The `append()` method adds an item to the end of the list.
fruits = ["apple", "banana", "cherry"]
fruits.append("date")
print(fruits) # Outputs: ['apple', 'banana', 'cherry', 'date']
Insert Items:
The `insert()` method can add an item at any position in the list. You provide two arguments: the index where you want to insert the new item and the item itself.
fruits = ["apple", "banana", "cherry"]
fruits.insert(1, "blueberry")
print(fruits) # Outputs: ['apple', 'blueberry', 'banana', 'cherry']
In this example, the string `"blueberry"` is inserted at position `1` in the `fruits` list. All items from that position to the end of the list are shifted to the right.
Extend List:
If you want to add more than one item to the end of a list, you can use the `extend()` method, which takes an iterable (like a list, tuple, or string) as an argument.
fruits = ["apple", "banana", "cherry"]
fruits.extend(["date", "elderberry"])
print(fruits) # Outputs: ['apple', 'banana', 'cherry', 'date', 'elderberry']
In the above example, `extend()` adds the elements of the list `["date", "elderberry"]` to the end of the `fruits` list. The `extend()` method treats the argument as a collection of individual elements, unlike the `append()` method, which would add the list as a single item.
Join Lists:
In Python, you can combine, or concatenate, two or more lists using the `+` operator. This operation joins the lists together into a new list.
Here's an example:
list1 = ["A", "B", "C"]
list2 = [1, 2, 3]
list3 = list1 + list2
print(list3) # Outputs: ['A', 'B', 'C', 1, 2, 3]
In this example, `list3` is a new list that contains all the elements of `list1` followed by all the elements of `list2`.
Copy a List:
In Python, you can copy a list using `copy()` method. This is often necessary because assigning a list to a new variable with `=` does not create a new list, but rather creates a reference to the existing list. Hence, changes made in one list will automatically also be made in second list.
original = [1, 2, 3, 4, 5]
copy1 = original.copy()
print(copy1) # Outputs: [1, 2, 3, 4, 5]
You can also use the `list()` constructor to create a new list from an existing iterable.
original = [1, 2, 3, 4, 5]
copy2 = list(original)
print(copy2) # Outputs: [1, 2, 3, 4, 5]
Sort a List:
Sorting a list is a common operation in Python. The `sort()` method sorts the list in place, meaning that it modifies the original list, and it does not return a new list. The `sorted()` function, on the other hand, returns a new sorted list and leaves the original list unaffected. These methods sorts the list alphanumerically, ascending, by default.
Sorting Ascending Order:
To sort a list in ascending order, you can use the `sort()` method or the `sorted()` function without any additional arguments.
# Using sort() method
fruits = ["Banana", "Apple", "Cherry", "Date"]
fruits.sort()
print(fruits) # Outputs: ['Apple', 'Banana', 'Cherry', 'Date']
# Using sorted() function
numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # Outputs: [1, 1, 3, 4, 5, 9]
Sorting Descending Order:
To sort a list in descending order, pass the argument `reverse=True` to the `sort()` method or the `sorted()` function.
# Using sort() method
fruits = ["Banana", "Apple", "Cherry", "Date"]
fruits.sort(reverse = True)
print(fruits) # Outputs: ['Date', 'Cherry', 'Banana', 'Apple']
# Using sorted() function
numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers = sorted(numbers, reverse = True)
print(sorted_numbers) # Outputs: [9, 5, 4, 3, 1, 1]
Case Insensitive Sort:
When sorting a list of strings, Python's default behavior is to sort in a case-sensitive manner. This means uppercase letters are considered "less than" lowercase letters, causing all strings starting with uppercase letters to appear before strings starting with lowercase letters in a sorted list.
# Using sort() method
fruits = ["banana", "Apple", "Cherry", "date"]
fruits.sort()
print(fruits) # Outputs: ['Apple', 'Cherry', 'banana', 'date']
# Using sorted() function
numbers = [3, 1, 4, 1, 5, 9]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # Outputs: [1, 1, 3, 4, 5, 9]
To customize the sorting behavior, both the `sort()` method and the `sorted()` function accept a `key` argument, which should be a function that takes one argument and returns a value that will be used for sorting purposes.
Key = Function:
The `key` function is applied to each item in the list before it's compared for sorting. The results of this function (not the original list items) are what actually get sorted. The list items themselves are left unchanged and are rearranged according to the order of the key function results. This allows for custom sorting orders.
In the case of a case insensitive sort, you might use `key=str.lower` or `key=str.upper`. The `str.lower` function converts a string to lowercase, and `str.upper` converts a string to uppercase. So `key=str.lower` tells Python to sort the list as if all the strings were in lowercase, even though it doesn't actually change the strings themselves.
Here's an example:
fruits = ["banana", "Apple", "Cherry", "date"]
fruits.sort(key = str.lower)
print(fruits) # Outputs: ['Apple', 'banana', 'Cherry', 'date']
The `key` argument can be used with any function that takes a single argument, not just `str.lower` and `str.upper`. It provides a powerful tool for customizing the behavior of Python's sort functions.
Reverse a List:
The `reverse()` method modifies the original list by reversing the order of elements:
numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers) # Outputs: [5, 4, 3, 2, 1]
Remove List Items:
Removing items from a list in Python can be done in several ways, depending on the specific use case. Here are some common methods to remove items:
1. Using the `remove()` method:
The `remove()` method removes the specified item from the list. If the item appears multiple times in the list, only the first instance of the item will be removed.
fruits = ["apple", "banana", "cherry", "banana"]
fruits.remove("banana")
print(fruits) # Outputs: ['apple', 'cherry', 'banana']
In this example, the first occurrence of `"banana"` is removed from the list.
2. Using the `pop()` method:
The `pop()` method removes the item at the specified position in the list, and returns the removed item. If no index is specified, `pop()` removes and returns the last item in the list.
fruits = ["apple", "banana", "cherry"]
popped = fruits.pop(1)
print(popped) # Outputs: 'banana'
print(fruits) # Outputs : ['apple', 'cherry']
In this example, the item at index `1` is removed and returned. The list now contains the remaining items.
3. Using the `clear()` method:
The `clear()` method removes all items from the list, leaving it empty.
fruits = ["apple", "banana", "cherry"]
fruits.clear()
print(fruits) # Outputs: []
In this example, all items are removed from the list, leaving an empty list.
4. Using the `del` keyword:
The `del` keyword in Python is used to delete objects. In the context of lists, it can be used to delete items at a specific index, a slice of items, or the entire list itself.
# Delete a specific item
fruits = ["apple", "banana", "cherry"]
del fruits[1]
print(fruits) # Outputs: ['apple', 'cherry']
# Delete a slice of items
fruits = ["apple", "banana", "cherry", "date", "elderberry"]
del fruits[1:3]
print(fruits) # Outputs: ['apple', 'date', 'elderberry']
# Delete the entire list
del fruits
