1 Hello friends and welcome to the tutorial on Basic Data types and

     2 operators in Python.  

     3 {{{ Show the slide containing title }}}

     4 

     5 {{{ Show the slide containing the outline slide }}}

     6 

     7 In this tutorial, we shall look at::

     8 

     9  * Various Datatypes in Python

    10  * Operators with a little hands-on on how they can be applied to 

    11    the different data types.

    12 

    13 

    14 

    15 First we will explore python data structures in the domain of numbers.

    16 There are three built-in data types in python to represent numbers.

    17 

    18 {{{ A slide to make a memory note of this }}}

    19 

    20 These are:

    21 

    22   * Integers 

    23   * Complex and 

    24   * Boolean 

    25 

    26 Lets first talk about integers. ::

    27 

    28    a = 13

    29    a

    30 

    31 

    32 Thats it, there we have our first integer variable a.

    33 

    34 

    35 

    36 If we now see ::

    37      

    38    type(a)

    39    <type 'int'>

    40 

    41 This means that a is a type of int. Being an int data structure 

    42 in python means that there are various functions that this variable

    43 has to manipulate it different ways. You can explore these by doing,

    44 

    45   a.<Tab>

    46 

    47 

    48 

    49 Lets see the limits of this int.

    50 

    51   b = 99999999999999999999

    52   b

    53 

    54 As you can see even when we put a value of 9 repeated 20 times 

    55 python did not complain. However when you asked python to print

    56 the number again it put a capital L at the end. Now if you check

    57 the type of this variable b, ::

    58 

    59   type(b)

    60   <type 'long'>

    61 

    62 

    63 The reason for this is that python recognizes large integer numbers

    64 by the data type long. However long type and integer type share there 

    65 functions and properties.

    66 

    67 Lets now try out the second type in list called float.

    68 

    69 Decimal numbers in python are recognized by the term float ::

    70 

    71   p = 3.141592

    72   p

    73 

    74 If you notice the value of output of p isn't exactly equal to p. This

    75 is because computer saves floating point values in a specific

    76 format. There is always an aproximationation. This is why we should

    77 never rely on equality of floating point numbers in a program.

    78 

    79 The last data type in the list is complex number ::

    80 

    81   c = 3.2+4.6j

    82 

    83 as simple as that so essentialy its just a combination of two floats the 

    84 imaginary part being define by j notation instead of i. Complex numbers have a lot of functions specific to them.

    85 Lets check these ::

    86 

    87   c.<Tab>

    88 

    89 Lets try some of them ::

    90 

    91   c.real

    92   c.imag

    93 

    94 c.real gives the real part of the number and c.imag the imaginary.

    95 

    96 We can get the absolute value using the function ::

    97  

    98   abs(c)

    99 

   100 Python also has Boolean as a built-in type.

   101 

   102 Try it out just type ::  

   103 

   104   t = True

   105 

   106 note that T in true is capitalized.

   107   

   108 You can apply different Boolean operations on t now for example ::

   109 

   110   f = not t 

   111   f

   112   f or t

   113   f and t 

   114 

   115 

   116   

   117 The results are explanotary in themselves.

   118 

   119 The usage of boolean brings us to an interesting question of precendence.

   120 What if you want to apply one operator before another. 

   121 

   122 Well you can use parenthesis for precedence.

   123 

   124 Lets write some piece of code to check this out.

   125 

   126   In[]: a=False 

   127   In[]: b=True 

   128   In[]: c=True

   129 

   130 To check how precedence changes with parenthesis. We will try two

   131 expressions and their evaluation.

   132 

   133 one ::

   134  

   135   (a and b) or c

   136  

   137 This expression gives the value True

   138 

   139 where as the expression :: 

   140   

   141   a and (b or c) 

   142 

   143 gives the value False.

   144 

   145 Lets now discuss sequence data structures in python. Sequence 

   146 datatypes are those in which elements are kept in a sequential 

   147 order. All the elements accessed using index. 

   148 

   149 {{{ slide to for memory aid }}}

   150 

   151 The sequence datatypes in python are ::

   152 

   153  * list

   154  * string

   155  * tuple

   156 

   157 The list type is a container that holds a number of other 

   158 objects, in the given order.

   159 

   160 We create our first list by typing :: 

   161   

   162   num_list = [1, 2, 3, 4]

   163   num_list

   164 

   165 

   166 Items enclosed in square brackets separated by comma 

   167 constitutes a list.

   168 

   169 Lists can store data of any type in them. 

   170 

   171 We can have a list something like ::

   172 

   173  var_list = [1, 1.2, [1,2]]	

   174  var_list

   175 

   176 

   177 

   178 Now we will have a look at strings 

   179 

   180 type :: 

   181 

   182  In[]: greeting_string="hello"

   183 

   184 

   185 greeting_string is now a string variable with the value "hello"

   186 

   187 {{{ Memory Aid Slide }}}

   188 

   189 Python strings can actually be defined in three different ways ::

   190 

   191   In[]: k='Single quote'

   192   In[]: l="Double quote contain's single quote"

   193   In[]: m='''"Contain's both"'''

   194 

   195 Thus, single quotes are used as delimiters usually.

   196 When a string contains a single quote, double quotes are used as delimiters.

   197 When a string quote contains both single and double quotes, triple quotes are

   198 used as delimiters.

   199 

   200 The last in the list of sequence data types is tuple.

   201 

   202 To create a tuple  we use normal brackets '('

   203 unlike '[' for lists.::

   204 

   205   In[]: num_tuple = (1, 2, 3, 4, 5, 6, 7, 8)

   206   

   207 Because of their sequential property there are certain functions and 

   208 operations we can apply to all of them. 

   209 

   210 {{{ Slide for memory aid }}}

   211 

   212 The first one is accessing.

   213 

   214 They can be accessed using index numbers ::

   215 

   216   In[]: num_list[2]

   217   In[]: num_list[-1]

   218   In[]: greeting_string[1]

   219   In[]: greeting_string[3]

   220   In[]: greeting_string[-2]

   221   In[]: num_tuple[2]

   222   In[]: num_tuple[-3]

   223 

   224 

   225 Indexing starts from 0 from left to right and from -1 when accessing

   226 lists in reverse. Thus num_list[2] refers to the third element 3. 

   227 and greetings [-2] is the second element from the end , that is 'l'. 

   228 

   229 

   230 

   231 Addition gives a new sequence containing both sequences ::

   232 

   233      In[]: num_list+var_list

   234      In[]: a_string="another string"

   235      In[]: greeting_string+a_string

   236      In[]: t2=(3,4,6,7)

   237      In[]: num_tuple+t2

   238 

   239 len function gives the length  ::

   240 

   241   In[]: len(num_list)

   242   In[]: len(greeting_string)

   243   In[]: len(num_tuple)

   244 

   245 Prints the length the variable.

   246 

   247 We can check the containership of an element using the 'in' keyword ::

   248 

   249   In[]: 3 in num_list

   250   In[]: 'H' in greeting_string

   251   In[]: 2 in num_tuple

   252 

   253 We see that it gives True and False accordingly.

   254 

   255 Find maximum using max function and minimum using min:: 

   256 

   257   In[]: max(num_tuple)

   258   In[]: min(greeting_string)

   259 

   260 Get a sorted list and reversed list using sorted and reversed function ::

   261 

   262   In[]: sorted(num_list)

   263   In[]: reversed(greeting_string)

   264 

   265 As a consequence of the order one we access a group of elements together.

   266 This is called slicing and striding.

   267 

   268 First Slicing 

   269 

   270 Given a list ::

   271 

   272   In[]:j=[1,2,3,4,5,6]

   273 

   274 Lets say we want elements starting from 2 and ending in 5.

   275 

   276 For this we can do ::

   277 

   278   In[]: j[1:4]

   279 

   280 The syntax for slicing is sequence variable name square bracket

   281 first element index, colon, second element index.The last element however is notincluded in the resultant list::

   282 

   283 

   284   In[]: j[:4]

   285 

   286 If first element is left blank default is from beginning and if last

   287 element is left blank it means till the end.

   288 

   289  In[]: j[1:]

   290 

   291  In[]: j[:]

   292 

   293 This effectively is the whole list.

   294 

   295 Striding is similar to slicing except that the step size here is not one.

   296 

   297 Lets see by example ::

   298 

   299   new_num_list=[1,2,3,4,5,6,7,8,9,10]

   300   new_num_list[1:8:2]

   301   [2, 4, 6, 8]

   302 

   303 The colon two added in the end signifies all the alternate elements. This is why we call this concept

   304 striding because we move through the list with a particular stride or step. The step in this example

   305 being 2. 

   306 

   307 We have talked about many similar features of lists, strings and tuples. But there are many important

   308 features in lists that differ from strings and tuples. Lets see this by example.::

   309 

   310   In[]: new_num_list[1]=9

   311   In[]: greeting_string[1]='k'

   312 

   313 {{{ slide to show the error }}}

   314 

   315 

   316 

   317 As you can see while the first command executes with out a problem there is an error on the second one.

   318   

   319 Now lets try ::

   320 

   321   In[]: new_tuple[1]=5

   322 

   323 Its the same error. This is because strings and tuples share the property of being immutable.

   324 We cannot change the value at a particular index just by assigning a new value at that position.

   325 

   326 

   327 We have looked at different types but we need to convert one data type into another. Well lets one

   328 by one go through methods by which we can convert one data type to other:

   329 

   330 We can convert all the number data types to one another ::

   331 

   332   i=34

   333   d=float(i)

   334   d  

   335 

   336 Python has built in functions int, float and complex to convert one number type

   337 data structure to another.

   338 

   339   dec=2.34

   340   dec_con=int(dec)

   341   dec_con

   342 

   343 

   344 As you can see the decimal part of the number is simply stripped to get the integer.::

   345 

   346   com=2.3+4.2j

   347   float(com)

   348   com

   349 

   350 In case of complex number to floating point only the real value of complex number is taken.

   351 

   352 Similarly we can convert list to tuple and tuple to list ::

   353   

   354   lst=[3,4,5,6]

   355   tup=tuple(lst)

   356   tupl=(3,23,4,56)

   357   lst=list(tuple)

   358 

   359 However string to list and list to string is an interesting problem.

   360 Lets say we have a string ::

   361 

   362   In: somestring="Is there a way to split on these spaces."

   363   In: somestring.split()

   364 

   365 

   366 This produces a list with the string split at whitespace.

   367 similarly we can split on some other character.

   368 

   369   In: otherstring="Tim,Amy,Stewy,Boss"

   370 

   371 How do we split on comma , simply pass it as argument ::

   372 

   373   In: otherstring.split(',')

   374 

   375 join function does the opposite. Joins a list to make a string.::

   376 

   377   In[]:','.join['List','joined','on','commas']

   378 

   379 Thus we get a list joined on commas. Similarly we can do spaces.::

   380 

   381   In[]:' '.join['Now','on','spaces']

   382 

   383 Note that the list has to be a list of strings to apply join operation.

   384 

   385 .. #[Nishanth]: string to list is fine. But list to string can be left for

   386                 string manipulations. Just say it requires some string 

   387                 manipulations and leave it there.

   388 

   389 .. #[Nishanth]: Where is the summary

   390                 There are no exercises in the script

   391 

   392 {{{ Show the "sponsored by FOSSEE" slide }}}

   393 

   394 This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India

   395 

   396 Hope you have enjoyed and found it useful.

   397 

   398 Thank You.

   399 

   400 

   401 

   402 Author              : Amit Sethi

   403 Internal Reviewer 1 : Nishanth

   404 Internal Reviewer 2 : 

   405 External Reviewer