29:05
Python Tutorial for Beginners 4: Lists, Tuples, and Sets
Corey Schafer
Overview
This video introduces Python's fundamental data structures: lists, tuples, and sets. It details how to create, access, and manipulate lists, covering indexing, slicing, and various methods for adding, removing, and sorting elements. The tutorial then explains tuples as immutable versions of lists, highlighting their key difference. Finally, it explores sets, emphasizing their unordered nature, duplicate removal capabilities, efficient membership testing, and set operations like intersection, difference, and union. The video concludes by demonstrating how to create empty versions of each data structure and briefly previews dictionaries.
How was this?
Save this permanently with flashcards, quizzes, and AI chat
Chapters
- Lists are ordered, mutable collections of values, created using square brackets `[]`.
- Elements in a list can be accessed individually using zero-based indexing (e.g., `my_list[0]`).
- Negative indexing allows access from the end of the list (e.g., `my_list[-1]` for the last element).
- Slicing `[start:stop]` extracts a sub-list, where `start` is inclusive and `stop` is exclusive.
- The `len()` function returns the number of items in a list.
Lists are the most versatile sequence type in Python, essential for storing and organizing collections of data that may need to be modified.
Creating a list of courses like `courses = ['history', 'math', 'physics', 'comp sci']` and accessing 'math' with `courses[1]`.
- The `append()` method adds a single item to the end of a list.
- The `insert(index, value)` method adds an item at a specific index, shifting subsequent elements.
- The `extend(iterable)` method adds all items from another iterable (like another list) to the end of the current list.
- Items can be removed using `remove(value)` (removes the first occurrence of a value) or `pop()` (removes and returns the last item by default, or an item at a specific index).
- Lists can be sorted alphabetically or numerically using `sort()`, which modifies the list in place.
Understanding these methods allows you to dynamically change the contents of your lists, which is crucial for managing data that changes over time.
Adding 'art' to the end of the `courses` list using `courses.append('art')`.
- The `reverse()` method reverses the order of elements in a list in place.
- The `sort()` method sorts list elements in ascending order (alphabetically for strings, numerically for numbers) in place.
- The `sorted(iterable)` function returns a *new* sorted list without modifying the original.
- Built-in functions like `min()`, `max()`, and `sum()` can be used on lists containing comparable elements (e.g., numbers).
- The `index(value)` method returns the index of the first occurrence of a specified value, raising a `ValueError` if the value is not found.
- The `in` operator efficiently checks for the presence of an element in a list, returning `True` or `False`.
These functions provide efficient ways to analyze, order, and query your list data without needing to write complex custom logic.
Finding the minimum value in a list of numbers `nums` using `min(nums)`.
- A `for` loop can iterate through each item in a list, assigning each item to a variable in turn.
- Code blocks within a `for` loop are indented to indicate they belong to the loop.
- The `enumerate()` function can be used in a `for` loop to access both the index and the value of each item.
- The `start` argument in `enumerate()` allows you to begin indexing from a number other than zero.
- The string `join()` method combines elements of a list into a single string, using a specified separator.
- The string `split()` method does the reverse: it breaks a string into a list of substrings based on a delimiter.
Efficiently processing each item in a list is a fundamental programming task, and these techniques enable you to automate repetitive operations.
Looping through a list of courses and printing each one using `for course in courses: print(course)`.
- Tuples are ordered collections of values, similar to lists, but are created using parentheses `()`.
- The key difference is that tuples are immutable, meaning their contents cannot be changed after creation.
- Attempting to modify a tuple (e.g., using item assignment) will result in a `TypeError`.
- Because they are immutable, tuples have fewer built-in methods compared to lists (e.g., no `append`, `remove`, or `sort`).
- Tuples are useful when you need a collection of items that should not be altered, ensuring data integrity.
Choosing tuples over lists when data should remain constant prevents accidental modifications and can sometimes offer performance benefits.
Creating a tuple `my_tuple = (1, 2, 3)` and attempting to change its first element `my_tuple[0] = 5`, which would raise an error.
- Sets are unordered collections of unique elements, created using curly braces `{}`.
- Sets automatically discard duplicate values.
- Their unordered nature means elements do not have a fixed index, and their order can change.
- Sets provide highly efficient membership testing (checking if an item is present using the `in` operator).
- Sets support mathematical operations like `intersection` (common elements), `difference` (elements in one set but not another), and `union` (all elements from both sets).
Sets are ideal for tasks involving uniqueness, fast lookups, and comparing collections of items, often outperforming lists for these specific operations.
Creating a set `my_set = {1, 2, 2, 3}` results in `{1, 2, 3}`, and checking for membership with `2 in my_set` returns `True`.
- Empty lists can be created with `[]` or `list()`.
- Empty tuples can be created with `()` or `tuple()`.
- Creating an empty set requires using the `set()` constructor; empty curly braces `{}` create an empty dictionary, not a set.
- Understanding how to initialize empty structures is fundamental for building collections dynamically.
Knowing the correct syntax for creating empty lists, tuples, and sets is essential for initializing variables before populating them with data.
The correct way to create an empty set is `empty_set = set()`, while `empty_dict = {}` creates an empty dictionary.
Key takeaways
- Lists are mutable, ordered sequences that support a wide range of operations for data manipulation.
- Tuples are immutable, ordered sequences, best used when data should not change after creation.
- Sets are unordered collections of unique items, optimized for fast membership testing and set operations.
- Indexing starts at 0 for lists and tuples, while negative indices count from the end.
- Slicing allows you to extract sub-sequences from lists and tuples.
- Methods like `append`, `insert`, `remove`, and `pop` modify lists, while `sort` and `reverse` alter their order.
- The `sorted()` function provides a non-destructive way to get a sorted version of a sequence.
- Sets efficiently handle uniqueness and comparisons between collections using operations like intersection and union.
Key terms
ListTupleSetMutableImmutableIndexSlicingAppendExtendPopSortEnumerateJoinSplitIntersectionUnionDifferenceMembership Test
Test your understanding
- What is the primary difference between a list and a tuple in Python, and why would you choose one over the other?
- How can you access the third element of a list named `my_list`, and what would happen if you tried to access an index beyond the list's bounds?
- Explain how the `append()` and `extend()` methods differ when adding multiple items to a list.
- What are the main advantages of using a set compared to a list for checking if an item exists within a collection?
- How would you create a new list containing the elements of an existing list `original_list` but sorted in descending order, without modifying `original_list`?