st-scripts: comparison basicdatatype.rst

equal deleted inserted replaced

-:db9617c1d01f
+:6b1efb74d914
 * 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.
+There are three built-in data types 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:
 * Boolean
 Lets first talk about integers. ::
 a = 13
+a
-.. #[Nishanth]: give a space before and after the = sign
 Thats it, there we have our first integer variable a.
-.. #[Nishanth]: Show the value of a
 If we now see ::
 type(a)
 <type 'int'>
 in python means that there are various functions that this variable
 has to manipulate it different ways. You can explore these by doing,
 a.<Tab>
-.. #[Nishanth]: a.<Tab> is not a good idea for int or float
 Lets see the limits of this int.
 b = 99999999999999999999
 b
 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. 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 ::
+The last data type in the list is complex number ::
 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
+imaginary part being define by j notation instead of i. Complex numbers have a lot of functions specific to them.
-engineering. Complex numbers have a lot of functions specific to them.
 Lets check these ::
 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 ::
 c.real
 c.imag
 note that T in true is capitalized.
 You can apply different Boolean operations on t now for example ::
 f = not t
-In[]: f
+f
-In[]: f or t
+f or t
-In[]: f and t
+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 are explanotary in themselves.
-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.
 To check how precedence changes with parenthesis. We will try two
 expressions and their evaluation.
 one ::
-In[]: (a and b) or c
+(a and b) or c
 This expression gives the value True
 where as the expression ::
-In[]: a and (b or c)
+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
 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]
+num_list = [1, 2, 3, 4]
+num_list
-.. #[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.
 We can have a list something like ::
-In[]: var = [1, 1.2, [1,2]]
+var_list = [1, 1.2, [1,2]]
+var_list
-.. #[Nishanth]: Show the value of the variable
-print var
 Now we will have a look at strings
 type ::
-In[]: w="hello"
+In[]: greeting_string="hello"
-.. #[Nishanth]: Show the value of the variable
-w is now a string variable with the value "hello"
+greeting_string is now a string variable with the value "hello"
 {{{ Memory Aid Slide }}}
 Python strings can actually be defined in three different ways ::
 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)
+In[]: num_tuple = (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_list[2]
-In[]: num[-1]
+In[]: num_list[-1]
-In[]: w[1]
+In[]: greeting_string[1]
-In[]: w[3]
+In[]: greeting_string[3]
-In[]: w[-2]
+In[]: greeting_string[-2]
-In[]: t[2]
+In[]: num_tuple[2]
-In[]: t[-3]
+In[]: num_tuple[-3]
-Negative indices can be used to access in reverse
+Indexing starts from 0 from left to right and from -1 when accessing
-.. #[Nishanth]: Elaborate on indexing.
+lists in reverse. Thus num_list[2] refers to the third element 3.
-Indexing starts from 0 when moving from left to right
+and greetings [-2] is the second element from the end , that is 'l'.
-Indexing starts from -1 when moving from right to left
 Addition gives a new sequence containing both sequences ::
-In[]: num+var
+In[]: num_list+var_list
-In[]: p="another string"
+In[]: a_string="another string"
-In[]: w+p
+In[]: greeting_string+a_string
 In[]: t2=(3,4,6,7)
-In[]: t+t2
+In[]: num_tuple+t2
 len function gives the length  ::
-In[]: len(num)
+In[]: len(num_list)
-In[]: len(w)
+In[]: len(greeting_string)
-In[]: len(t)
+In[]: len(num_tuple)
 Prints the length the variable.
 We can check the containership of an element using the 'in' keyword ::
-In[]: 3 in num
+In[]: 3 in num_list
-In[]: 'H' in w
+In[]: 'H' in greeting_string
-In[]: 2 in t
+In[]: 2 in num_tuple
 We see that it gives True and False accordingly.
 Find maximum using max function and minimum using min::
-In[]: max(t)
+In[]: max(num_tuple)
-In[]: min(w)
+In[]: min(greeting_string)
 Get a sorted list and reversed list using sorted and reversed function ::
-In[]: sorted(num)
+In[]: sorted(num_list)
-In[]: reversed(w)
+In[]: reversed(greeting_string)
 As a consequence of the order one we access a group of elements together.
 This is called slicing and striding.
 First Slicing
 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.The last element however is notincluded in the resultant list::
-.. #[nishanth]: specify that the last element is not included
 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.
 Striding is similar to slicing except that the step size here is not one.
 Lets see by example ::
-In[]: z=[1,2,3,4,5,6,7,8,9,10]
+new_num_list=[1,2,3,4,5,6,7,8,9,10]
-In[]: z[1:8:2]
+new_num_list[1:8:2]
-Out[]:[2, 4, 6, 8]
+[2, 4, 6, 8]
 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 important
 features in lists that differ from strings and tuples. Lets see this by example.::
-In[]: z[1]=9
+In[]: new_num_list[1]=9
-In[]: w[1]='k'
+In[]: greeting_string[1]='k'
 {{{ 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
+In[]: new_tuple[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:
 We can convert all the number data types to one another ::
-In[]: i=34
+i=34
-In[]: d=float(i)
+d=float(i)
+d
 Python has built in functions int, float and complex to convert one number type
 data structure to another.
-In[]: dec=2.34
+dec=2.34
-In[]: dec_con=int(dec)
+dec_con=int(dec)
+dec_con
-.. #[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
+com=2.3+4.2j
-In[]: float(com)
+float(com)
+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]
+lst=[3,4,5,6]
-In[]: tup=tuple(lst)
+tup=tuple(lst)
-In[]: tupl=(3,23,4,56)
+tupl=(3,23,4,56)
-In[]: lst=list(tuple)
+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()
-.. #[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.
 In: otherstring="Tim,Amy,Stewy,Boss"

changeset 201	6b1efb74d914
parent 186	488f05b1fbcc