Packt+ | Advance your knowledge in tech (2024)

The following example shows how to construct a list in Python and assign it to a variable:

numbers = [0, 1.2, 234259399992, 4+3j]

Individual entries in the list are accessed with index notation as follows:

numbers[2]

Notice that indexing always starts with 0. Negative indices are allowed and they represent positions starting at the end of the list. For example, numbers[-1] is the last entry, numbers[-2] is the next-to-last entry, and so forth.

Since lists are a mutable sequence type, we are allowed to modify the entries in-place:

numbers[0] = -3numbers[2] += numbers[0]print numbers

Another important way to refer to elements in a Python sequence type is slices, which allow the extraction of sublists from a list. Since this topic is very important for NumPy arrays, we defer the discussion to Appendix C, NumPy Arrays.

Python lists have a nice set of features, a few of which are illustrated in the following code examples:

Python has a few handy ways to construct frequently used lists. The range() function returns a list of equally spaced integers. The simplest form returns a list of successive integers starting at 0:

range(10)

The preceding command returns the following list:

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

Note that the last element is one less than the argument given in the function call. The rule of thumb is that range(n) returns a list with n elements starting at zero so that the last element is n-1. To start at a nonzero value, use the two-argument version as follows:

range(3, 17)

A third argument specifies an increment. The following command line produces a list of all positive multiples of 6 that are less than 100:

range(6,100,6)

Negative increments can also be used:

range(20, 2, -3)

Lists support concatenation, which is represented by the + operator:

l1 = range(1, 10)l2 = range(10, 0, -1)l3 = l1 + l2print l3

The multiplication operator (*) can be used to construct a list by repeating the elements of a given list, as follows:

l4 = 3*[4,-1,5]print l4

The most flexible way to construct a list in Python is to use a list comprehension. A full discussion is beyond the scope of this appendix, but the following examples illustrate some of the possibilities:

Tuples are similar to lists, but are immutable—once created, their elements cannot

be changed. The following command lines will result in an error message:

t1 = (2,3,5,7)t1[2] = -4

Tuples have a few specialized uses in Python. They can be used as indexes in dictionaries (because they are immutable). They also consist of the mechanism that Python uses to return more than one value from a function. For example, the built-in function divmod() returns both the integer quotient and remainder in a tuple:

divmod(213, 43)

Tuples support the same sequence interface as lists, except for methods that would modify the tuple. For example, there is no method named sort() that sorts a tuple in place.

A Python string represents an immutable sequence of characters. There are two string types: str, representing ASCII strings, and unicode, representing Unicode strings.

A string literal is a sequence of characters enclosed by either single quotes or double quotes, as follows:

s1 = 'I am a string's2 = "I am a string"print s1print s2

There is no semantic difference between single quotes and double quotes, except that a single-quoted string can contain double quotes and a double quoted string can contain single quotes. For example, the following command lines are correct:

s3 = "I'm a string"print s3

Strings are used for two main purposes: as dictionary indexes and to print messages. When printing messages, strings have the format() method that allows easy display of information. We use this feature frequently to add annotations to graphics. Here is an example:

n = 3message = 'The square root of {:d} is approximately {:8.5f}.'.format(n, n ** 0.5)print message

In the preceding example, there are two format specifiers:

The format specifications are matched (in order) with the arguments, in this case n and n ** 0.5.

Strings have a rich interface. If you need to code something with strings, it is very likely that there is a built-in function that does the job with very little modification. A list of all available string methods, as well as formatting features, is available at https://docs.python.org/2/library/stdtypes.html#string-methods.