st-scripts: comparison basic-data-type/script.rst

equal deleted inserted replaced

-:a28d592851b4
+:a77a27916f81
 .. Objectives
 .. ----------
-.. Learn about Python Data Structures and Operators.(Remembering)
+.. At the end of this tutorial, you should know --
-.. Use them to do basic operations.(Applying)
+.. 1. Learn about Python Data Structures and Operators.(Remembering)
+.. #.Use them to do basic operations.(Applying)
 .. Prerequisites
 .. -------------
+.. None
 .. Author              : Amit Sethi
 Internal Reviewer   :
 External Reviewer   :
 Checklist OK?       : <put date stamp here, if OK> [2010-10-05]
 Now we will have a look at strings
 type ::
-In[]: greeting_string="hello"
+greeting_string="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 ::
-In[]: k='Single quote'
+k='Single quote'
-In[]: l="Double quote contain's single quote"
+l="Double quote contain's single quote"
-In[]: m='''"Contain's both"'''
+m='''"Contain's both"'''
 .. #[Puneeth: Contain's? That's not a word!]
 Thus, single quotes are used as delimiters usually.
 The last in the list of sequence data types is tuple.
 To create a tuple we use normal brackets '(' unlike '[' for lists.::
-In[]: num_tuple = (1, 2, 3, 4, 5, 6, 7, 8)
+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.
 The first one is accessing.
 They can be accessed using index numbers ::
-In[]: num_list[2]
+num_list[2]
-In[]: num_list[-1]
+num_list[-1]
-In[]: greeting_string[1]
+greeting_string[1]
-In[]: greeting_string[3]
+greeting_string[3]
-In[]: greeting_string[-2]
+greeting_string[-2]
-In[]: num_tuple[2]
+num_tuple[2]
-In[]: num_tuple[-3]
+num_tuple[-3]
 Indexing starts from 0 from left to right and from -1 when accessing lists
 in reverse. Thus num_list[2] refers to the third element 3. and greetings
 [-2] is the second element from the end , that is 'l'.
 Addition gives a new sequence containing both sequences ::
-In[]: num_list+var_list
+num_list+var_list
-In[]: a_string="another string"
+a_string="another string"
-In[]: greeting_string+a_string
+greeting_string+a_string
-In[]: t2=(3,4,6,7)
+t2=(3,4,6,7)
-In[]: num_tuple+t2
+num_tuple+t2
 len function gives the length ::
-In[]: len(num_list)
+len(num_list)
-In[]: len(greeting_string)
+len(greeting_string)
-In[]: len(num_tuple)
+len(num_tuple)
 Prints the length the variable.
 We can check the containership of an element using the 'in' keyword ::
-In[]: 3 in num_list
+3 in num_list
-In[]: 'H' in greeting_string
+'H' in greeting_string
-In[]: 2 in num_tuple
+2 in num_tuple
 We see that it gives True and False accordingly.
 Find maximum using max function and minimum using min::
-In[]: max(num_tuple)
+max(num_tuple)
-In[]: min(greeting_string)
+min(greeting_string)
 Get a sorted list and reversed list using sorted and reversed function ::
-In[]: sorted(num_list)
+sorted(num_list)
-In[]: reversed(greeting_string)
+reversed(greeting_string)
 As a consequence of the order one we access a group of elements together.
 This is called slicing and striding.
 .. #[Puneeth: Fix the sentence above. ]
 First Slicing
 Given a list ::
-In[]:j=[1,2,3,4,5,6]
+j=[1,2,3,4,5,6]
 Lets say we want elements starting from 2 and ending in 5.
 For this we can do ::
-In[]: j[1:4]
+j[1:4]
 The syntax for slicing is, sequence variable name square bracket first
 element index, colon, second element index. The last element however is not
 included in the resultant list::
-In[]: j[:4]
+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:]
+j[1:]
-In[]: j[:]
+j[:]
 This effectively is the whole list.
 Striding is similar to slicing except that the step size here is not one.
 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[]: new_num_list[1]=9
+new_num_list[1]=9
-In[]: greeting_string[1]='k'
+greeting_string[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[]: new_tuple[1]=5
+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: otherstring.split(',')
 join function does the opposite. Joins a list to make a string.::
-In[]:','.join['List','joined','on','commas']
+','.join['List','joined','on','commas']
 Thus we get a list joined on commas. Similarly we can do spaces.::
-In[]:' '.join['Now','on','spaces']
+' '.join['Now','on','spaces']
 Note that the list has to be a list of strings to apply join operation.
 With this we come to the end of this tutorial .

changeset 362	a77a27916f81
parent 337	c65d0d9fc0c8
child 364	91d16630c90f