List Manipulation Basics

1. What is a List?

In programming, we often need to work with groups of related items. For example, a list of student names, a sequence of measurements from a sensor, or the daily steps you've walked in a week. A list in Python is a data structure that serves exactly this purpose.

A list is an ordered and mutable collection of items. Let's break down these two key properties:

• Ordered: The items in a list have a defined sequence, and that sequence will not change unless you explicitly change it. The first item you put in remains the first, the second remains the second, and so on.
• Mutable: This means you can change the list after it has been created. You can add new items, remove existing items, or change the items that are already in the list.

You can think of a list as a series of numbered boxes, where each box can hold any piece of data (an integer, a string, or even another list).

As you've read, creating a list is straightforward. You use square brackets [], and separate the items with commas.

# An empty list
empty_list = []




# A list of integers
primes = [2, 3, 5, 7, 11]




# A list of strings
shopping_list = ["apples", "bread", "milk"]




# A list with mixed data types
mixed_list = ["hello", 100, True, 3.14]




# A list containing another list (a nested list)
nested_list = [1, 2, ["a", "b"]]

2. Accessing and Slicing Lists

Since lists are ordered, every item has a specific position. This position is called an index. In Python, as in most programming languages, indexing starts from zero. This means the first item is at index 0, the second at index 1, and so on.

You can also use negative indices to count from the end of the list. Index -1 refers to the last item, -2 to the second-to-last, and so forth. This is particularly useful when you want to access the end of a list without knowing its length.

Beyond accessing single items, we often need to extract a portion of a list, or a "sub-list". This operation is called slicing.

Let's summarize the syntax for indexing and slicing.

Indexing: Accessing a single element

my_list[i] returns the element at index i.

letters = ['a', 'b', 'c', 'd', 'e']
print(letters[0])   # Output: 'a'
print(letters[2])   # Output: 'c'
print(letters[-1])  # Output: 'e'

Slicing: Accessing a sub-list

The general syntax is my_list[start:end:step].

• start: The index of the first item to include (inclusive). If omitted, it defaults to 0.
• end: The index of the first item to exclude. If omitted, it defaults to the end of the list.
• step: The interval to skip between items. If omitted, it defaults to 1.

Let's see it in action:

letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']




# Get elements from index 2 up to (but not including) index 5
print(letters[2:5])   # Output: ['c', 'd', 'e']




# Get the first three elements
print(letters[:3])    # Output: ['a', 'b', 'c']




# Get all elements from index 4 to the end
print(letters[4:])    # Output: ['e', 'f', 'g']




# Create a full copy of the list
print(letters[:])     # Output: ['a', 'b', 'c', 'd', 'e', 'f', 'g']




# Get every second element
print(letters[::2])   # Output: ['a', 'c', 'e', 'g']




# Reverse the list
print(letters[::-1])  # Output: ['g', 'f', 'e', 'd', 'c', 'b', 'a']

3. Modifying Lists: Methods

One of the most important properties of lists is their mutability—the ability to be changed after creation. This is a significant difference from strings, which are immutable. With a string, you cannot change a character; you have to create a new string. With a list, you can change, add, or remove elements directly. This flexibility is what makes lists so powerful.

Python provides a set of built-in functions, called methods, that you can use to modify lists. A method is a function that "belongs" to an object. You call it using dot notation, like my_list.method_name().

The following video from "Programming with Mosh" gives a concise tour of the most common methods for adding, removing, and finding items in a list.

Here is a summary of the most important list methods, with some code examples.

Adding Elements

• append(item): Adds an item to the end of the list.
• insert(index, item): Inserts an item at a specific index.

numbers = [1, 2, 3]
numbers.append(4)      # numbers is now [1, 2, 3, 4]
numbers.insert(0, 0)   # numbers is now [0, 1, 2, 3, 4]
print(numbers)

Removing Elements

• remove(item): Removes the first occurrence of a specific value.
• pop(index): Removes the item at a specific index and returns it. If no index is specified, it removes and returns the last item.
• clear(): Removes all items from the list.
• del my_list[index]: The del statement removes an item at a specific index (it's not a method, but a Python statement).

letters = ['a', 'b', 'c', 'b', 'd']
letters.remove('b')      # Removes the first 'b'. letters is now ['a', 'c', 'b', 'd']
print(letters)

last_item = letters.pop()  # Removes and returns 'd'. letters is now ['a', 'c', 'b']
print(last_item)         # Output: d
print(letters)

del letters[0]           # Removes item at index 0. letters is now ['c', 'b']
print(letters)

Other Useful Methods

• index(item): Returns the index of the first occurrence of an item. Raises an error if the item is not found.
• count(item): Returns the number of times an item appears in the list.
• sort(): Sorts the list in place (modifies the original list).
• reverse(): Reverses the order of elements in the list in place.

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

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

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

Conclusion

In this lesson, we've explored Python's list data structure, a versatile tool for managing ordered collections of data. You've learned how to create, access, and manipulate lists, which is a significant step forward in your programming journey.

Here are the key takeaways:

• Lists are ordered and mutable collections of items enclosed in square brackets [].
• You can access individual items using indexing, with my_list[0] for the first item and my_list[-1] for the last.
• You can extract sub-lists using slicing with the [start:end:step] syntax.
• Because lists are mutable, their contents can be changed after creation.
• A rich set of methods like append(), insert(), remove(), and pop() allow for flexible manipulation, while methods like sort() and reverse() help organize the data within the list.

You've now learned how to handle individual variables and ordered collections of them. In our next lesson, we'll introduce another fundamental concept in programming: loops. Loops will allow us to repeat actions, such as performing an operation on every single item in a list, making our programs far more efficient and powerful.