* 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. The list type implements the sequence
	protocol, and also allows 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
	and with this list we can perform most of list operations.
	Python lists are very versatile, that is we can change it as we 
	wish. It supports features like removal, addition, sort, etc. 

	Similar to strings, we can concatenate two lists using '+' 
	operator
	so num + var will return a new list with 'var' added in end of
	'num'
	We have already covered the append function.
	To add single object at the end of a list the 'append' 
	function is used
	num
	num.append(-5)
	num
	append takes only one argument. And append behaves different 
	from + operator. While + will return new list with two lists 
	added if we try similar with append function like:
	num.append([9, 10, 11])
	num
	It changes original list and add the argument as one element
	and not separate elements.
	To extend list with new list elements we use 'extend' function
	num = [1, 4, -6]
	num.extend([2, 8, 0])
	num
	As we can notice extend and append behave differently.
	To reverse a list 'reverse' function is available. 
	num
	This is current content of list
	num.reverse()
	Now after using reverse function, lets check the value of 'num'
	num
	Please note, reverse 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]
	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
	a[-1]
	similarly -2 will be second last and so forth. Now these 
	negative indexes can also be used with slicing. If we try
	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.
	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
	a[1:-1:2]
	This gives second, fourth and so on items of a till we reach 
	last item of list.
	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
	a[::-1]
	It returns reversed 'a'
	We can check for containership with lists as well.
	Let's look at the contents of num
	num
	To check if the number 4 is present in the list we type
	4 in a
	True
	
	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
	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 some more operations 
	on lists and tuples. In next session we will cover more on 
	Python supported data structures. Thank you!

*** Notes