.. Objectives

.. ----------

.. By the end of this tutorial, you will be able to

.. Create Lists.

.. Access List elements.

.. Append elemets to list

.. Delete list elemets

.. 1. getting started with ipython 

.. Prerequisites

.. -------------

..   1. getting started with strings

..   #. getting started with lists

..   #. basic datatypes

.. Author              : Amit 

   Internal Reviewer   : Anoop Jacob Thomas <anoop@fossee.in>

   External Reviewer   :

   Language Reviewer   : Bhanukiran

.. #[[Anoop: Slides contain only outline and summary

Script

------

 {{{ Show the slide containing title }}}

Hello friends and welcome to the tutorial on getting started with

lists.

 {{{ Show the slide containing the outline slide }}}

In this tutorial we will be getting acquainted with a python data

structure called lists.  We will learn ::

 * How to create lists

 * Structure of lists

 * Access list elements

 * Append elements to lists

 * Delete elements from lists

List is a compound data type, it can contain data of mutually

different datatypes. List is also a sequence data type, all the

elements are arranged in a given order.

.. #[[Anoop: "all the elements are in order and **there** order has a

   meaning." - I guess something is wrong here, I am not able to

   follow this.]]

We will first create an empty list with no elements. On your IPython

shell type ::

   empty = [] 

   type(empty)

This is an empty list without any elements.

.. #[[Anoop: the document has to be continous, without any

   subheadings, removing * Filled lists]]

Lets now see how to define a non-empty list. We do it as,::

     nonempty = ['spam', 'eggs', 100, 1.234]

Thus the simplest way of creating a list is typing out a sequence 

of comma-separated values (or items) between two square brackets. 

As we can see lists can contain different kinds of data. In the

previous example 'spam' and 'eggs' are strings whereas 100 and 1.234 are

integer and float respectively. Thus we can put elements of different types in

lists including lists itself. This property makes lists heterogeneous

data structures.

.. #[[Anoop: the sentence "Thus list themselves can be one of the

   element types possible in lists" is not clear, rephrase it.]]

Example ::

      listinlist=[[4,2,3,4],'and', 1, 2, 3, 4]

We access an element of a list using its corresponding index. Index of

the first element of a list is 0. So for the list nonempty, nonempty[0] 

gives the first element, nonempty[1] the second element and so on and 

nonempty[3] the last element. ::

	    nonempty[0] 

	    nonempty[1] 

	    nonempty[3]

Following is an exercise that you must do. 

%% %% What happens when you do nonempty[-1]. 

Please, pause the video here. Do the exercise and then continue.  

.. #[[Anoop: was negative indices introduced earlier, if not may be we

   can ask them to try out nonempty[-1] and see what happens and then

   tell that it gives the last element in the list.]]

As you can see you get the last element which is 1.234.

In python negative indices are used to access elements from the end::

   nonempty[-1] 

   nonempty[-2] 

   nonempty[-4]

-1 gives the last element which is the 4th element , -2 second to last

and -4 gives the fourth from the last which, in this case,  is the first element.

We can append elements to the end of a list using the method append. ::

   nonempty.append('onemore') 

   nonempty

   nonempty.append(6) 

   nonempty

Following are  exercises that you must do. 

%% %% What is the syntax to get the element 'and' 

in the list,listinlist ?

%% %% How would you get 'and' using negative indices?

Please, pause the video here. Do the exercise and then continue.  

The solution is on your screen

As we can see nonempty is appended with 'onemore' and 6 at the end.

Using len function we can check the number of elements in the list

nonempty. In this case it is 6 ::

	 len(nonempty)

Just like we can append elements to a list we can also remove them.

There are two ways of doing it. One is by using index. ::

      del(nonempty[1])

deletes the element at index 1, i.e the second element of the

list, 'eggs'. The other way is removing element by content. Lets say

one wishes to delete 100 from nonempty list the syntax of the command

would be 

.. #[[Anoop: let x = [1,2,1,3]

   	     now x.remove(x[2])

	     still x is [2,1,3] so that is not the way to remove

	     element by index, it removed first occurrence of 1(by

	     content) and not based on index, so make necessary

	     changes]]

::

    nonempty.remove(100)

but what if there were two 100's. To check that lets do a small

experiment. ::

	   nonempty.append('spam') 

	   nonempty

	   nonempty.remove('spam') 

	   nonempty

If we check now we will see that the first occurence 'spam' is removed

and therefore `remove` removes the first occurence of the element in the sequence

and leaves others untouched.

One should remember this that while del removes by index number,

`remove` removes on the basis of content being passed on. For instance

if ::

       k = [1,2,1,3] 

       del([k[2])

gives us [1,2,3]. ::

      k.remove(x[2])

will give us [2,1,3]. Since it deletes the first occurence of what is

returned by x[2] which is 1.      

.. #[[Anoop: does it have two spams or two pythons?]]

.. #[[Anoop: there are no exercises/solved problems in this script,

   add them]]

Following are  exercises that you must do. 

%% %% Remove the third element from the list, listinlist.   

%% %% Remove 'and' from the list, listinlist.

Please, pause the video here. Do the exercise and then continue.  

{{{Slide for Summary }}}

In this tutorial we came across a sequence data type called lists. ::

 * We learned how to create lists.  

 * How to access lists.

 * Append elements to list.

 * Delete Element from list.  

 * And Checking list length.

{{{ show Sponsored by Fossee Slide }}}

This tutorial was created as a part of FOSSEE project.

I hope you found this tutorial useful.

Thank You

..

 * Author : Amit Sethi 

 * First Reviewer : 

 * Second Reviewer : Nishanth