A list is a Python collection that stores several values inside one variable. Lists keep their items in order and allow you to add, remove, replace, or examine values. A list can hold names, numbers, prices, colors, or even other lists. Lists are useful whenever a program needs to manage a group of related items.

You create a list by placing values between square brackets and separating the values with commas. The items may share the same data type or use different data types. After assigning the list to a variable, you can print it, update it, loop through it, or pass it to another part of your program.

An empty list contains no items when it is first created. You can make one with empty square brackets. Empty lists are useful when a program will collect information later, such as names entered by users, products added to a shopping cart, messages received from a form, or scores calculated while the program is running.

Every value stored inside a list is called an item or element. Items are separated by commas and can be strings, numbers, Boolean values, or other objects. Duplicate values are allowed. The position of each item matters because Python gives every item an index that can be used to access, replace, or remove it.

To access one list item, write the list name followed by an index inside square brackets. Python indexes begin at zero, so the first item uses index zero. Accessing an item lets you print it, compare it, use it in a calculation, or store it in another variable without changing the original list.

Positive indexing counts list positions from the beginning. The first item is index zero, the second is index one, and the pattern continues. Positive indexes are useful when you know an item’s position from the left side. Remembering that counting begins at zero prevents a common beginner mistake called an off-by-one error.

Negative indexing counts backward from the end of a list. Index minus one selects the last item, minus two selects the second-last item, and so on. This is convenient when you need an item near the end but do not know the list’s exact length. You do not need to calculate its positive index.

List slicing creates a new list containing part of an existing list. A slice commonly uses a start position and a stop position separated by a colon. The start item is included, but the stop item is excluded. Slicing is useful for selecting ranges, dividing data, copying sections, or examining only the items you need.

Lists are mutable, which means their items can be changed after the list is created. To replace one item, use its index on the left side of an assignment. Python removes the old value at that position and stores the new value there. This is useful for correcting information or updating a user’s selection.

You can replace several list items at once by assigning new values to a slice. The selected range is removed and replaced with the new sequence. The number of replacement items does not have to match the original range. This makes it possible to expand, shorten, or update a section of a list in one statement.

The append method adds one item to the end of an existing list. It changes the original list and does not create a new list. Append is commonly used when information arrives one item at a time, such as adding a new student, recording another score, or placing another product into a shopping cart.

The insert method adds an item at a specific position. It receives an index and the new value. Existing items at that position and after it move one place to the right. Insert is useful when order matters and the new item must appear at the beginning, middle, or another exact location in the list.

The extend method adds every item from another iterable to the end of a list. Unlike append, which adds its argument as one item, extend adds the values separately. It is useful for combining an existing list with several new values while changing the original list directly and preserving the order of all added items.

The remove method deletes the first item whose value matches the value you provide. You do not need to know the item’s index. If the value appears more than once, only its first occurrence is removed. If the value is absent, Python raises an error, so programs may check membership before calling remove.

The pop method removes an item and returns the removed value. Without an index, it removes the last item. With an index, it removes the item at that position. Pop is helpful when you need both to delete an item and continue using the removed value, such as processing the latest task in a list.

The del statement removes an item or a range of items by index. It can also delete the entire list variable. Unlike pop, del does not return the removed value. Use it when you know the position of data you no longer need. Be careful because using an invalid index causes an IndexError.

The clear method removes every item from a list but keeps the list variable available. After clearing, the list still exists and can receive new items. This is useful when a program needs to reset collected data, empty a cart, begin a new round of a game, or reuse the same list variable for fresh information.

The len function returns the number of items in a list. It is useful for showing totals, checking whether a list is empty, controlling loops, or validating that enough information was entered. The returned value is an integer. Nested lists count as single items at the outer level because each inner list occupies one position.

The in operator checks whether a value exists in a list, while not in checks whether it is absent. The result is either True or False. Membership tests are useful before removing values, preventing duplicate entries, checking permissions, or confirming that a user’s choice is one of the allowed options.

The count method tells you how many times a particular value appears in a list. It returns zero when the value is absent. Count is useful for finding repeated answers, measuring product quantities, checking votes, or summarizing data. The comparison uses exact values, so uppercase and lowercase strings are normally treated as different items.

The index method returns the position of the first matching value in a list. If the value appears several times, only the first position is returned. If the value does not exist, Python raises a ValueError. Membership can be checked first when the value may be missing. Index positions always begin at zero.

The sort method arranges the items in an existing list. Numbers are normally placed from smallest to largest, and strings are ordered alphabetically. Passing reverse=True sorts in descending order. Sort changes the original list. All compared items should normally have compatible types, because Python cannot directly order unrelated values such as strings and integers.

Custom sorting lets you decide which part of each item Python should use for ordering. The key argument receives a function that produces a comparison value. For beginners, built-in functions such as len are easy to use. Custom sorting is valuable when ordering words by length, records by price, or students by a selected score.

The reverse method changes the order of a list so the last item becomes first and the first item becomes last. It does not sort values by size or alphabet; it only flips the current order. A slice with a negative step can also produce a reversed copy without modifying the original list.

Assigning one list variable to another does not create an independent copy. Both names refer to the same list. To make a separate top-level list, use the copy method, list function, or a full slice. This prevents simple changes in one list from unexpectedly changing another list that was supposed to remain separate.

A normal list copy is a shallow copy. It creates a new outer list, but nested mutable objects inside it may still be shared. Changing the outer structure is independent, while changing an inner shared list can appear in both copies. Understanding this behavior is important when lists contain other lists, dictionaries, or mutable objects.

Lists can be joined with the plus operator, extend method, or unpacking. The plus operator creates a new list containing the items from both operands. Extend changes the first list. Joining lists is useful when combining results, merging groups, adding imported data, or building one complete sequence from several smaller collections.

A nested list is a list that contains one or more lists as items. Nested lists are helpful for grouped information, tables, game boards, schedules, or categories. To access a value inside an inner list, use one index for the outer list and another index for the position within the selected inner list.

A multidimensional list represents data using several levels of nested lists. A two-dimensional list resembles rows and columns in a table. More dimensions can represent layers or groups, although deeply nested structures can become difficult to read. Multidimensional lists are used for grids, matrices, seating charts, maps, and simple game boards.

List unpacking assigns list items to separate variables in one statement. The number of variables must normally match the number of items. Unpacking makes code easier to read when a list has a known structure, such as a name, age, and city. Each variable receives the value from the corresponding list position.

Extended unpacking uses an asterisk before one variable so it can collect several remaining items into a new list. This is useful when you need the first item, last item, or another fixed part while grouping the rest together. Only one starred target may appear in a single unpacking assignment.

A loop processes list items one at a time. A for loop is the simplest choice when you need every value. You can print items, calculate totals, validate information, or create new results. The loop variable temporarily receives each item in order, so the same indented code runs once for every list element.

A list comprehension is a compact way to create a new list from an existing iterable. It combines an expression and a loop inside square brackets. List comprehensions are useful for simple transformations, such as doubling numbers or changing text. Beginners should first understand ordinary loops before using this shorter form.

A conditional list comprehension creates a new list while keeping only items that satisfy a condition. The condition appears after the loop portion. This is useful for filtering numbers, valid names, available products, or completed tasks. It can replace a simple loop containing an if statement, but clarity should remain more important than shortening code.

A nested list comprehension includes more than one loop or creates nested list structures. It can be useful for grids and combinations, but it may become difficult for beginners to read. Start with a clear ordinary nested loop, then use a comprehension only when the meaning remains easy to understand and maintain.

Python provides lists, tuples, sets, and dictionaries for different jobs. Lists are ordered, mutable, and allow duplicates. Tuples are ordered but normally unchanged after creation. Sets store unique items without relying on position. Dictionaries connect keys with values. Choosing the correct collection depends on whether order, changes, duplicates, or named access are needed.

Common list errors include using an index that does not exist, removing a missing value, mixing incompatible types during sorting, and accidentally sharing one list between variables. Reading the final line of the traceback usually identifies the error type. Checking length, membership, and data types before an operation can prevent many beginner mistakes.

Lists are used in shopping carts, student records, task managers, menus, search results, game inventories, schedules, and many other applications. A program can collect values, update them, remove finished items, sort results, and calculate summaries. Combining basic list methods provides enough power to build many useful beginner projects.

Practice helps you remember how list operations work. Try creating lists, accessing positive and negative indexes, slicing ranges, replacing values, adding and removing items, sorting data, copying lists, looping through values, and writing comprehensions. Run every exercise, compare the output with your expectation, and correct mistakes by reading Python’s error messages carefully.

This mini project creates a simple shopping list manager using the list skills from this chapter. It begins with an empty list, adds products, removes one product, sorts the remaining items, and prints each item with a number. A larger version could accept user input, prevent duplicates, save data, or mark purchased items.