* 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