Python: Lists and Mutability

Lists: A Sequence of Values

• A list, like a string, is a sequence of values, but unlike strings, lists can contain values of any type.
• The values in a list are called elements or items.
• Lists are created by enclosing elements in square brackets: [10, 20, 30, 40] or ['crunchy frog', 'ram bladder', 'lark vomit'].
• List elements don't need to be the same type, and a list can even contain another list, which is called nesting e.g. ['spam', 2.0, 5, [10, 20]].
• An empty list can be created using empty brackets: [].
• List values can be assigned to variables: cheeses = ['Cheddar', 'Edam', 'Gouda'].

Lists Are Mutable

• List elements are accessed using the bracket operator with the index, similar to strings, e.g. print(cheeses).
• Lists are mutable, meaning the order of items can be changed or individual items can be reassigned: numbers = [17, 123] followed by numbers = 5 changes the list to [17, 5].
• Lists create a mapping between indices and elements.
• Any integer expression can be used as an index.
• Using an index that doesn't exist results in an IndexError.
• Negative indices count backward from the end of the list.
• The in operator can be used to check if a value exists in a list: 'Edam' in cheeses returns True.

Traversing a List

• The most common way to traverse a list is using a for loop: for cheese in cheeses: print(cheese).
• To write or update elements, indices are needed, which can be achieved using range and len: for i in range(len(numbers)): numbers[i] = numbers[i] * 2.
• A for loop over an empty list will not execute the body.
• Nested lists count as a single element when determining the length of a list.

List Operations

• The + operator concatenates lists: c = a + b where a = [1, 2, 3] and b = [4, 5, 6] results in c = [1, 2, 3, 4, 5, 6].
• The * operator repeats a list a given number of times: [0] * 4 results in [0, 0, 0, 0].

List Slices

• The slice operator works on lists, similar to strings.
• Omitting the first index starts the slice at the beginning, and omitting the second index goes to the end.
• Omitting both indices creates a copy of the whole list: t[:].
• The slice operator on the left side of an assignment can update multiple elements: t[1:3] = ['x', 'y'] replaces elements at indices 1 and 2.

List Methods

• append adds a new element to the end of a list: t.append('d').
• extend takes a list as an argument and appends all its elements to the list: t1.extend(t2).
• sort arranges the elements of the list from low to high: t.sort().
• Most list methods are void, meaning they modify the list and return None.

Deleting Elements

• pop removes an element by its index and returns the removed element: x = t.pop(1). If no index is provided, it removes and returns the last element.
• del removes an element by its index without returning it: del t.
• remove removes an element by its value (first occurrence): t.remove('b').
• del with a slice index removes multiple elements: del t[1:5].

Lists and Functions

• len(list) returns the length of the list
• max(list) returns the maximum value from the list
• min(list) returns the minimum value from the list
• sum(list) returns the sum of all numbers in the list
• sum() only works when the list consists of numbers. max(), min(), and len() can work with strings and other comparable types.
• Lists can be used to simplify programs, such as computing the average of numbers entered by a user.

Lists and Strings

• Strings can be converted to a list of characters using list(string).
• The split method breaks a string into a list of words, using whitespace as the default delimiter: s.split().
• split can take an optional delimiter argument to specify word boundaries: s.split('-').
• join is the inverse of split; it concatenates a list of strings using a specified delimiter: ' '.join(t).

Parsing Lines

• The split method can be used to parse specific parts of lines in a file.
• Code example: opens a file, identifies lines starting with "From," splits those lines into words, and prints the third word (day of the week).

Objects and Values

• Variables can refer to the same object or to different objects with the same value.
• The is operator checks if two variables refer to the same object.
• Objects are identical if they are the same object, and equivalent if they have the same value.

Aliasing

• When one variable is assigned to another (b = a), both refer to the same object, creating an alias.
• Changes to an aliased mutable object affect all aliases.
• Aliasing is generally safer with immutable objects like strings.

List Arguments

• When a list is passed to a function, the function receives a reference to the list.
• If a function modifies a list parameter, the caller sees the change.
• List methods like append modify the list, while operators like + create new lists.
• Functions intended to modify lists should be carefully written to avoid creating new lists unintentionally.

Debugging

• List errors can be hard to debug
• Most list methods modify the list and return None, which differs from string methods.
• Pick one way to do things and stick with it, avoid confusion cause by the multitude of options
• Use copies to avoid aliasing problems when you need to keep the original list unchanged e.g. orig = t[:] creates a copy of list t
• Applying a guardian pattern is useful when reading and parsing files to avoid errors caused by unexpected or missing input data

Glossary

• Aliasing: When two or more variables refer to the same object.
• Delimiter: A character or string that separates parts of a string.
• Element: A value in a list (or other sequence), also called items.
• Equivalent: Having the same value.
• Index: An integer indicating an element's position in a list.
• Identical: Being the same object (implies equivalence).
• List: A sequence of values.
• List traversal: Accessing each element in a list sequentially.
• Nested list: A list within another list.
• Object: Something to which a variable can refer, having a type and value.
• Reference: The association between a variable and its value.