# HG changeset patch
# User amit
# Date 1285133031 -19800
# Node ID c1242f073db39d8b22cb83b6e3dcd0a9f1ac4acc
# Parent  ce0ff610e2791247a523769963f2fe57157f90e4
Initial commit basic data types

diff -r ce0ff610e279 -r c1242f073db3 basicdatatype.rst
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/basicdatatype.rst	Wed Sep 22 10:53:51 2010 +0530
@@ -0,0 +1,384 @@
+Hello friends and welcome to the tutorial on Basic Data types and
+operators in Python.  
+{{{ Show the slide containing title }}}
+
+{{{ Show the slide containing the outline slide }}}
+
+
+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. 
+
+
+First we will explore python data structures in the domain of numbers.
+There are three built-in data structures in python to represent numbers.
+
+{{{ A slide to make a memory note of this }}}
+
+These are:
+
+  * Integers 
+  * Complex and 
+  * Boolean 
+
+
+
+Lets first talk about integers. ::
+
+   In[]: a=13
+
+
+Thats it , there we have our first integer variable a.
+
+If we now see ::
+     
+   In[]: type(a)
+   Out[]: <type 'int'>
+
+   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>
+
+
+Lets see the limits of this int.
+
+  In[]: b=99999999999999999999
+  In[]: 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 '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 
+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
+
+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
+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
+
+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>
+
+Lets try some of them ::
+
+  In[]: c.real
+  In[]: 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)
+
+
+Python also has Boolean as a built-in type.
+
+Try it out just type ::  
+
+  In[]: t=True
+
+note that T in true is capitalized.
+  
+You can apply different Boolean operations on t now for example ::
+
+  In[]: f=not t 
+  In[]: f
+  In[]: f or t
+  In[]: f and t 
+  
+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 ,
+
+Lets write some piece of code to check this out.
+
+  In[]: a=False 
+  In[]: b=True 
+  In[]: c=True
+
+To check how precedence changes with parenthesis. We will try two
+expressions and their evaluation.
+
+one ::
+ 
+  In[]: (a and b) or c
+ 
+This expression gives the value True
+
+where as the expression :: 
+  
+  In[]: a and (b or c) 
+
+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. 
+
+{{{ 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]
+
+Items enclosed in square brackets separated by comma 
+constitutes a list.
+
+Lists  can store data of any type in them. 
+
+We can have a list something like ::
+ In[]: var = [1, 1.2, [1,2]]	
+print var
+
+Now we will have a look at strings 
+
+type :: 
+
+ In[]: w="hello"
+
+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.
+
+The last in the list of sequence data types is tuple.
+
+To create a tuple  we use normal brackets '('
+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. 
+
+{{{ Slide for memory aid }}}
+
+The first one is accessing.
+
+They can be accessed using index numbers ::
+
+  In[]: num[2]
+  In[]: num[-1]
+  In[]: w[1]
+  In[]: w[3]
+  In[]: w[-2]
+  In[]: t[2]
+  In[]: t[-3]
+
+Negative indices can be used to access in reverse
+
+Addition gives a new sequence containing both sequences ::
+
+     In[]: num+var
+     In[]: p="another string"
+     In[]: w+p
+     In[]: t2=(3,4,6,7)
+     In[]: t+t2
+
+len function gives the length  ::
+
+  In[]: len(num)
+  In[]: len(w)
+  In[]: len(t)
+
+We can check whether an element is there with 'in' keyword ::
+
+  In[]: 3 in num
+  In[]: 'H' in w
+  In[]: 2 in t
+
+Find maximum using max function  and minimum using min:: 
+
+  In[]: max(t)
+  In[]: min(w)
+
+Get a sorted list and reversed list using sorted and reversed function ::
+
+  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 
+
+First Slicing 
+
+Given a list ::
+
+  In[]:j=[1,2,3,4,5,6]
+
+Lets say we want elements 2 to 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.
+
+  In[]: j[:4]
+
+If first element is left blank default is from beginning and if last
+element is left blank it means till the end.
+
+ In[]: j[1:]
+
+ In[]: j[:]
+
+This effectively is the whole list.
+
+Striding is a concept similar to slicing with the concept of skiping elements
+at regular intervals added.
+
+Lets see by example ::
+
+  In[]: z=[1,2,3,4,5,6,7,8,9,10]
+  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
+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.::
+
+  In[]: z[1]=9
+  In[]: w[1]='k'
+
+
+{{{ slide to show the error }}}
+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. 
+
+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:
+
+We can convert all the number data types to one another ::
+
+  In[]: i=34
+  In[]: d=float(i)
+
+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.::
+
+  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.
+
+Similarly we can convert list to tuple and tuple to list ::
+  
+  In[]: lst=[3,4,5,6]
+  In[]: tup=tuple(lst)
+  In[]: tupl=(3,23,4,56)
+  In[]: lst=list(tuple)
+
+However string to list and list to string is an interesting problem.
+Lets say we have a string ::
+
+  In: somestring="Is there a way to split on these spaces."
+  In: somestring.split()
+
+This produces a list with the string split at whitespace.
+similarly we can split on some other character.
+
+  In: otherstring="Tim,Amy,Stewy,Boss"
+
+How do we split on comma , simply pass it as argument ::
+
+  In: otherstring.split(',')
+
+join function does the opposite. Joins a list to make a string.::
+
+  In[]:','.join['List','joined','on','commas']
+
+Thus we get a list joined on commas. Similarly we can do spaces.::
+
+  In[]:' '.join['Now','on','spaces']
+
+Note that the list has to be a list of strings to apply join operation.
+
+{{{ 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.
+
+
+
+Author              : Amit Sethi
+
+Internal Reviewer 1 : 
+
+Internal Reviewer 2 : 
+
+External Reviewer