• Choose a category
• All
• Classic-Fiction

By Root 1878 0

As we learned in Chapter 6, though, Python always follows a reference to an object whenever the reference is used, so your program deals only with objects. Whenever you assign an object to a data structure component or variable name, Python always stores a reference to that same object, not a copy of it (unless you request a copy explicitly).

Table 8-1 summarizes common and representative list object operations. As usual, for the full story see the Python standard library manual, or run a help(list) or dir(list) call interactively for a complete list of list methods—you can pass in a real list, or the word list, which is the name of the list data type.

Table 8-1. Common list literals and operations

Operation

Interpretation

L = []

An empty list

L = [0, 1, 2, 3]

Four items: indexes 0..3

L = ['abc', ['def', 'ghi']]

Nested sublists

L = list('spam')

L = list(range(-4, 4))

Lists of an iterable’s items, list of successive integers

L[i]

L[i][j]

L[i:j]

len(L)

Index, index of index, slice, length

L1 + L2

L * 3

Concatenate, repeat

for x in L: print(x)

3 in L

Iteration, membership

L.append(4)

L.extend([5,6,7])

L.insert(I, X)

Methods: growing

L.index(1)

L.count(X)

Methods: searching

L.sort()

L.reverse()

Methods: sorting, reversing, etc.

del L[k]

del L[i:j]

L.pop()

L.remove(2)

L[i:j] = []

Methods, statement: shrinking

L[i] = 1

L[i:j] = [4,5,6]

Index assignment, slice assignment

L = [x**2 for x in range(5)]

list(map(ord, 'spam'))

List comprehensions and maps (Chapters 14, 20)

When written down as a literal expression, a list is coded as a series of objects (really, expressions that return objects) in square brackets, separated by commas. For instance, the second row in Table 8-1 assigns the variable L to a four-item list. A nested list is coded as a nested square-bracketed series (row 3), and the empty list is just a square-bracket pair with nothing inside (row 1).[21]

Many of the operations in Table 8-1 should look familiar, as they are the same sequence operations we put to work on strings—indexing, concatenation, iteration, and so on. Lists also respond to list-specific method calls (which provide utilities such as sorting, reversing, adding items to the end, etc.), as well as in-place change operations (deleting items, assignment to indexes and slices, and so forth). Lists have these tools for change operations because they are a mutable object type.

* * *

[21] In practice, you won’t see many lists written out like this in list-processing programs. It’s more common to see code that processes lists constructed dynamically (at runtime). In fact, although it’s important to master literal syntax, most data structures in Python are built by running program code at runtime.

Lists in Action

Perhaps the best way to understand lists is to see them at work. Let’s once again turn to some simple interpreter interactions to illustrate the operations in Table 8-1.

Basic List Operations

Because they are sequences, lists support many of the same operations as strings. For example, lists respond to the + and * operators much like strings—they mean concatenation and repetition here too, except that the result is a new list, not a string:

% python

>>> len([1, 2, 3]) # Length

3

>>> [1, 2, 3] + [4, 5, 6] # Concatenation

[1, 2, 3, 4, 5, 6]

>>> ['Ni!'] * 4 # Repetition

['Ni!', 'Ni!', 'Ni!', 'Ni!']

Although the + operator works the same for lists and strings, it’s important to know that it expects the same sort of sequence on both sides—otherwise, you get a type error when the code runs. For instance, you cannot concatenate a list and a string unless you first convert the list to a string (using tools such as str or % formatting) or convert the string to a list (the list built-in function does the trick):

>>> str([1, 2]) + "34" # Same as "[1, 2]" + "34"

'[1, 2]34'

>>> [1, 2] + list("34") # Same as [1, 2] + ["3", "4"]

[1, 2, '3', '4']

List Iteration and Comprehensions

More