+ + Table of Contents + +
++ + Table of Contents + +
++ Python provides an intuitive way to represent a group items, called + + + Lists + + + . The +items of a + + + List + + + are called its elements. Unlike C/C++, elements can be of any +type. A + + + List + + + is represented as a list of comma-sepated elements with square +brackets around them: +
++ >>> a = [10, 'Python programming', 20.3523, 23, 3534534L] +>>> a +[10, 'Python programming', 20.3523, 23, 3534534L] ++
+ The following are some of the most commonly used operations on + + + Lists + + + . +
++ Individual elements of a + + + List + + + can be accessed using an index to the element. +The indices start at 0. One can also access the elements of the + + + List + + + in reverse +using negative indices.: +
++ >>> a[1] +'Python programming' +>>> a[-1] +3534534L ++
+ It is important to note here that the last element of the + + + List + + + has an index of +-1. +
++ Two or more + + + Lists + + + can be concatenated using the + operator: +
++ >>> a + ['foo', 12, 23.3432, 54] +[10, 'Python programming', 20.3523, 'foo', 12, 23.3432, 54] +>>> [54, 75, 23] + ['write', 67, 'read'] +[54, 75, 23, 'write', 67, 'read'] ++
+ A + + + List + + + can be sliced off to contain a subset of elements of the + + + List + + + . Slicing +can be done by using two indices separated by a colon, where the first index is +inclusive and the second index is exclusive. The resulting slice is also a + + + List + + + .: +
++ >>> num = [1, 2, 3, 4, 5, 6, 7, 8, 9] +>>> num[3:6] +[4, 5, 6] +>>> num[0:1] +[1] +>>> num[7:10] +[7, 8, 9] ++
+ The last example showed how to access last 3 elements of the + + + List + + + . There is a +small catch here. The second index 10 actually refers to the 11th element of the + + + List + + + which is still valid, even though it doesn't exist because the second +index is exclusive and tells the Python interpreter to get the last element of +the + + + List + + + . But this can also be done in a much easier way using negative indices: +
++ >>> num[-3:-1] +[7, 8, 9] ++
+ Excluding the first index implies that the slice must start at the beginning of +the + + + List + + + , while excluding the second index includes all the elements till the +end of the + + + List + + + . A third parameter to a slice, which is implicitly taken as 1 +is the step of the slice. It is specified as a value which follows a colon after +the second index: +
++ >>> num[:4] +[1, 2, 3, 4] +>>> num[7:] +[8, 9] +>>> num[-3:] +[7, 8, 9] +>>> num[:] +[1, 2, 3, 4, 5, 6, 7, 8, 9] +>>> num[4:9:3] +[5, 8] +>>> num[3::2] +[4, 6, 8] +>>> num[::4] +[1, 5, 9] ++
+ A + + + List + + + can be multiplied with an integer to repeat itself: +
++ >>> [20] * 5 +[20, 20, 20, 20, 20] +>>> [42, 'Python', 54] * 3 +[42, 'Python', 54, 42, 'Python', 54, 42, 'Python', 54] ++
+ + + in + + + operator is used to find whether an element is part of the + + + List + + + . It +returns + + + True + + + if the element is present in the + + + List + + + or + + + False + + + if it is not +present. Since this operator returns a Boolean value it is called a Boolean +operator: +
++ >>> names = ['Guido', 'Alex', 'Tim'] +>>> 'Tim' in names +True +>>> 'Adam' in names +False ++
+ Length of a + + + List + + + can be found out using the len function. The max function +returns the element with the largest value and the min function returns the +element with the smallest value: +
++ >>> num = [4, 1, 32, 12, 67, 34, 65] +>>> len(num) +7 +>>> max(num) +67 +>>> min(num) +1 ++
+ Unlike Strings + + + Lists + + + are mutable, i.e. elements of a + + + List + + + can be manipulated: +
++ >>> a = [1, 3, 5, 7] +>>> a[2] = 9 +>>> a +[1, 3, 9, 7] ++
+ An element or a slice of a + + + List + + + can be deleted by using the + + + del + + + statement: +
++ >>> a = [1, 3, 5, 7, 9, 11] +>>> del a[-2:] +>>> a +[1, 3, 5, 7] +>>> del a[1] +>>> a +[1, 5, 7] ++
+ In the same way, values can be assigned to individual elements of the + + + List + + + , +a + + + List + + + of elements can be assigned to a slice: +
++ >>> a = [2, 3, 4, 5] +>>> a[:2] = [0, 1] +[0, 1, 4, 5] +>>> a[2:2] = [2, 3] +>>> a +[0, 1, 2, 3, 4, 5] +>>> a[2:4] = [] +>>> a +[0, 1, 4, 5] ++
+ The last two examples should be particularly noted carefully. The last but one +example insert elements or a list of elements into a + + + List + + + and the last example +deletes a list of elements from the + + + List + + + . +
++ An + + + Empty List + + + is a + + + List + + + with no elements and is simply represented as +[]. A + + + None List + + + is one with all elements in it being + + + None + + + . It serves +the purpose having a container list of some fixed number of elements with +no value: +
++ >>> a = [] +>>> a +[] +>>> n = [None] * 10 +>>> n +[None, None, None, None, None, None, None, None, None, None] ++
+ As mentioned earlier, a List can contain elements of any data type. This also +implies a + + + List + + + can have a + + + Lists + + + themselves as its elements. These are +called as + + + Nested Lists + + + . There is no limit on the depth of the + + + Nested Lists + + + : +
++ >>> a = [1, [1, 2, 3], 3, [1, [1, 2, 3]], 7] ++
+ A method is a function that is coupled to an object. More about objects +and its methods are discussed in Advanced Python module. In general, a +method is called like: +
++ object.method(arguments) ++
+ For now, it is enough to know that a list of elements is an object and +so + + + List + + + methods can be called upon them. Also some of the methods change +the + + + List + + + in-place, meaning it modifies the existing list instead of creating +a new one, while other methods don't. It must be noted as we run through +the + + + List + + + methods. +
++ Some of the most commonly used + + + List + + + methods are as follows: +
++ The + + + append + + + method is used to append an object at the end of the list: +
++ >>> prime = [2, 3, 5] +>>> prime.append(7) +>>> prime +[2, 3, 5, 7] ++
+ It is important to note that append changes the + + + List + + + in-place. +
++ The + + + count + + + method returns the number of occurences of a particular element +in a list: +
+
+ >>> [1, 4, 4, 9, 9, 9].count(9)
+3
+>>> tlst = ['Python', 'is', 'a', 'beautiful', 'language']
+>>> tlst.count('Python')
+1
+
+ + The + + + extend + + + method extends the list on which it is called by the list supplied +as argument to it: +
++ >>> a = [1, 2, 3] +>>> b = [4, 5, 6] +>>> a.extend(b) +[1, 2, 3, 4, 5, 6] ++
+ This is an in-place method. This method is equivalent to using the + operator, but +using the + operator returns a new list. +
++ The + + + index + + + method returns the index position of the element in the list +specified as argument: +
++ >>> a = [1, 2, 3, ,4, 5] +>>> a.index(4) +3 ++
+ The + + + insert + + + method is used to insert an element specified as the second +argument to the list at the position specified by the first argument: +
++ >>> a = ['Python', 'is', 'cool'] +>>> a.insert(2, 'so') +>>> a +['Python', 'is', 'so', 'cool'] ++
+ The + + + insert + + + method changes the + + + List + + + in-place. +
++ The + + + pop + + + method removes an element from the list. The index position +of the element to be removed can be specified as an argument to the + + + pop + + + method, if not it removes the last element by default: +
++ >>> a = [1, 2, 3, 4, 5] +>>> a.pop() +>>> a +5 +>>> a.pop(2) +>>> a +3 ++
+ The + + + pop + + + method changes the + + + List + + + in-place. +
++ The + + + remove + + + method removes the first occurence of an element supplied as a +parameter: +
++ >>> a = [1, 2, 3, 4, 2, 5, 2] +>>> a.remove(2) +>>> a +[1, 3, 4, 2, 5, 2] ++
+ The + + + reverse + + + method reverses elements in the list. It is important to note +here that + + + reverse + + + method changes the list in-place and doesn't return any +thing: +
++ >>> a = ['guido', 'alex', 'tim'] +>>> a.reverse() +>>> a +['tim', 'alex', 'guido'] ++
+ The + + + sort + + + method is used to sort the elements of the list. The + + + sort + + + method +also sorts in-place and does not return anything: +
++ >>> a = [5, 1, 3, 7, 4] +>>> a.sort() +>>> a +[1, 3, 4, 5, 7] ++
+ In addition to the sort method on a + + + List + + + object we can also use the built-in + + + sorted + + + function. This function takes the + + + List + + + as a parameter and returns +a sorted copy of the list. However the original list is left intact: +
++ >>> a = [5, 1, 3, 7, 4] +>>> b = sorted(a) +>>> b +[1, 3, 4, 5, 7] +>>> a +[5, 1, 3, 7, 4] ++
+ + + Tuples + + + are sequences just like + + + Lists + + + , but they are immutable. In other +words + + + Tuples + + + provides a way to represent a group of items, where the group +of items cannot be changed in any way. The syntax of a + + + Tuple + + + is also very +similar to + + + List + + + . A + + + Tuple + + + is represented with the list of items, called +elements of the + + + Tuple + + + separated by comma, with the entire list being enclosed +in parenthesis. It is not compulsory to use parenthesis around a + + + Tuple + + + but +it may be necessary in some of the cases: +
++ >>> a = 1, 2, 3 +>>> a +(1, 2, 3) +>>> b = 1, +>>> b +(1,) ++
+ It is interesting to note the second example. Just a value followed by a comma +automatically makes that an element of a + + + Tuple + + + with only one element. It is +also important to note that, irrespective of input having a parenthesis, the +output always has a parenthesis. +
++ The first example is also known as + + + Tuple packing + + + , because values are being +packed into a tuple. It is also possible to do + + + Tuple unpacking + + + which is more +interesting. It is better to understand that by example. Say we have a +co-ordinate pair from which we need to separate x and y co-ordinates: +
++ >>> a = (1, 2) +>>> x, y = a +>>> x +1 +>>> y +2 ++
+ + + Tuple unpacking + + + also has several other use-cases of which the most interesting +one is to swap the values of two variables. Using programming languages like C +would require anywhere around 10 lines of code and an extra temporary variable +to do this (including all the #include stuff). Python does it in the most +intuitive way in just one line. Say we want to swap the co-ordinates in the +above example: +
++ >>> x, y = y, x +>>> x +2 +>>> y +1 ++
+ There is no need to introduce all the + + + Tuple + + + operations again, since + + + Tuples + + + support the following operations that + + + List + + + supports in exactly the same way: +
++ Indexing +
++ Concatenating +
++ Slicing +
++ Membership +
++ Multiplication +
++ Length, Maximum, Minimum +
++ The following examples illustrate the above operations: +
++ >>> a = (1, 2, 3, 4, 5, 6) +>>> a[5] +6 +>>> b = (7, 8, 9) +>>> a + b +(1, 2, 3, 4, 5, 6, 7, 8, 9) +>>> a[3:5] +(4, 5) +>>> 5 in a +True +>>> c = (1,) +>>> c * 5 +(1, 1, 1, 1, 1) +>>> len(a) +6 +>>> max(a) +6 +>>> min(a) +1 ++
+ However the following + + + List + + + operations are not supported by + + + Tuples + + + because + + + Tuples + + + cannot be changed once they are created: +
++ Changing elements +
++ Deleting elements +
++ Assigning to slices +
++ Similarity to + + + Lists + + + leads to the questions like, why not + + + Lists + + + only? Why do +we even want + + + Tuples + + + ? Can we do the same with + + + Lists + + + ? And the answer is + + + Yes + + + we can do it, but + + + Tuples + + + are helpful at times, like we can return Tuples from +functions. They are also returned by some built-in functions and methods. And +also there are some use cases like co-ordinate among other things. So + + + Tuples + + + are helpful. +
++ The following additional syntax are introduced to make it easier to operate on + + + Lists + + + . +
++ The + + + range + + + function takes at least one argument and 2 additional optional +arguments. If two or more arguments are specified, the range function returns +a list of natural numbers starting from the first argument passed to it to the +second argument. The third argument, if specified is used as a step. Suppose +only one argument is specified, then + + + range + + + function returns a list of natural +numbers starting from 0 upto the argument specified: +
++ >>> range(5, 10, 2) +[5, 7, 9] +>>> range(2, 15) +[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] +>>> range(12) +[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11] ++
+ The + + + for + + + keyword is used as a part of the looping construct. Unlike for loops +in other languages, Python's for is used to iterate through the elements of +sequences like + + + Lists + + + , + + + Tuples + + + , + + + Dictionaries + + + , etc. The syntax of the for loop +consists of + + + for + + + , followed by a variable to hold the individual or the current +element of the list during iteration and + + + in + + + , followed by the sequence and a +semicolon(':') The next line which is part of the + + + for + + + loop, i.e the statements +that are part of the loop should start with a new intend: +
++ >>> names = ['Guido', 'Alex', 'Tim'] +>>> for name in names: +... print "Name =", name +... +Name = Guido +Name = Alex +Name = Tim ++
+ This section on + + + Lists + + + and + + + Tuples + + + introduces almost all the necessary +machinary required to work on + + + Lists + + + and + + + Tuples + + + . Topics like how to +use these data structures in bigger more useful programs will be introduced +in the subsequent chapters. +
+