List Manipulation Fundamentals

What is a Python List?

At its core, a Python list is a container that holds an ordered collection of items. Think of it as a dynamic array. Here are its key characteristics:

• Ordered: Items are stored in a specific sequence, and that order is maintained.
• Mutable: You can change the list after it's created—add, remove, or change items. This is a crucial feature.
• Heterogeneous: A single list can contain items of different data types (e.g., integers, strings, and even other lists).

Creating Lists

You can create a list in a few common ways. The most direct is using a list literal, which is simply a comma-separated series of values inside square brackets [].

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




# A list of mission objectives (strings)
objectives = ["Establish orbit", "Deploy satellite", "Return to base"]




# A mixed-type list
mixed_data = ["sensor_A", 12.5, True]




# An empty list, to be filled later
sensor_readings = []

You can also use the list() constructor to create a list from another iterable object, such as a string or a range object from our last lesson.

To see these creation methods demonstrated, please watch the first part of the following video.

For a more detailed textual reference on the characteristics of lists, you can review the introductory section of the article "Python's list Data Type" from Real Python.

Accessing and Modifying List Items

Once you have a list, you'll need to work with its contents. Python provides powerful mechanisms for accessing and changing items based on their position.

Indexing: Accessing a Single Item

Each item in a list has an index, which is its position in the sequence. Python uses zero-based indexing, meaning the first item is at index 0, the second at index 1, and so on.

You can access an item by putting its index in square brackets after the list variable.

objectives = ["Establish orbit", "Deploy satellite", "Return to base"]

first_objective = objectives[0]  # Accesses "Establish orbit"
last_objective = objectives[2]   # Accesses "Return to base"




# Using negative indexing is often more convenient for accessing items near the end
last_objective_again = objectives[-1] # Accesses "Return to base"
second_to_last = objectives[-2]      # Accesses "Deploy satellite"

Because lists are mutable, you can also use indexing to change an item at a specific position.

objectives[2] = "Perform re-entry"
print(objectives)  # Output: ['Establish orbit', 'Deploy satellite', 'Perform re-entry']

The next segment of the video demonstrates both accessing and modifying elements using indexing.

Slicing: Accessing a Sub-List

What if you need a part of a list, not just a single item? For this, you use slicing. The syntax is list[start:stop:step].

• start: The index of the first item to include (inclusive, defaults to 0).
• stop: The index of the first item not to include (exclusive, defaults to the end).
• step: The amount to jump between items (defaults to 1).

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




# Get the first three numbers
first_three = numbers[0:3]  # or simply numbers[:3]



# Result: [0, 1, 2]




# Get numbers from index 5 to the end
from_five_on = numbers[5:]



# Result: [5, 6, 7, 8, 9]




# Get every other number
even_numbers = numbers[::2]



# Result: [0, 2, 4, 6, 8]




# Get a section from the middle
middle_part = numbers[3:7]



# Result: [3, 4, 5, 6]

This next video segment will walk you through these slicing operations.

Growing and Shrinking Lists

Lists are dynamic, meaning their size can change. Python provides several methods to add and remove items.

• list.append(item): Adds a single item to the end of the list. This is the most common way to add items.
• list.insert(index, item): Adds an item at a specific index, shifting existing items to the right.
• list.pop(index): Removes the item at the given index and returns it. If no index is specified, it removes and returns the last item.
• list.remove(value): Searches for the first occurrence of value and removes it.
• del list[index]: The del statement removes an item at a specific index.

Let's watch a demonstration of these essential methods.

A Critical Concept: References vs. Copies

This is one of the most important—and often misunderstood—concepts for new Python programmers. When you assign a list to a new variable, you are not creating a new list. You are creating another reference (or name) pointing to the same list in memory.

original_list = [1, 2, 3]
reference_list = original_list  # This does NOT create a copy

reference_list.append(4)

print(original_list)  # Output will be [1, 2, 3, 4]!

Changing reference_list also changed original_list because they both point to the same object. To create a true, independent copy, you must use slicing [:] or the .copy() method.

original_list = [1, 2, 3]
copied_list = original_list[:] # This creates a shallow copy

copied_list.append(4)

print(original_list) # Output: [1, 2, 3]
print(copied_list)   # Output: [1, 2, 3, 4]

Understanding this distinction is crucial for avoiding unexpected bugs. The following video from Khan Academy provides an excellent visual explanation of this concept.

Your Turn: Mission Control Pre-Launch Sequence

Now it's time to apply what you've learned. Imagine you're programming a simple mission control system. You will use a list to manage the sequence of pre-launch checks.

Instructions (10 minutes):

1. Create a list named pre_launch_checks containing the following initial steps: "System power on", "Propellant loading", "Engine ignition".
2. Print the initial list.
3. A new check, "Communications check", needs to be added before "Propellant loading". Use the .insert() method.
4. The "Engine ignition" step is premature. Replace it with "Final orbit calculation". Use indexing to modify the element.
5. A final check, "Liftoff", needs to be added to the very end of the sequence. Use the .append() method.
6. Print the final, updated list of checks.
7. Now, create a backup. Use slicing to create a new list called critical_checks that contains only the first three checks from the final pre_launch_checks list.
8. To prove your backup is a true copy, append the string "Backup confirmed" to your critical_checks list.
9. Finally, print both the pre_launch_checks list and the critical_checks list to confirm that only the backup list was modified.

Example Code Structure:

# 1. Create the initial list
pre_launch_checks = ["System power on", "Propellant loading", "Engine ignition"]
print(f"Initial checks: {pre_launch_checks}")




# 3. Insert the communications check
# Your code here...




# 4. Modify the last element
# Your code here...




# 5. Append the liftoff check
# Your code here...




# 6. Print the final list
print(f"Final checks: {pre_launch_checks}")




# 7. Create the backup
# Your code here...




# 8. Modify the backup
# Your code here...




# 9. Print both lists to verify
print(f"Final main sequence: {pre_launch_checks}")
print(f"Critical backup sequence: {critical_checks}")

Take your time to work through this. It combines all the key skills from this lesson into a practical scenario.

Conclusion

Excellent work today. You have learned how to use Python's lists, one of the most versatile tools in your programming toolkit. You can now store, access, and manipulate ordered collections of data, a skill that is absolutely essential for any non-trivial program, especially in the field of AI where data is king.

Key Takeaways:

• Lists are ordered, mutable collections of items, created with [].
• Indexing (list[i]) allows you to access or modify a single item by its position.
• Slicing (list[start:stop]) creates a new sub-list from an existing one.
• Methods like .append(), .insert(), and .pop() allow you to dynamically change the size and content of a list.
• Assignment (=) creates a reference, not a copy. To create an independent copy of a list, you must use slicing (new_list = old_list[:]).

Preview of the Next Lesson:
Lists are fantastic for ordered sequences, but what if you need to store data not by its position, but by a unique identifier? For example, storing a person's information using keys like "name", "age", and "occupation". In our next lesson, we will explore dictionaries, a data structure that allows you to store and retrieve data using key-value pairs. This will open up even more powerful ways to structure the information in your programs.