--- a/lists.org Mon Sep 13 18:35:56 2010 +0530
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,141 +0,0 @@
-* Lists
-*** Outline
-***** Lists
-***** Tuples
-***** Arsenal Required
-*** Script
- 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!
-
-*** Notes