.. 4.1 LO: getting started with arrays (2) [anoop] 

.. ------------------------------------------------

.. * why arrays 

..   + speed - simply say 

..   + array level operations 

.. * creating arrays 

..   + direct data 

..   + list conversion 

..   + homogeneous 

..   + builtins - identitiy, zeros, 

.. * array operations 

..   + =+ - * /= 

===========================

Getting started with Arrays

===========================

{{{ show the welcome slide }}}

Welcome to the spoken tutorial on getting started with arrays.

{{{ switch to next slide, outline slide }}}

In this tutorial, we will learn about arrays, how to convert a list

into an array and also why an array is preferred over lists. And array

operations.

{{{ switch to next slide on overview of array }}}

Arrays are homogeneous data structures, unlike lists, arrays cannot

have heterogeneous data elements, that is, it can have only one type

of data type, either all integers, or strings, or float, and not a

mix.

Arrays are really fast in mathematical operations when compared to

lists, it is at least 80 to 100 times faster than lists.

{{{ switch to the next slide, creating arrays }}}

Now let us see how to create arrays.

I am assuming that you have your IPython interpreter running with the

``-pylab`` option, so that you have the required modules loaded.

To create an array we will use the function ``array()`` as,

::

    a1 = array([1,2,3,4])

Notice that here we created a one dimensional array. Also notice the

object we passed to create an array. Now let us see how to create a

two dimensional array. Pause here and try to do it yourself before

looking at the solution.

This is how we create two dimensional arrays.

::

    a2 = array([[1,2,3,4],[5,6,7,8]])

Let us see an easy method of creating an array with elements 1 to 8.

::

    ar = arange(1,9)

And it created a single dimensional array of elements from 1 to 8.

::

    print ar

And how can we make it a two dimensional array of order 2 by 4. Pause

here and try to do it yourself, try ``ar.tab`` and find a suitable

method for that.

We can use the function ``reshape()`` for that purpose and it can be

done as,

::

    ar.reshape(2,4)

    ar.reshape(4,2)

    ar = ar.reshape(2,4)

Now, let us see how to convert a list object to an array. As you have

already seen, in both of the previous statements we have passed a

list, so creating an array can be done so, first let us create a list

``l1``

::

    l1 = [1,2,3,4]

Now we can convert the list to an array as,

::

    a3 = array(l1)

{{{ switch to the next slide, problem statement of unsolved exercise 1 }}}

Create a three dimensional array of the order (2,2,4).

{{{ switch to the next slide, shape of an array }}}

To find the shape of an array we can use the object ``.shape``, let us

check the shape of the arrays we have created so far,

::

    a1.shape

``a1.shape`` object is a tuple, and since a1 is a single dimensional

array, it returned a tuple (4,).

{{{ switch to the next slide, unsolved exercise 2 }}}

Find out the shape of the other two arrays that we have created.

{{{ Array can have only a single type of data }}}

Now let us try to create a new array with a mix of elements and see

what will happen,

::

    a4 = array([1,2,3,'a string'])

Well, we expected an error as previously I said that an array can have

only homogeneous elements, but it didn't give an error. Let us check

the values in the new array created. In your IPython terminal type,

::

    a4

Did you notice it, 

{{{ highlight all the array elements one by one using mouse 

movements }}}

all the elements have been implicitly type casted as string, though

our first three elements were integers.

{{{ switch to the next slide, identity & zeros methods }}}

An identity matrix is a square matrix in which all the diagonal

elements are one and rest of the elements zero. We can create an

identity matrix using the method ``identity()``.

The function ``identity()`` takes an integer argument,

::

    identity(3)

As you can see the identity method returned a three by three square

array with all the diagonal elements as one and the rest of the

elements as zero.

``zeros()`` function accepts a tuple, which is the order of the array

we want to create, and it generates an array with all elements zero.

{{{ switch to the next slide, problem statement of the solved exercise

1 }}}

Let us creates an array of the order four by five with all the

elements zero. We can do it using the method zeros,

::

    zeros((4,5))

Notice that we passed a tuple to the function zeros.

{{{ switch to next slide, learning exercise }}}

We learned two functions ``identity()`` and ``zeros()``, find out more

about the functions ``zeros_like()``, ``ones()``, ``ones_like()``.

{{{ switch to next slide, array operations }}}

Try the following, first check the value of a1,

::

    a1

``a1`` is a single dimensional array, and now try,

::

    a1 * 2

It returned a new array with all the elements multiplied by 2.

::

    a1

note that the value of a1 still remains the same.

Similarly with addition,

::

    a1 + 2

it returns a new array, with all the elements summed with two. But

again notice that the value of a1 has not been changed.

::

    a1

You may change the value of a1 by simply assigning the newly returned

array as,

::

    a1 += 2

Notice the change in elements of a,

::

    a

We can use all the mathematical operations with arrays, Now let us try

this

::

   a1 = array([1,2,3,4])

   a2 = array([1,2,3,4])

   a1 + a2

Returns an array with element by element addition,

::

    a1 * a2

Returns an array with element by element multiplication, notice that

it does not perform matrix multiplication.

{{{ switch to next slide, recap slide }}}

So this brings us to the end of this tutorial, in this tutorial we

covered basics of arrays, how to create an array, converting a list to

an array, basic array operations etc.

{{{ switch to next slide, thank you }}}

Thank you!

..  Author: Anoop Jacob Thomas <anoop@fossee.in>

    Reviewer 1:

    Reviewer 2:

    External reviewer: