Python-Old-Version/C3/Data-Structures-Lists-and-Tuples /English
Welcome friends.
In this tutorial we shall look at some special Data structures supported by Python namely Lists and Tuples. We have already been introduced to lists in some of the previous tutorials, here we shall look at them in little more detail.
The list type is a container that holds a number of other objects, in the given order. Lists allow you to add and remove objects from the sequence.
First lets start the interpreter by typing ipython in terminal. We create our first list by typing
num = [1, 2, 3, 4]
Items enclosed in square brackets separated by comma constitutes a list. One neat feature of Python list is that we can store data of any type in them. We can have a list something like:
var = [1, 1.2, 'string'] print var
Similar to strings, we can concatenate two lists using '+' operator, so num + var will return a new list with the contents of both 'num' and 'var' one after the other. Let's look at what num contains now
print num
As you can see num is unchanged by the '+' operator.
We have already covered the append function in one of our previous tutorials. To add single object at the end of a list the 'append' function is used Let's now append -5 to it.
num.append(-5)
The contents of num have been changed now.
print num
append takes only one argument. And append behaves different from + operator. While + returns a new list with two lists added, append will simply add the entire object to the end of the list:
num.append([9, 10, 11]) print num
It adds the entire list as one element and not separate elements. In order to add separate elements we use the 'extend' function Let's reinitialize num
num = [1, 4, -6] num.extend([2, 8, 0]) print num
Let's now move on to see more functions available with lists. To reverse a list, we have the 'reverse' function. Please note the order of the elements in num. Let's now do:
num.reverse()
Now after using reverse function, lets check the value of 'num'
print num
Please note, the reverse() function actually manipulated the list. To remove a particular element from the list Python provides the remove() function
num.remove(8)
if the given argument is present more than once in the list, then the first occurrence of that element is removed from list.
The Slicing and Striding concepts which we covered for Arrays work with lists as well. Lets revisit the concept by looking at some examples
a = [1, 2, 3, 4, 5] print a[1:3]
returns a list with second and third element of 'a'. One important feature of list indexing is the negative index. In Lists -1 indicates last element of the list
print a[-1]
similarly -2 will be second last and so forth. Now these negative indexes can also be used with slicing. If we try
print a[1:-1]
we get list which excludes first and last element of a, and if we do not specify the start or the end index value the default values are taken. The default values being the first element and the last element.
print a[:3]
will return a list from beginning upto the fourth element of a. We can perform striding as well, by specifying the step size
print a[1:-1:2]
This gives second, fourth and so on items of a till we reach last item of list.
print a[::2]
will skip all the even placed elements of a with step sizes, if we specify negative values we get some interesting results. Lets try
print a[4:1:-1]
Here we begin at the 5th element and go upto the 2nd element in the reverse order since step size is -1
print a[::-1]
This returns a slice with all the elements in 'a' reversed in order. Here the negative step indicates that the start point has to be the last element and the end point has to be the first element and the order has to be reversed.
Let's now move on to other functionality. We can check for containership of elements within lists as well. Let's look at the contents of num print num To check if the number 4 is present in the list we type 4 in num True
Now let's move onto Tuples. Python provides support for special immutable lists known as 'tuple'. To create a tuple instead we use normal brackets '(' unlike '[' for lists.
t = (1, 2, 3, 4, 5, 6, 7, 8)
its elements can also be accessed using indexes just like lists.
print t[0] + t[3] + t[-1]
but operation like
t[4] = 7
are not allowed These features of tuples have their advantages. To see where are they used we first create two variables
a, b = 1, 6 print a, b
As you can see multiple variable assignments are possible using tuples. Now lets swap values their values. Normal approach would be to create a temporary to hold the value but because of tuples we can do something cool like
b, a = a, b print a, b
and values are swapped. And this swapping works for all types of variables. This is possible because of something magical that Python does called as tuple packing and unpacking.
With this we come to the end of this tutorial on Lists and tuples. In this tutorial we have learnt about initializing, various list operations, slicing and striding. We learnt about tuple initialization, packing and unpacking. In next session we will cover more on Python supported data structures. Thank you!
