In Python, a
list is a versatile and commonly used data structure that allows you to store
an ordered collection of items. These items can be of any data type (e.g.,
integers, strings, other lists, etc.), and a single list can contain items of
different types. Python lists are mutable, meaning you can modify their
contents after creation.
### Creating
Lists
You can
create a list by placing items inside square brackets `[]`, separated by
commas:
```python
# An empty
list
empty_list =
[]
# A list of
integers
int_list =
[1, 2, 3, 4, 5]
# A list of
strings
str_list =
["apple", "banana", "cherry"]
# A list
with mixed data types
mixed_list =
[1, "hello", 3.14, True]
```
###
Accessing List Items
You can
access individual items in a list using their index. Python uses zero-based
indexing, so the first item is at index `0`, the second at index `1`, and so
on.
```python
fruits =
["apple", "banana", "cherry"]
print(fruits[0]) # Output: apple
print(fruits[1]) # Output: banana
print(fruits[2]) # Output: cherry
```
You can also
use negative indexing to access items from the end of the list:
```python
print(fruits[-1]) # Output: cherry
print(fruits[-2]) # Output: banana
```
### Slicing
Lists
You can
extract a part of a list (a sublist) using slicing. Slicing is done by
specifying a start and end index, and it returns a new list containing the
elements between those indices.
```python
numbers =
[10, 20, 30, 40, 50]
print(numbers[1:4]) # Output: [20, 30, 40]
print(numbers[:3]) # Output: [10, 20, 30]
print(numbers[2:]) # Output: [30, 40, 50]
```
###
Modifying List Items
Since lists
are mutable, you can change the value of an item by assigning a new value to a
specific index:
```python
numbers =
[10, 20, 30, 40, 50]
numbers[1] =
25
print(numbers) # Output: [10, 25, 30, 40, 50]
```
### Adding
Items to a List
You can add
items to a list using methods like `append()`, `insert()`, or `extend()`:
-
**`append()`**: Adds an item to the end of the list.
```python
numbers = [1, 2, 3]
numbers.append(4)
print(numbers) # Output: [1, 2, 3, 4]
```
-
**`insert()`**: Inserts an item at a specified index.
```python
numbers.insert(1, 10)
print(numbers) # Output: [1, 10, 2, 3, 4]
```
-
**`extend()`**: Adds multiple items to the end of the list.
```python
numbers.extend([5, 6, 7])
print(numbers) # Output: [1, 10, 2, 3, 4, 5, 6, 7]
```
### Removing
Items from a List
You can
remove items from a list using methods like `remove()`, `pop()`, or `del`:
-
**`remove()`**: Removes the first occurrence of a specified value.
```python
fruits = ["apple",
"banana", "cherry", "banana"]
fruits.remove("banana")
print(fruits)
# Output: ["apple", "cherry", "banana"]
```
-
**`pop()`**: Removes the item at a specified index (or the last item if no
index is specified) and returns it.
```python
fruits.pop(1)
print(fruits)
# Output: ["apple", "cherry"]
```
- **`del`**:
Deletes an item at a specified index.
```python
del fruits[0]
print(fruits)
# Output: ["cherry"]
```
### List
Methods
Python lists
come with several built-in methods that allow you to perform various
operations:
-
**`sort()`**: Sorts the list in ascending order.
```python
numbers = [4, 1, 3, 2]
numbers.sort()
print(numbers) # Output: [1, 2, 3, 4]
```
-
**`reverse()`**: Reverses the order of the list.
```python
numbers.reverse()
print(numbers) # Output: [4, 3, 2, 1]
```
-
**`index()`**: Returns the index of the first occurrence of a specified value.
```python
print(numbers.index(3)) # Output: 1
```
-
**`count()`**: Returns the number of occurrences of a specified value.
```python
print(numbers.count(2)) # Output: 1
```
-
**`copy()`**: Returns a shallow copy of the list.
```python
new_list = numbers.copy()
print(new_list) # Output: [4, 3, 2, 1]
```
-
**`clear()`**: Removes all items from the list.
```python
numbers.clear()
print(numbers) # Output: []
```
### List
Comprehensions
List
comprehensions provide a concise way to create lists. It can be used to apply
an expression to each item in a sequence or to filter items.
```python
# Create a
list of squares
squares =
[x**2 for x in range(5)]
print(squares) # Output: [0, 1, 4, 9, 16]
# Filter
even numbers
even_numbers
= [x for x in range(10) if x % 2 == 0]
print(even_numbers) # Output: [0, 2, 4, 6, 8]
```
### Nested
Lists
Lists can contain
other lists as elements, creating a nested list.
```python
nested_list
= [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested_list[0]) # Output: [1, 2, 3]
print(nested_list[1][2]) # Output: 6
```
###
Conclusion
Python lists
are a powerful and flexible way to work with ordered collections of data. They
are fundamental to Python programming, offering a wide range of methods and
capabilities for data manipulation. Understanding how to use lists effectively
will significantly enhance your ability to write efficient and clean Python
code.
