Merged heads.
--- a/basicdatatype.rst Wed Sep 22 22:11:00 2010 +0530
+++ b/basicdatatype.rst Wed Sep 22 23:09:28 2010 +0530
@@ -4,19 +4,22 @@
{{{ Show the slide containing the outline slide }}}
+In this tutorial, we shall look at::
-In this tutorial, we shall look at
* Various Datatypes in Python
* Operators with a little hands-on on how they can be applied to
the different data types.
Since this a hands on session, you will require python installed in your
computer.
-
+.. #[Nishanth]: this line is not required
First we will explore python data structures in the domain of numbers.
There are three built-in data structures in python to represent numbers.
+.. #[Nishanth]: Did you mean data types when you said data structures??
+ Data structures is used for lists and others.
+
{{{ A slide to make a memory note of this }}}
These are:
@@ -25,103 +28,109 @@
* Complex and
* Boolean
-
-
Lets first talk about integers. ::
- In[]: a=13
+ a = 13
+
+.. #[Nishanth]: give a space before and after the = sign
+Thats it, there we have our first integer variable a.
-Thats it , there we have our first integer variable a.
+.. #[Nishanth]: Show the value of a
If we now see ::
- In[]: type(a)
- Out[]: <type 'int'>
+ type(a)
+ <type 'int'>
- This means that a is a type of int. Being an int data structure
+This means that a is a type of int. Being an int data structure
in python means that there are various functions that this variable
has to manipulate it different ways. You can explore these by doing,
- In[]: a.<Tab>
+ a.<Tab>
+.. #[Nishanth]: a.<Tab> is not a good idea for int or float
Lets see the limits of this int.
- In[]: b=99999999999999999999
- In[]: b
+ b = 99999999999999999999
+ b
As you can see even when we put a value of 9 repeated 20 times
python did not complain. However when you asked python to print
the number again it put a capital L at the end. Now if you check
the type of this variable b, ::
- In[]: type(b)
+ type(b)
<type 'long'>
The reason for this is that python recognizes large integer numbers
-by a data type long. However long type and integer type share there
+by the data type long. However long type and integer type share there
functions and properties.
Lets now try out the second type in list called float.
-
Decimal numbers in python are recognized by the term float ::
- In[]: p=3.141592
- In[]: p
+ p = 3.141592
+ p
If you notice the value of output of p isn't exactly equal to p. This
is because computer saves floating point values in a specific
-format. This is always an aproximationation. This is why we should
+format. There is always an aproximationation. This is why we should
never rely on equality of floating point numbers in a program.
-
The last data structure in the list is complex number ::
- In: c=3.2+4.6j
+ c = 3.2+4.6j
as simple as that so essentialy its just a combination of two floats the
imaginary part being define by j notation usually used in electrical
engineering. Complex numbers have a lot of functions specific to them.
Lets check these ::
- In[]: c.<Tab>
+ c.<Tab>
+
+.. #[Nishanth]: rephrase the "j used in electrical engineering"
+ Its ok if you skip it also. Just say that here
+ j is used and not i
Lets try some of them ::
- In[]: c.real
- In[]: c.imag
+ c.real
+ c.imag
c.real gives the real part of the number and c.imag the imaginary.
We can get the absolute value using the function ::
- In[]: abs(c)
-
+ abs(c)
Python also has Boolean as a built-in type.
Try it out just type ::
- In[]: t=True
+ t = True
note that T in true is capitalized.
You can apply different Boolean operations on t now for example ::
- In[]: f=not t
+ f = not t
In[]: f
In[]: f or t
In[]: f and t
+
+.. #[Nishanth]: remove In[]: and include spaces before and after = symbol
+ I don't want to edit it everywhere in the script
The results explanotary in themselves.
The usage of boolean brings us to an interesting question of precendence.
What if you want to apply one operator before another.
-Well you can use parenthesis for precedence ,
+Well you can use parenthesis for precedence.
Lets write some piece of code to check this out.
@@ -144,34 +153,36 @@
gives the value False.
-
Lets now discuss sequence data structures in python. Sequence
datatypes are those in which elements are kept in a sequential
-order.All the elements accessed using index.
+order. All the elements accessed using index.
{{{ slide to for memory aid }}}
The sequence datatypes in python are ::
+
* list
* string
* tuple
-
The list type is a container that holds a number of other
objects, in the given order.
-
We create our first list by typing ::
In[]: num = [1, 2, 3, 4]
+.. #[Nishanth]: Show the value of the variable
Items enclosed in square brackets separated by comma
constitutes a list.
-Lists can store data of any type in them.
+Lists can store data of any type in them.
We can have a list something like ::
+
In[]: var = [1, 1.2, [1,2]]
+
+.. #[Nishanth]: Show the value of the variable
print var
Now we will have a look at strings
@@ -180,20 +191,21 @@
In[]: w="hello"
+.. #[Nishanth]: Show the value of the variable
w is now a string variable with the value "hello"
{{{ Memory Aid Slide }}}
Python strings can actually be defined in three different ways ::
-
-
In[]: k='Single quote'
In[]: l="Double quote contain's single quote"
In[]: m='''"Contain's both"'''
-Thus while single quote string may not contain another single quote
-double quote can do that. While triple quoted strings can contain both.
+Thus, single quotes are used as delimiters usually.
+When a string contains a single quote, double quotes are used as delimiters.
+When a string quote contains both single and double quotes, triple quotes are
+used as delimiters.
The last in the list of sequence data types is tuple.
@@ -201,7 +213,6 @@
unlike '[' for lists.::
In[]: t = (1, 2, 3, 4, 5, 6, 7, 8)
-
Because of their sequential property there are certain functions and
operations we can apply to all of them.
@@ -222,6 +233,10 @@
Negative indices can be used to access in reverse
+.. #[Nishanth]: Elaborate on indexing.
+ Indexing starts from 0 when moving from left to right
+ Indexing starts from -1 when moving from right to left
+
Addition gives a new sequence containing both sequences ::
In[]: num+var
@@ -236,13 +251,17 @@
In[]: len(w)
In[]: len(t)
-We can check whether an element is there with 'in' keyword ::
+Prints the length the variable.
+
+We can check the containership of an element using the 'in' keyword ::
In[]: 3 in num
In[]: 'H' in w
In[]: 2 in t
-Find maximum using max function and minimum using min::
+We see that it gives True and False accordingly.
+
+Find maximum using max function and minimum using min::
In[]: max(t)
In[]: min(w)
@@ -252,8 +271,8 @@
In[]: sorted(num)
In[]: reversed(w)
-As a consequence of the order one can access a group of elements together
-The methods for this are called slicing and striding
+As a consequence of the order one we access a group of elements together.
+This is called slicing and striding.
First Slicing
@@ -261,14 +280,15 @@
In[]:j=[1,2,3,4,5,6]
-Lets say we want elements 2 to 5.
+Lets say we want elements starting from 2 and ending in 5.
For this we can do ::
In[]: j[1:4]
The syntax for slicing is sequence variable name square bracket
-first element index ,colon,second element index.
+first element index, colon, second element index.::
+.. #[nishanth]: specify that the last element is not included
In[]: j[:4]
@@ -281,8 +301,7 @@
This effectively is the whole list.
-Striding is a concept similar to slicing with the concept of skiping elements
-at regular intervals added.
+Striding is similar to slicing except that the step size here is not one.
Lets see by example ::
@@ -290,28 +309,40 @@
In[]: z[1:8:2]
Out[]:[2, 4, 6, 8]
-The colon two added in the end signifies all the second elemets. This is why we call this concept
+The colon two added in the end signifies all the alternate elements. This is why we call this concept
striding because we move through the list with a particular stride or step. The step in this example
being 2.
-We have talked about many similar features of lists,strings and tuples but there are many is an important
-way in which lists differ from strings and tuples. Lets see this by example.::
+We have talked about many similar features of lists, strings and tuples. But there are many important
+features in lists that differ from strings and tuples. Lets see this by example.::
In[]: z[1]=9
In[]: w[1]='k'
+{{{ slide to show the error }}}
-{{{ slide to show the error }}}
+.. #[Nishanth]: Use sensible variable names. At this point no one will remember
+ that z is a list and w is tuple.
+ for example you can use names like some_list, a_tuple etc.
+ or you can also use l for list, t for tuple and s for string
+
As you can see while the first command executes with out a problem there is an error on the second one.
Now lets try ::
+
In[]: t[1]=5
Its the same error. This is because strings and tuples share the property of being immutable.
We cannot change the value at a particular index just by assigning a new value at that position.
+
In case of strings we have special functions to appy relacement and other things while tuples cannot
be changed at all.
+.. #[Nishanth]: Even in strings also the special functions do not modify the
+ original string. A new string is created instead. These have
+ been provided for string manipulation.
+ hence I don't think you have to mention this.
+
We have looked at different types but we need to convert one data type into another. Well lets one
by one go through methods by which we can convert one data type to other:
@@ -320,17 +351,20 @@
In[]: i=34
In[]: d=float(i)
-Python has built in functions int , float and complex to convert one number type
+Python has built in functions int, float and complex to convert one number type
data structure to another.
In[]: dec=2.34
In[]: dec_con=int(dec)
-As you can see the decimal part of the number is simply stripped to get the integer.::
+.. #[Nishanth]: Show the value of the variables
+
+As you can see the decimal part of the number is simply stripped to get the integer.::
In[]: com=2.3+4.2j
In[]: float(com)
- In case of complex number to floating point only the real value of complex number is taken.
+
+In case of complex number to floating point only the real value of complex number is taken.
Similarly we can convert list to tuple and tuple to list ::
@@ -345,6 +379,8 @@
In: somestring="Is there a way to split on these spaces."
In: somestring.split()
+.. #[Nishanth]: Did you try list(somestring). What does it give??
+
This produces a list with the string split at whitespace.
similarly we can split on some other character.
@@ -364,11 +400,17 @@
Note that the list has to be a list of strings to apply join operation.
+.. #[Nishanth]: string to list is fine. But list to string can be left for
+ string manipulations. Just say it requires some string
+ manipulations and leave it there.
+
+.. #[Nishanth]: Where is the summary
+ There are no exercises in the script
+
{{{ Show the "sponsored by FOSSEE" slide }}}
This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
-
Hope you have enjoyed and found it useful.
Thank You.
@@ -376,9 +418,6 @@
Author : Amit Sethi
-
-Internal Reviewer 1 :
-
+Internal Reviewer 1 : Nishanth
Internal Reviewer 2 :
-
External Reviewer
--- a/liststart.rst Wed Sep 22 22:11:00 2010 +0530
+++ b/liststart.rst Wed Sep 22 23:09:28 2010 +0530
@@ -1,64 +1,68 @@
+.. #[Nishanth]: liststart is not a good name. there is no consistency.
+ Use underscores or hyphens instead of spaces and
+ make the filename from LO name
+ Ex: getting_started_with_lists (or)
+ getting_started_lists
+
Hello friends and welcome to the tutorial on getting started with
-lists
+lists.
{{{ Show the slide containing title }}}
{{{ 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
-Deleting elements from lists
+structure called lists. We will learn :
+ * How to create lists
+ * Structure of lists
+ * Access list elements
+ * Append elements to lists
+ * Deleting elements from lists
-I hope you have ipython running on your system .
-
+.. #[Nishanth]: Did you compile this??
+ There must an empty before the bulleted list
+I hope you have ipython running on your system.
+.. #[Nishanth]: need not specify. Implicit that IPython is running
-List is a compound data type,it can contain data of other data
-types.List is also a sequence data type , all the elements are in
-order and there order has a meaning .
+List is a compound data type, it can contain data of other data
+types. List is also a sequence data type, all the elements are in
+order and there order has a meaning.
-
-
-
-We will first create an empty list with no elements . On your ipython
+We will first create an empty list with no elements. On your IPython
shell type ::
- In []: empty = [] In []: type(empty)
+ empty = []
+ type(empty)
- <type 'list'>
-This is an empty list without any elements .
+This is an empty list without any elements.
-* filled lists
+* Filled lists
-Lets now define a list nonempty and fill it with some random elements.
+Lets now define a list, nonempty and fill it with some random elements.
-nonempty = ['spam','eggs', 100, 1.234]
+nonempty = ['spam', 'eggs', 100, 1.234]
Thus the simplest way of creating a list is typing out a sequence
of comma-separated values (items) between square brackets.
-List items need not all have the same data type.
-
+All the list items need not have the same data type.
-As you can see lists can contain different kinds of data . In the
-previous example 'spam' and 'eggs' are strings and 100 and 1.234
-integer and float . Thus you can put elements of heterogenous types in
-lists. Thus list themselves can be one of the element types possible
-in lists. Thus lists can also contain other lists in it . Example ::
+.. #[Nishanth]: do not use "You" or anything else. Stick to "We"
- list_in_list=[[4,2,3,4],'and', 1,2,3,4]
-
+As we can see lists can contain different kinds of data. In the
+previous example 'spam' and 'eggs' are strings and 100 and 1.234
+integer and float. Thus we can put elements of heterogenous types in
+lists. Thus list themselves can be one of the element types possible
+in lists. Thus lists can also contain other lists. Example ::
-We access list elements using the number of index . The
-index begins from 0 . So for list, nonempty , nonempty[0] gives the
-first element , nonempty[1] the second element and so on and
-nonempty[3] the last element .::
+ list_in_list=[[4,2,3,4],'and', 1, 2, 3, 4]
+We access list elements using the number of index. The
+index begins from 0. So for 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]
@@ -71,55 +75,76 @@
nonempty[-4]
-1 being the last element , -2 second to last and -4 being the first
- element .
+element.
+
+.. #[Nishanth]: -1 being last element sounds like -1 is the last element
+ Instead say -1 gives the last element which is 4
-* =append= elements We can append elements to the end of a list using
-append command .::
+.. #[Nishanth]: Instead of saying -4 being the first, say -4 gives 4th
+ from the last which is the first element.
+
+* =append= elements
+We can append elements to the end of a list using append command. ::
nonempty.append('onemore')
nonempty.append(6)
nonempty
-As you can see non empty appends 'onemore' and 6 at the end
+As we can see non empty appends 'onemore' and 6 at the end.
+
+.. #[Nishanth]: First show an example with only one append.
+ may be show the value of a after first append
+ then show what happens after second append
Using len function we can check the number of elements in the list
-nonempty .Because we just appended two elements at the end this
+nonempty. Because we just appended two elements at the end this
returns us 6.::
len(nonempty)
-Just like you can append elements to a list you can also remove them .
-Their are two ways of doing one is by index no. ::
+.. #[Nishanth]: the "because ..." can be removed. You can simply
+ say len gives the no.of elements which is 6 here
+
+Just like we can append elements to a list we can also remove them.
+There are two ways of doing. One is by using index. ::
del(nonempty[1])
-deletes the element at index no.1 , i.e the second element of the
+.. #[Nishanth]: do not use "You" or anything else. Stick to We
+
+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
-shall be :: a.remove(100)
+should be ::
+
+ a.remove(100)
-but what if their were two 100 's . To check that lets do a small
-experiment . ::
+but what if their were two 100's. To check that lets do a small
+experiment. ::
a.append('spam')
a
a.remove('spam')
a
-If we check a now we will see that the first element spam is remove
-thus remove removes only the first instance of the element by sequence
-and leaves others untouched .
+If we check a now we will see that the first occurence 'spam' is removed
+thus remove removes the first occurence of the element in the sequence
+and leaves others untouched.
{{{Slide for Summary }}}
-In this tutorial we came across a sequence data type called lists
-We learned how to create lists .
-Append elements to list .
-Delete Element from list.
-And Checking list length.
+In this tutorial we came across a sequence data type called lists. ::
+ * We learned how to create lists.
+ * Append elements to list.
+ * Delete Element from list.
+ * And Checking list length.
+
+.. #[Nishanth]: See the diff. I have corrected punctuation in many places.
+ The first thing you do before committing is compile the script.
+ I have corrected syntax errors also in many places.
{{{ Sponsored by Fossee Slide }}}
@@ -131,4 +156,5 @@
Author : Amit Sethi
-First Reviewer :
+First Reviewer :
+Second Reviewer : Nishanth
--- a/multiple-plots.rst Wed Sep 22 22:11:00 2010 +0530
+++ b/multiple-plots.rst Wed Sep 22 23:09:28 2010 +0530
@@ -6,9 +6,11 @@
In this tutorial, we will learn how to draw more than one plot, how to
add legends to each plot to indicate what each plot represents. We
-will also learn how to switch between the plots and creating multiple
+will also learn how to switch between the plots and create multiple
plots with different regular axes which are also called as subplots.
+.. #[Nishanth]: See diff - edited a grammatical mistake
+
{{{ Shift to terminal and start ipython -pylab }}}
To begin with let us start ipython with pylab, by typing::
@@ -25,6 +27,11 @@
linspace command creates 10 points in the interval between 0 and 50
both inclusive. We assign these values to a variable called x.
+.. #[Nishanth]: pre requisite for this LO is basic plotting which
+ covers linspace and plot. So you may not need to
+ specify all that again. But not a problem if it is
+ there also.
+
Now let us draw a plot simple sine plot using these points::
plot(x, sin(x))
@@ -34,9 +41,11 @@
{{{ Switch to the plot window }}}
Oh! wait! Is that a nice sine plot? Does a sine plot actually look
-like that? We know that a sine plot is a smooth curve is it not? What
+like that? We know that a sine plot is a smooth curve. Is it not? What
really caused this?
+.. #[Nishanth]: See diff
+
{{{ pause for a while }}}
A small investigation on linspace tells us that we chose too few
@@ -44,6 +53,11 @@
smooth. So now let us use linspace again to get 500 points between 0
and 100 and draw the sine plot
+.. #[Nishanth]: Here specify that when we do plot(x, sin(x)
+ it is actually plotting two sets of points
+ and not analytical functions. Hence the sharp
+ curve.
+
{{{ Switch to ipython andtype }}} ::
y = linspace(0, 50, 500)
@@ -78,6 +92,14 @@
Now we have two plots, a sine plot and a cosine plot one overlaid upon
the other.
+.. #[Nishanth]: figure(1) and figure(2) give two different plots.
+ The remaining script moves on the fact that they
+ give overlaid plots which is not the case.
+ So clear the figure and plot cos and sin without
+ introducing figure command. Then introduce legend
+ and finish off the everything on legend.
+ Then introduce figure command.
+
{{{ Have both plot window and ipython side by side }}}
The figure command takes an integer as an argument which is the serial
@@ -107,6 +129,9 @@
legend(['sin(x)', 'cos(x)'])
+.. #[Nishanth]: This legend may go up in the script. May be before
+ introducing the figure command itself.
+
The legend command takes a single list of parameters where each
parameter is the text indicating the plots in the order of their
serial number.
@@ -172,8 +197,15 @@
100 and y-axis varies from 0 to 1 where as for the parabolic plot the
x-axis varies from 0 to 10 and y-axis varies from 0 to 100
+.. #[Nishanth]: stress on the similarity between subplot and figure commands
+
{{{ Show summary slide }}}
+.. #[Nishanth]: Exercises are missing in the script
+ one exercise for overlaid plot and legend
+ one for figure command
+ one for subplot must do
+
This brings us to the end of another session. In this tutorial session
we learnt
@@ -184,6 +216,8 @@
* the legend command and
* creating and switching between subplots
+.. #[Nishanth]: legend command can be told right after overlaid plots
+
{{{ Show the "sponsored by FOSSEE" slide }}}
This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
@@ -193,6 +227,6 @@
.. Author : Madhu
Internal Reviewer 1 : [potential reviewer: Puneeth]
- Internal Reviewer 2 : [potential reviewer: Nishanth]
+ Internal Reviewer 2 : Nishanth
External Reviewer :
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/outline_and_allocations.rst Wed Sep 22 23:09:28 2010 +0530
@@ -0,0 +1,491 @@
+1 Module 1: Basic Plotting (16)
+================================
+
+1.1 ABCD
+---------
+* Audience
+ + same
+* Behaviour
+ - should be able to generate plots with any combination of built-in
+ mathematical functions provided by pylab
+* Condition
+ - being learnt in a self-study tutorial.
+ - have python setup in their machine
+* Degree
+ - RBT - Ap
+
+
+1.2 LO: getting started with =ipython= (2) [punch]
+---------------------------------------------------
+* Objective
+ Participants will be able to invoke and use basic features of ipython.
+* ABCD
+ + Condition
+ - have =python= & =ipython= setup in their machine. no mention of =pylab=
+* Assessment Strategy
+ Built-in interspersed exercises
+ - workbook
+ + errors, make connection with error message
+* Outline
+ + invoking ipython
+ if there's a problem, pre-requisites are not met.
+ + getting out
+ + explain the prompt
+ + typing commands
+ - 1+2
+ * careful wording to differentiate from print
+ - print 1+2
+ - history (up, down arrows)
+ - backspace, delete key
+ - tab completion
+ * ab
+ * a
+ * rou
+ * ro
+ * r
+ + =abs?=, =round?=
+ + handling typing errors
+ - round(2.48,
+ + close it
+ + use ^C
+
+1.3 LO: using the =plot= command interactively (2) [amit]
+----------------------------------------------------------
+* Outline
+ + ipython -pylab
+ - pylab brings in the libraries necessary for Scientific Computing.
+ + =linspace=,
+ + =len=
+ + =clf=
+ + =plot=
+ + using the plot ui
+
+1.4 LO: embellishing a plot (2) [nishanth]
+-------------------------------------------
+* Outline
+ + [X]line width, color, style
+ + [X]Title
+ + [X]Label
+ + [X]annotations
+
+1.5 LO: saving plots (2) [anoop]
+---------------------------------
+* Outline
+ + basic savefig
+ + png, pdf, ps, eps, svg
+ + going to OS and looking at the file
+
+1.6 LO: multiple plots (3) [madhu]
+-----------------------------------
+* Outline
+ + overlays
+ - linspace
+ * give one with very few points, more points
+ * show smoothness of the curve
+ + legend
+ + figure 1, figure2
+ + subplots
+
+1.7 LO: additional features of IPython (2) [nishanth]
+------------------------------------------------------
+* Outline
+ + =%save=, =%history=, =%run=
+
+1.8 LO: module level assessment (3) [madhu]
+--------------------------------------------
+* 10-12 question, time the questions
+* pause & and play when ready to look at answers
+* show the answers
+* one large or two medium questions
+* ex: four_plot
+
+
+2 Module 2: Plotting Experimental Data (12)
+============================================
+
+2.1 ABCD
+---------
+* Audience
+ + same
+* Behaviour
+ - should be able to generate plots with numeric data from files.
+* Condition
+ - being learnt in a self-study tutorial.
+ - have python setup in their machine
+* Degree
+ - Same
+
+2.2 LO: loading data from files (3) [punch]
+--------------------------------------------
+* loadtxt with unpack=True
+ + primes.list (one col)
+ + pendulum.txt (two col)
+
+2.3 LO: plotting the data (3) [amit]
+-------------------------------------
+* plot L vs. T^2
+ + using square function
+* problem with 3 cols
+ + 3rd column is error
+ + error bar
+
+2.4 LO: other types of plots (3) [anoop]
+-----------------------------------------
+* scatter
+* pie chart
+* bar chart
+* log
+* illustration of other plots, matplotlib help
+
+2.5 LO: module level assessment (3) [nishanth]
+-----------------------------------------------
+* pos.txt is evaluation
+
+
+3 Module 3: Handling Large Data Files (17)
+===========================================
+
+3.1 LO: getting started with lists (2) [amit]
+----------------------------------------------
+* empty
+* filled lists
+ + heterogenity
+* accessing
+* len
+* =append= elements
+* del (+ remove)
+
+3.2 LO: getting started with =for= (2) [anoop]
+-----------------------------------------------
+* blocks in python
+ + (indentation)
+* blocks in ipython
+ + ... prompt
+ + hitting enter
+* =for= with a list
+* =range= function
+
+3.3 LO: getting started with strings (2) [madhu]
+-------------------------------------------------
+* strings
+ + single, double, triple quoted
+* accessing elements
+* show immutability
+* tell that there are methods for manipulation
+
+3.4 LO: getting started with files (3) [punch]
+-----------------------------------------------
+* show file object
+* read the file with =read=
+* closing the file
+* for line in file:
+* print a line
+* append the lines to a list
+
+3.5 LO: parsing data (3) [nishanth]
+------------------------------------
+* explain what is parsing
+* strip (with strings)
+* split (with strings)
+ + with delimiters
+ - specify space as delimiter
+* datatype conversion
+* reading from files
+ + do the same problem done with loadtxt (for pendulum)
+ + basic parse sslc text
+
+3.6 LO: statistics (2) [amit]
+------------------------------
+* mean
+ + summing
+* median
+* std
+
+3.7 LO: module level assessment (3) [madhu]
+--------------------------------------------
+* mean g
+
+
+4 Module 4: Arrays and Matrices (14)
+=====================================
+
+4.1 LO: getting started with arrays (2) [anoop]
+------------------------------------------------
+* why arrays
+ + speed - simply say
+ + array level operations
+* creating arrays
+ + direct data
+ + list conversion
+ + homogeneous
+ + builtins - identitiy, zeros,
+* array operations
+ + =+ - * /=
+
+4.2 LO: accessing parts of arrays (4) [punch]
+----------------------------------------------
+* accessing individual elements
+* slicing, striding
+* image manipulation
+
+4.3 LO: Matrices (3) [anoop]
+-----------------------------
+* creating matrices
+ + direct data
+ + list conversion
+ + builtins - identitiy, zeros,
+* matrix operations
+ + + - * /
+ + dot
+ + inv
+ + det
+ + eig
+ + norm
+ + svd
+
+4.4 LO: Least square fit (2) [nishanth]
+----------------------------------------
+* show pendulum
+ + use loadtxt
+* lstsq
+
+4.5 LO: Assessment (3) [punch]
+-------------------------------
+* extract faces from a group photograph
+
+5 Module 5: using Sage (13)
+============================
+
+5.1 LO: getting started with sage notebook (3) [madhu]
+-------------------------------------------------------
+* about sage
+ + ...
+* starting the notebook server
+* using the UI
+ + typesetting & print
+ + selecting language
+ - sage
+ - LaTeX
+ - python
+ + help
+ - sum(<tab>
+ - ?
+
+5.2 LO: getting started with symbolics (3) [amit]
+--------------------------------------------------
+* symbolic expressions
+ + built-in constants & functions
+ + algebraic expressions,
+ + series
+ + integration, differentiation
+ + matrices
+* symbolic functions
+ + defining
+* simplification
+* finding roots & factors
+* substituting expressions
+* output formats
+
+5.3 LO: using Sage (4) [punch]
+-------------------------------
+* ABCD
+ + Degree
+ - RBT - U
+* Calculus
+ + limits
+ + differentiation
+ + integration
+ - indefinite
+ - definite
+ + piece-wise functions
+ + differential equations
+ + maxima, minima
+* Linear Algebra
+ + Vectors and Matrices
+ - constructions
+ + Vector Operations
+ - linear combination
+ - dot
+ - cross
+ - pairwise
+ + Matrix Operations
+ - linear combination
+ - matrix multiplication
+ - inverse
+ - transpose
+ - adjoint
+ - rank
+ - determinant
+ - trace
+ - norm
+ + Solving equations
+ + Eigenvalues, eigenvectors
+* Graph Theory
+* Number Theory
+
+5.4 LO: using sage to teach (3) [nishanth]
+-------------------------------------------
+* @interact
+* 2D, 3D graphics
+* Graph Theory
+* Share, Publish
+* print
+
+5.5 LO: Assessment (3) [anoop]
+-------------------------------
+* 5 questions
+* choice of exercises from one area
+
+6 Module 6: Python Language: Basics (12)
+=======================================
+
+6.1 LO: basic datatypes & operators (4) [amit]
+----------------------------------------------
+* int
+ + L, long
+* float
+ + repr, str
+* complex
+ + methods like imag, real
+* boolean
+ + short circuit logic
+* conversion functions
+* sequence datatypes & mutability
+ + list available sequence datatypes
+ - string
+ - list
+ - tuple
+ + mutability
+ + conversion
+ + common stuff
+ - len
+ - in
+ - max, min, sum, sorted, reversed
+ - accessing individual elements
+ - slicing, striding
+ - containership
+
+6.2 LO: I/O (1) [nishanth]
+--------------------------
+* print statement
+* raw_input
+
+6.3 LO: conditionals (2) [Madhu]
+--------------------------------
+* if, elif, else
+* pass
+* ternary operator
+
+6.4 LO: loops (2) [punch]
+-------------------------
+* while
+* for
+* pass, break, continue
+
+6.5 LO: Assessment (3) [Anoop]
+------------------------------
+* 10 Questions
+* One of collatz or armstrong numbers
+
+
+7 Module 7: Python Language: Datastructures (14)
+================================================
+
+7.1 LO: manipulating lists (3) [Madhu]
+--------------------------------------
+* concatenation
+* slicing
+* striding
+* .sort
+* sorted
+* .reverse
+* reversed
+
+7.2 LO: manipulating strings (2) [punch]
+----------------------------------------
+* upper, lower,
+* replace
+* slicing
+* [::-1]
+* reversed
+* palindrome check
+
+7.3 LO: getting started with tuples (2) [nishanth]
+--------------------------------------------------
+* immutability
+* tuple packing, unpacking
+ + a, b = b, a
+* accessing individual elements
+* slicing, striding
+
+7.4 LO: dictionaries (2) [anoop]
+--------------------------------
+* empty
+* filled
+* accessing via keys
+* .values(), .keys()
+* in
+* iteration
+
+7.5 LO: sets (2) [nishanth]
+---------------------------
+* Operations
+ + Union
+ + Intersection
+ + Complement
+ + Symmetric Difference
+* Containership
+* Subset
+* len
+
+7.6 LO: Assessment (3) [amit]
+-----------------------------
+* 10 Questions
+* Anagrams for sets and dictionaries
+* A problem for lists and strings
+
+8 Module 8: Python Language: Advanced (16)
+==========================================
+
+8.1 LO: getting started with functions (3) [nishanth]
+-----------------------------------------------------
+* defining function
+* arguments
+* docstrings
+* return values
+ + can return multiple values
+* code reading exercises
+
+8.2 LO: advanced features of functions (3) [punch]
+--------------------------------------------------
+* default arguments
+* keyword arguments
+* built-in functions show off
+
+8.3 LO: using python modules (3) [anoop]
+----------------------------------------
+* executing python scripts from command line
+* import
+* scipy
+* pylab
+* sys
+* STDLIB modules show off
+
+8.4 LO: writing python scripts (2) [nishanth]
+----------------------------------------------
+* importing our own modules
+* if __name__ == '__main__'
+
+8.5 LO: testing and debugging (2) [amit]
+----------------------------------------
+* Types of errors and exceptions
+* Strategy for debugging
+ + Using print
+
+8.6 LO: Assessment (3) [punch]
+------------------------------
+* 10 Questions
+* Find four digit numbers whose digits are all even
+* Write a script to use methods from pylab (like plot, show and other commands) and execute it as a stand-alone script
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/progress.org Wed Sep 22 23:09:28 2010 +0530
@@ -0,0 +1,55 @@
+| S.No | Name | Units | Author | 1st Review (Status) | 2nd Review (Status) |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 1.2 LO: | getting started with =ipython= | 2 | Punch | | |
+| 1.3 LO: | using the =plot= command interactively | 2 | Amit | Anoop (Pending) | Puneeth (Pending) |
+| 1.4 LO: | embellishing a plot | 2 | Nishanth | Anoop (Done) | Madhu (Done) |
+| 1.5 LO: | saving plots | 2 | Anoop | | |
+| 1.6 LO: | multiple plots | 3 | Madhu | Nishanth (Done) | Punch (Pending) |
+| 1.7 LO: | additional features of IPython | 2 | Nishanth | Amit (Pending) | Madhu (Pending) |
+| 1.8 LO: | module level assessment | 3 | Madhu | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 2.2 LO: | loading data from files | 3 | Punch | | |
+| 2.3 LO: | plotting the data | 3 | Amit | Anoop (Pending) | Punch (Pending) |
+| 2.4 LO: | other types of plots | 3 | Anoop | | |
+| 2.5 LO: | module level assessment | 3 | Nishanth | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 3.1 LO: | getting started with lists | 2 | Amit | Madhu (Pending) | Nishanth (Done) |
+| 3.2 LO: | getting started with =for= | 2 | Anoop | | |
+| 3.3 LO: | getting started with strings | 2 | Madhu | | |
+| 3.4 LO: | getting started with files | 3 | Punch | | |
+| 3.5 LO: | parsing data | 3 | Nishanth | Amit (Pending) | Punch (Pending) |
+| 3.6 LO: | statistics | 2 | Amit | Anoop (Pending) | Puneeth (Pending) |
+| 3.7 LO: | module level assessment | 3 | Madhu | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 4.1 LO: | getting started with arrays | 2 | Anoop | | |
+| 4.2 LO: | accessing parts of arrays | 4 | Punch | | |
+| 4.3 LO: | Matrices | 3 | Anoop | | |
+| 4.4 LO: | Least square fit | 2 | Nishanth | Punch (Pending) | Anoop (Pending) |
+| 4.5 LO: | Assessment | 3 | Punch | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 5.1 LO: | getting started with sage notebook | 3 | Madhu | | |
+| 5.2 LO: | getting started with symbolics | 3 | Amit | Madhu (Pending) | Nishanth (Pending) |
+| 5.3 LO: | using Sage | 4 | Punch | | |
+| 5.4 LO: | using sage to teach | 3 | Nishanth | | |
+| 5.5 LO: | Assessment | 3 | Anoop | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 6.1 LO: | basic datatypes & operators | 4 | Amit | Madhu (Pending) | Nishanth (Done) |
+| 6.2 LO: | I/O | 1 | Nishanth | | |
+| 6.3 LO: | conditionals | 2 | Madhu | | |
+| 6.4 LO: | loops | 2 | Puneeth | | |
+| 6.5 LO: | Assessment | 3 | Anoop | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 7.1 LO: | manipulating lists | 3 | Madhu | | |
+| 7.2 LO: | manipulating strings | 2 | Punch | | |
+| 7.3 LO: | getting started with tuples | 2 | Nishanth | | |
+| 7.4 LO: | dictionaries | 2 | Anoop | | |
+| 7.5 LO: | sets | 2 | Nishanth | | |
+| 7.6 LO: | Assessment | 3 | Amit | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|
+| 8.1 LO: | getting started with functions | 3 | Nishanth | | |
+| 8.2 LO: | advanced features of functions | 3 | Punch | | |
+| 8.3 LO: | using python modules | 3 | Anoop | | |
+| 8.4 LO: | writing python scripts | 2 | Nishanth | | |
+| 8.5 LO: | testing and debugging | 2 | Amit | | |
+| 8.6 LO: | Assessment | 3 | Madhu | | |
+|---------+----------------------------------------+-------+----------+---------------------+---------------------|