basicdatatype.rst
author Nishanth <nishanth@fossee.in>
Thu, 07 Oct 2010 14:15:30 +0530
changeset 233 ab748264f726
parent 201 6b1efb74d914
permissions -rw-r--r--
Made sets.rst into the new template form
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     1
Hello friends and welcome to the tutorial on Basic Data types and
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     2
operators in Python.  
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     3
{{{ Show the slide containing title }}}
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     4
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     5
{{{ Show the slide containing the outline slide }}}
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     6
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
     7
In this tutorial, we shall look at::
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     8
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
     9
 * Various Datatypes in Python
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    10
 * Operators with a little hands-on on how they can be applied to 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    11
   the different data types.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    12
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
    13
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    14
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    15
First we will explore python data structures in the domain of numbers.
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
    16
There are three built-in data types in python to represent numbers.
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    17
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    18
{{{ A slide to make a memory note of this }}}
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    19
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    20
These are:
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    21
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    22
  * Integers 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    23
  * Complex and 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    24
  * Boolean 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    25
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    26
Lets first talk about integers. ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    27
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    28
   a = 13
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
    29
   a
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    30
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    31
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    32
Thats it, there we have our first integer variable a.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    33
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
    34
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    35
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    36
If we now see ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    37
     
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    38
   type(a)
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    39
   <type 'int'>
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    40
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    41
This means that a is a type of int. Being an int data structure 
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    42
in python means that there are various functions that this variable
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    43
has to manipulate it different ways. You can explore these by doing,
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    44
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    45
  a.<Tab>
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    46
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
    47
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    48
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    49
Lets see the limits of this int.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    50
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    51
  b = 99999999999999999999
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    52
  b
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    53
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    54
As you can see even when we put a value of 9 repeated 20 times 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    55
python did not complain. However when you asked python to print
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    56
the number again it put a capital L at the end. Now if you check
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    57
the type of this variable b, ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    58
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    59
  type(b)
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    60
  <type 'long'>
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    61
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    62
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    63
The reason for this is that python recognizes large integer numbers
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    64
by the data type long. However long type and integer type share there 
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    65
functions and properties.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    66
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    67
Lets now try out the second type in list called float.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    68
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    69
Decimal numbers in python are recognized by the term float ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    70
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    71
  p = 3.141592
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    72
  p
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    73
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    74
If you notice the value of output of p isn't exactly equal to p. This
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    75
is because computer saves floating point values in a specific
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    76
format. There is always an aproximationation. This is why we should
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    77
never rely on equality of floating point numbers in a program.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    78
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
    79
The last data type in the list is complex number ::
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    80
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    81
  c = 3.2+4.6j
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    82
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    83
as simple as that so essentialy its just a combination of two floats the 
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
    84
imaginary part being define by j notation instead of i. Complex numbers have a lot of functions specific to them.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    85
Lets check these ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    86
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    87
  c.<Tab>
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    88
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    89
Lets try some of them ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    90
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    91
  c.real
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    92
  c.imag
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    93
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    94
c.real gives the real part of the number and c.imag the imaginary.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    95
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    96
We can get the absolute value using the function ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    97
 
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
    98
  abs(c)
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
    99
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   100
Python also has Boolean as a built-in type.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   101
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   102
Try it out just type ::  
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   103
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   104
  t = True
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   105
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   106
note that T in true is capitalized.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   107
  
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   108
You can apply different Boolean operations on t now for example ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   109
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   110
  f = not t 
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   111
  f
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   112
  f or t
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   113
  f and t 
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   114
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   115
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   116
  
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   117
The results are explanotary in themselves.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   118
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   119
The usage of boolean brings us to an interesting question of precendence.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   120
What if you want to apply one operator before another. 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   121
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   122
Well you can use parenthesis for precedence.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   123
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   124
Lets write some piece of code to check this out.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   125
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   126
  In[]: a=False 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   127
  In[]: b=True 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   128
  In[]: c=True
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   129
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   130
To check how precedence changes with parenthesis. We will try two
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   131
expressions and their evaluation.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   132
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   133
one ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   134
 
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   135
  (a and b) or c
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   136
 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   137
This expression gives the value True
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   138
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   139
where as the expression :: 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   140
  
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   141
  a and (b or c) 
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   142
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   143
gives the value False.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   144
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   145
Lets now discuss sequence data structures in python. Sequence 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   146
datatypes are those in which elements are kept in a sequential 
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   147
order. All the elements accessed using index. 
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   148
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   149
{{{ slide to for memory aid }}}
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   150
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   151
The sequence datatypes in python are ::
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   152
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   153
 * list
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   154
 * string
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   155
 * tuple
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   156
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   157
The list type is a container that holds a number of other 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   158
objects, in the given order.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   159
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   160
We create our first list by typing :: 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   161
  
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   162
  num_list = [1, 2, 3, 4]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   163
  num_list
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   164
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   165
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   166
Items enclosed in square brackets separated by comma 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   167
constitutes a list.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   168
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   169
Lists can store data of any type in them. 
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   170
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   171
We can have a list something like ::
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   172
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   173
 var_list = [1, 1.2, [1,2]]	
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   174
 var_list
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   175
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   176
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   177
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   178
Now we will have a look at strings 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   179
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   180
type :: 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   181
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   182
 In[]: greeting_string="hello"
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   183
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   184
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   185
greeting_string is now a string variable with the value "hello"
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   186
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   187
{{{ Memory Aid Slide }}}
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   188
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   189
Python strings can actually be defined in three different ways ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   190
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   191
  In[]: k='Single quote'
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   192
  In[]: l="Double quote contain's single quote"
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   193
  In[]: m='''"Contain's both"'''
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   194
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   195
Thus, single quotes are used as delimiters usually.
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   196
When a string contains a single quote, double quotes are used as delimiters.
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   197
When a string quote contains both single and double quotes, triple quotes are
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   198
used as delimiters.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   199
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   200
The last in the list of sequence data types is tuple.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   201
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   202
To create a tuple  we use normal brackets '('
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   203
unlike '[' for lists.::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   204
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   205
  In[]: num_tuple = (1, 2, 3, 4, 5, 6, 7, 8)
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   206
  
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   207
Because of their sequential property there are certain functions and 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   208
operations we can apply to all of them. 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   209
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   210
{{{ Slide for memory aid }}}
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   211
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   212
The first one is accessing.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   213
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   214
They can be accessed using index numbers ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   215
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   216
  In[]: num_list[2]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   217
  In[]: num_list[-1]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   218
  In[]: greeting_string[1]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   219
  In[]: greeting_string[3]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   220
  In[]: greeting_string[-2]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   221
  In[]: num_tuple[2]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   222
  In[]: num_tuple[-3]
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   223
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   224
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   225
Indexing starts from 0 from left to right and from -1 when accessing
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   226
lists in reverse. Thus num_list[2] refers to the third element 3. 
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   227
and greetings [-2] is the second element from the end , that is 'l'. 
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   228
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   229
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   230
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   231
Addition gives a new sequence containing both sequences ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   232
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   233
     In[]: num_list+var_list
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   234
     In[]: a_string="another string"
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   235
     In[]: greeting_string+a_string
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   236
     In[]: t2=(3,4,6,7)
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   237
     In[]: num_tuple+t2
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   238
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   239
len function gives the length  ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   240
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   241
  In[]: len(num_list)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   242
  In[]: len(greeting_string)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   243
  In[]: len(num_tuple)
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   244
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   245
Prints the length the variable.
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   246
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   247
We can check the containership of an element using the 'in' keyword ::
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   248
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   249
  In[]: 3 in num_list
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   250
  In[]: 'H' in greeting_string
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   251
  In[]: 2 in num_tuple
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   252
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   253
We see that it gives True and False accordingly.
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   254
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   255
Find maximum using max function and minimum using min:: 
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   256
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   257
  In[]: max(num_tuple)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   258
  In[]: min(greeting_string)
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   259
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   260
Get a sorted list and reversed list using sorted and reversed function ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   261
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   262
  In[]: sorted(num_list)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   263
  In[]: reversed(greeting_string)
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   264
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   265
As a consequence of the order one we access a group of elements together.
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   266
This is called slicing and striding.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   267
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   268
First Slicing 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   269
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   270
Given a list ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   271
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   272
  In[]:j=[1,2,3,4,5,6]
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   273
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   274
Lets say we want elements starting from 2 and ending in 5.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   275
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   276
For this we can do ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   277
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   278
  In[]: j[1:4]
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   279
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   280
The syntax for slicing is sequence variable name square bracket
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   281
first element index, colon, second element index.The last element however is notincluded in the resultant list::
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   282
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   283
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   284
  In[]: j[:4]
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   285
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   286
If first element is left blank default is from beginning and if last
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   287
element is left blank it means till the end.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   288
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   289
 In[]: j[1:]
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   290
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   291
 In[]: j[:]
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   292
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   293
This effectively is the whole list.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   294
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   295
Striding is similar to slicing except that the step size here is not one.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   296
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   297
Lets see by example ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   298
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   299
  new_num_list=[1,2,3,4,5,6,7,8,9,10]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   300
  new_num_list[1:8:2]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   301
  [2, 4, 6, 8]
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   302
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   303
The colon two added in the end signifies all the alternate elements. This is why we call this concept
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   304
striding because we move through the list with a particular stride or step. The step in this example
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   305
being 2. 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   306
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   307
We have talked about many similar features of lists, strings and tuples. But there are many important
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   308
features in lists that differ from strings and tuples. Lets see this by example.::
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   309
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   310
  In[]: new_num_list[1]=9
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   311
  In[]: greeting_string[1]='k'
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   312
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   313
{{{ slide to show the error }}}
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   314
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   315
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   316
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   317
As you can see while the first command executes with out a problem there is an error on the second one.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   318
  
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   319
Now lets try ::
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   320
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   321
  In[]: new_tuple[1]=5
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   322
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   323
Its the same error. This is because strings and tuples share the property of being immutable.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   324
We cannot change the value at a particular index just by assigning a new value at that position.
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   325
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   326
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   327
We have looked at different types but we need to convert one data type into another. Well lets one
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   328
by one go through methods by which we can convert one data type to other:
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   329
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   330
We can convert all the number data types to one another ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   331
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   332
  i=34
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   333
  d=float(i)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   334
  d  
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   335
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   336
Python has built in functions int, float and complex to convert one number type
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   337
data structure to another.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   338
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   339
  dec=2.34
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   340
  dec_con=int(dec)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   341
  dec_con
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   342
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   343
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   344
As you can see the decimal part of the number is simply stripped to get the integer.::
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   345
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   346
  com=2.3+4.2j
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   347
  float(com)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   348
  com
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   349
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   350
In case of complex number to floating point only the real value of complex number is taken.
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   351
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   352
Similarly we can convert list to tuple and tuple to list ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   353
  
201
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   354
  lst=[3,4,5,6]
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   355
  tup=tuple(lst)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   356
  tupl=(3,23,4,56)
6b1efb74d914 Applied the suggestion of Nishanth on getting started with lists and basicdatatypes(Partially)
amit
parents: 186
diff changeset
   357
  lst=list(tuple)
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   358
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   359
However string to list and list to string is an interesting problem.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   360
Lets say we have a string ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   361
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   362
  In: somestring="Is there a way to split on these spaces."
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   363
  In: somestring.split()
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   364
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   365
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   366
This produces a list with the string split at whitespace.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   367
similarly we can split on some other character.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   368
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   369
  In: otherstring="Tim,Amy,Stewy,Boss"
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   370
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   371
How do we split on comma , simply pass it as argument ::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   372
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   373
  In: otherstring.split(',')
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   374
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   375
join function does the opposite. Joins a list to make a string.::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   376
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   377
  In[]:','.join['List','joined','on','commas']
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   378
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   379
Thus we get a list joined on commas. Similarly we can do spaces.::
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   380
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   381
  In[]:' '.join['Now','on','spaces']
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   382
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   383
Note that the list has to be a list of strings to apply join operation.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   384
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   385
.. #[Nishanth]: string to list is fine. But list to string can be left for
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   386
                string manipulations. Just say it requires some string 
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   387
                manipulations and leave it there.
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   388
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   389
.. #[Nishanth]: Where is the summary
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   390
                There are no exercises in the script
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   391
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   392
{{{ Show the "sponsored by FOSSEE" slide }}}
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   393
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   394
This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   395
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   396
Hope you have enjoyed and found it useful.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   397
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   398
Thank You.
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   399
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   400
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   401
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   402
Author              : Amit Sethi
186
488f05b1fbcc reviewed basic_data_types_
Nishanth <nishanth@fossee.in>
parents: 176
diff changeset
   403
Internal Reviewer 1 : Nishanth
176
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   404
Internal Reviewer 2 : 
c1242f073db3 Initial commit basic data types
amit
parents:
diff changeset
   405
External Reviewer