Notebook for class 4¶

This is the notebook I was typing into in class 4, with some notes.

First we explored different data types.

In [1]:

my_float = 1.0

In [2]:

my_float

Out[2]:

1.0

We can see what type of thing a variable refers to with the type function. We will see more of functions later.

In [3]:

type(my_float)

Out[3]:

float

Notice the lack of a decimal point in the following statement.

In [4]:

my_other_thing = 1

This gives us an int:

In [5]:

my_other_thing

Out[5]:

In [6]:

type(my_other_thing)

Out[6]:

int

We are about to make a string. Here I am trying to make the string "I love Python", but I get an error - why?

In [7]:

my_string = I love python

  File "<ipython-input-7-273633364422>", line 1
    my_string = I love python
                     ^
SyntaxError: invalid syntax

It looked there was a problem with the spaces, so I replace the spaces with underscores:

In [8]:

my_string = I_love_python

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-8-0f708e6c0151> in <module>
----> 1 my_string = I_love_python

NameError: name 'I_love_python' is not defined

Now it becomes clear that Python thought that I was trying to refer to a variable name that does not exist.

Here's a string - it needs quotes:

In [9]:

my_string = "I love python"

In [10]:

my_string

Out[10]:

'I love python'

In [11]:

type(my_string)

Out[11]:

str

Notice that Python displays strings with quotes, by default (at least in the Notebook):

In [12]:

'I love python'

Out[12]:

'I love python'

If you use the print function, it does not add the quotes.

In [13]:

print(my_string)

I love python

Here I go through the class exercise:

In [14]:

a = 1.0
b = 1
c = 'Hello'

Here I add a float to itself:

In [15]:

a + a

Out[15]:

2.0

The addition produces a float:

In [16]:

type(a + a)

Out[16]:

float

Adding two ints gives an int:

In [17]:

b + b

Out[17]:

Adding two strings concatenates the strings:

In [18]:

c + c

Out[18]:

'HelloHello'

Adding a float to an int gives a float:

In [19]:

a + b

Out[19]:

2.0

Python won't let you add floats (or ints) to a string:

In [20]:

a + c

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-20-e81e582b6fa9> in <module>
----> 1 a + c

TypeError: unsupported operand type(s) for +: 'float' and 'str'

Remember assignment - a name, followed by =, followed by an expression:

In [21]:

a = 1

It sets the value of a (in this case):

In [22]:

Out[22]:

Here is a comparison expression. < is a comparison operator, and returns the result of the comparison less than.

In [23]:

a < 10

Out[23]:

True

Here we look at the value returned from this expression:

In [24]:

my_logical = a < 10

In [25]:

my_logical

Out[25]:

True

It's a bool type (Boolean).

In [26]:

type(my_logical)

Out[26]:

bool

Booleans can be either True or False:

In [27]:

a > 10

Out[27]:

False

Remember assignment (again). It has the single = between the name (on the left) and the expression (on the right).

In [28]:

a = 1

Here is something very different - an equality comparison operator. This is two equals signs: ==. It's an expression. It tests whether the thing on the left is equal to the thing on the right, returning True or False.

In [29]:

a == 1

Out[29]:

True

Now we consider call expressions.

In [30]:

a = 2 / 3

In [31]:

Out[31]:

0.6666666666666666

Here we call the function round, with the argument a - the number we want it to round.

In [32]:

round(a)

Out[32]:

We can pass round two arguments. The second argument is the number of decimal points we want it to round to.

In [33]:

round(a, 2)

Out[33]:

0.67

We can also give this argument a name. In that case, it is called a keyword argument.

In [34]:

round(a, ndigits=2)

Out[34]:

0.67

To find what the names of the arguments are, look at the help:

In [35]:

round?

We have to get the name of the argument right, otherwise Python complains.

In [36]:

round(a, number_of_digits=2)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-36-c89cc06512a3> in <module>
----> 1 round(a, number_of_digits=2)

TypeError: 'number_of_digits' is an invalid keyword argument for this function

Check the names, from the help:

In [37]:

round?

Now we get on to arrays.

In [38]:

import numpy as np

Here I am calling a function with no arguments. It's a call expression, but in this case, the function needs no arguments. It returns a single random number:

In [39]:

np.random.uniform()

Out[39]:

0.7558424036608197

Once we have checked the help, we find there is a size argument, that we can specify. This allows us to ask for 100 random numbers.

In [40]:

np.random.uniform(size=100)

Out[40]:

array([ 0.36693208,  0.87758662,  0.81019582,  0.82214536,  0.36394251,
        0.07969345,  0.35343822,  0.97806641,  0.9532617 ,  0.59773898,
        0.58081863,  0.62741994,  0.95847418,  0.03567867,  0.05212555,
        0.71711456,  0.17662301,  0.11707422,  0.41300096,  0.06000016,
        0.7726217 ,  0.43842319,  0.14607717,  0.01461987,  0.45210905,
        0.11072198,  0.82793531,  0.01498911,  0.30554031,  0.24935128,
        0.15916459,  0.54524344,  0.03558632,  0.48099707,  0.43274497,
        0.82487948,  0.3796686 ,  0.60998452,  0.28689629,  0.59365581,
        0.31763947,  0.92812618,  0.44717822,  0.05692277,  0.97550456,
        0.76643058,  0.19427462,  0.65746642,  0.02530174,  0.42710621,
        0.16244242,  0.41119599,  0.16460324,  0.03615299,  0.5873492 ,
        0.04265181,  0.09245906,  0.56257469,  0.64322541,  0.62147685,
        0.75644138,  0.27570146,  0.11715281,  0.48179549,  0.44877749,
        0.88395977,  0.33036868,  0.19958962,  0.37841863,  0.58654954,
        0.87654479,  0.86413769,  0.3123292 ,  0.20707659,  0.24201805,
        0.74959689,  0.06625441,  0.02026559,  0.97464529,  0.63600724,
        0.06385651,  0.34978269,  0.37378996,  0.06817189,  0.67991121,
        0.17659475,  0.19225224,  0.30393928,  0.32401367,  0.57006609,
        0.36204343,  0.1393311 ,  0.03584481,  0.93263328,  0.73635803,
        0.92246816,  0.72562353,  0.00144158,  0.80831398,  0.05020239])

Here I put these into a variable:

In [41]:

randoms = np.random.uniform(size=100)

It's a new type - array:

In [42]:

type(randoms)

Out[42]:

numpy.ndarray

One of the things that arrays have, is a length. We can get that with the len function:

In [43]:

len(randoms)

Out[43]:

In [44]:

randoms

Out[44]:

array([ 0.99759455,  0.18332171,  0.48756725,  0.26591066,  0.15436288,
        0.95128538,  0.66077124,  0.55775149,  0.03508935,  0.5412619 ,
        0.64847867,  0.34489874,  0.69598301,  0.06871524,  0.25808015,
        0.58960472,  0.72211686,  0.27325624,  0.67260077,  0.83995721,
        0.79970784,  0.95336243,  0.964208  ,  0.83936253,  0.05656299,
        0.90039992,  0.1338113 ,  0.13691248,  0.14159298,  0.34965063,
        0.61237528,  0.16934558,  0.96038391,  0.42721043,  0.98938284,
        0.95646816,  0.18415332,  0.81226052,  0.73249926,  0.30732336,
        0.87148763,  0.81042182,  0.73458396,  0.00581783,  0.96601248,
        0.21221345,  0.92395521,  0.54040162,  0.52355445,  0.02329994,
        0.50524813,  0.00135702,  0.44433152,  0.55002481,  0.63741974,
        0.95615915,  0.49641958,  0.67045131,  0.21201677,  0.86107248,
        0.8180656 ,  0.17918569,  0.51762375,  0.7829002 ,  0.83993162,
        0.75212422,  0.86351651,  0.71620174,  0.16334626,  0.12899758,
        0.41677654,  0.72401677,  0.72959161,  0.37035538,  0.65291767,
        0.6762217 ,  0.10313215,  0.5606955 ,  0.03125565,  0.26660795,
        0.23112951,  0.59380057,  0.67975397,  0.25033702,  0.83819111,
        0.38698292,  0.86193146,  0.90357501,  0.61546889,  0.36227131,
        0.75510565,  0.54165405,  0.96419388,  0.65234739,  0.61019126,
        0.4283649 ,  0.08000637,  0.56819196,  0.86529496,  0.0179533 ])

Here we do a comparison on a single random number:

In [45]:

a_random = np.random.uniform()
a_random

Out[45]:

0.12583938290027896

For our simulation, we want to check whether the random number is less than 0.26. If so, we label this as a black juror.

In [46]:

a_random < 0.26

Out[46]:

True

We want to do this 100 times. We can do this with arrays, in one shot:

In [47]:

black_yn = randoms < 0.26
black_yn

Out[47]:

array([False,  True, False, False,  True, False, False, False,  True,
       False, False, False, False,  True,  True, False, False, False,
       False, False, False, False, False, False,  True, False,  True,
        True,  True, False, False,  True, False, False, False, False,
        True, False, False, False, False, False, False,  True, False,
        True, False, False, False,  True, False,  True, False, False,
       False, False, False, False,  True, False, False,  True, False,
       False, False, False, False, False,  True,  True, False, False,
       False, False, False, False,  True, False,  True, False,  True,
       False, False,  True, False, False, False, False, False, False,
       False, False, False, False, False, False,  True, False, False,  True], dtype=bool)

Now we can use the np.count_nonzero function to count how many True values there are. This is our first simulation of a jury pool, of 100 jurors.

In [48]:

np.count_nonzero(black_yn)

Out[48]: