CS 237 Homework 01 — Data Display in Python

In this first homework, you will become familiar with various methods of displaying the results of probability

experiments graphically in Python using Jupyter notebooks and Matplotlib. This will be a fundamental way of

understand the results of experiments throughout the course. We will cover:

Basic introduction to Python and Jupyter Notebook.

Basic introduction to Matplotlib and graphing

Basic introduction to Monte Carlo (probability) simulation.

Please follow the HW Submission Instructions

(http://www.cs.bu.edu/fac/snyder/cs237/HWSubmissionInstructions.html); any homeworks not following these

requirements may be penalized.

Anaconda Distribution of Python

Download from https://www.continuum.io/downloads (https://www.continuum.io/downloads)

Make sure it’s Python 3!

Be sure to pick the correct Operating System (i.e., Windows, MAC OS, Linux)

Starting Jupyter

Open a Terminal Window

For MAC OS, open your Applications folder, then open the Utilities folder. Open the Terminal

application. (Or, type “terminal” into Spotlight.) You may want to add this to your dock.

For Windows, simply search for CMD and run the result

In the terminal run

This will bring you to the home page.

Click new and then click python3 to create a new Ipython3 notebook.

Alternatively, use the Anaconda Navigator that will be installed in your Applications folder.

jupyter notebook

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 2/35

Downloading the Assignments

From the class web page download HW01 as an IPYNB file (NOT a .txt file):

As soon as you download it, Run All the cells:

Normally, you select one or more cells and then start execution using Cell – Run Cells, but it is easier to

use the keyboard shortcut: Click inside the cell to select it, then type Control-Return.

Use the Kernel menu to kill a runaway piece of code, and if weird stuff is happening and you want to reset

everything, select Kernel – Restart and Run All:

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 3/35

In [1]: # Here are some imports which will be used in the code in the rest of

the lab

# Imports used for the code in CS 237

import numpy as np # arrays and functions which operat

e on array

import matplotlib.pyplot as plt # normal plotting

import seaborn as sns # Fancy plotting

import pandas as pd # Data input and manipulation

from numpy.random import seed, randint, random

from collections import Counter

%matplotlib inline

Plotting Points

The scatter(…) function is used to plot points from a list of x values and the associated y values.

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 4/35

In [2]: # To plot the points (1,2), (2,3), (3,6), (4,8) we would list the x v

alues and the corresponding y values:

X = [1,2,3,4]

Y = [2,3,6,8]

print(“\nThis is the list of points:”,list(zip(X,Y)))

print(“They must be input to the function as separate lists:”)

print(“\tX =”,X)

print(“\tY =”,Y,”\n”)

plt.scatter(X,Y)

plt.title(‘Graphing Points with scatter(X,Y)’)

plt.xlabel(“The X Values”)

plt.ylabel(“The Y Values”)

plt.show()

Plotting Lines and Curves

If you call plot(…) instead of scatter(…) you will display a curve created by connecting the points

with straight lines. Essentially you can only plot straight lines between points, but if the points are close together,

you will not notice, and it will look like a smooth curve.

This is the list of points: [(1, 2), (2, 3), (3, 6), (4, 8)]

They must be input to the function as separate lists:

X = [1, 2, 3, 4]

Y = [2, 3, 6, 8]

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 5/35

In [3]: # To plot a curve through the points (1,2), (2,3), (3,6), (4,8) we wo

uld use:

plt.plot([1,2,3,4], [2,3,6,8])

plt.title(‘A Sequence of Straight Lines’)

plt.xlabel(“The X Values”)

plt.ylabel(“The Y Values”)

plt.show()

X = np.linspace(1,20,100) # returns a list of 100 equallyspaced values in the range [1..20]

Y = [np.sin(x) for x in X]

plt.plot(X,Y)

plt.title(‘A Smooth-Looking Curve’)

plt.xlabel(“The X Values”)

plt.ylabel(“The Y Values”)

plt.show()

If you want to do both, you can simply call both functions before you call show().

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 6/35

In [4]: plt.scatter([1,2,3,4], [2,3,6,8])

plt.plot([1,2,3,4], [2,3,6,8])

plt.title(‘A Curve Through Some Points, Showing the Points’)

plt.xlabel(“The X Values”)

plt.ylabel(“The Y Values”)

plt.show()

If you want to draw a single line from to you can plot and

Here we have added a zero line to our sin curve:

(x1, y1) (x2, y2) [x1, x2] [y1, y2].

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 7/35

In [5]: X = np.linspace(1,20,100) # returns a list of 100 equallyspaced values in the range [1..20]

Y = [np.sin(x) for x in X]

plt.plot(X,Y)

plt.plot([0,20],[0,0])

plt.title(‘A Smooth-Looking Curve’)

plt.xlabel(“The X Values”)

plt.ylabel(“The Y Values”)

plt.show()

For further details on drawing plots, particularly on color and format, see the

Appendix at the end of this document

Problem Zero: Using the Numpy Random Library

We have imported a number of functions from the Numpy Random library, which you can read about here

(https://docs.scipy.org/doc/numpy/user/quickstart.html).

In [6]: # Run this cell several times and and see what happens

random()

Out[6]: 0.25437701508006305

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 8/35

In [7]: # Run this cell several times and and see what happens

# List comprehensions are your best friend, learn how to use them!!!

size = 10

rands = [ random() for k in range(size) ]

rands

In [8]: # Run this cell several times and and see what happens

# This produces a Numpy 1D vector, which is

# another way to store a sequence.

size = 5

random(size)

In [9]: # In most cases, arrays are interchangeable with lists, but if you ne

ed a Python

# list, just do this:

list(random(size))

In order to make grading easier, we will “seed” the random number generation so that it always produces the

same pseudo-random sequence. However, you should generally try running your code several times without the

seed, trying it on various random sequences.

Just be sure to include the seed before running your program to submit, so that the graders can see your correct

results.

In [10]: # Run this cell several times, and see what happens

# How is it different from the result in cell [210]?

seed(0)

random(5)

Out[7]: [0.8459421725471246,

0.8956782540437821,

0.587705032211821,

0.35378549433952533,

0.07456167058026497,

0.2864312207404033,

0.5830974374308513,

0.35410819800605386,

0.7460296596860136,

0.7850564361492659]

Out[8]: array([0.74799137, 0.72214408, 0.10288086, 0.01369631, 0.85348445])

Out[9]: [0.7669604344687095,

0.13193918476106503,

0.4256066530035917,

0.06568377219402044,

0.013844805563202]

Out[10]: array([0.5488135 , 0.71518937, 0.60276338, 0.54488318, 0.4236548 ])

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 9/35

Problem 1 (Plotting Points)

Part A

One of our standard examples in lecture will be a “spinner” which can be set in motion to randomly chose a real

number in the half-open interval [0..1):

We will simulate this using the Python function random() from the Numpy.random library we imported above.

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 10/35

In [11]: # Use numpy’s random() function to build a list of x_vals with th

e following properties:

# – x_vals list should have length num_trials

# – Each value in x_vals should be a random float in the ran

ge [0..1)

# Now plot the points (xi,0) along the x axis in the diagram belo

w

def random_line_plot(num_trials):

x_vals = [ [ random() for k in range(num_trials) ] ]

# <— Your code here

y_vals = [ 0 ] * num_trials # <— Your

code here

plt.figure(figsize=(12, 4))

plt.title(‘Graph of Uniform Distribution of ‘+str(num_trials)+’ p

oints in 1D.’,fontsize=12)

plt.grid(color=’0.95′)

plt.ylim(-0.2, 0.2)

plt.xlim(-0.0,1.0)

plt.plot([0,1.0],[0,0])

plt.scatter(x_vals, y_vals, marker=”x”,color=”r”)

plt.show()

# TO DO: Complete the lines of code indicated above. Then comment ou

t the seed(0)

# statement and run this cell several times to see the distribution o

f points;

# put the seed command back in before you submit!

seed(0)

random_line_plot(50)

Part B

Now we will simulate the experiment of throwing a dart at a unit square, which will produce a scatter plot of

random points in a 2D grid.

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 11/35

In [12]: # TO DO: Complete the following function stub which will produce a s

catter plot of

# random points in a unit square.

def random_plane_plot(num_trials):

“””Uses numpy’s random function to build a list of x and y values

with the following properties:

– x_vals should have len num_trials

– y_vals should have len num_trials

– Each value in x and y should be between 0 and 1

HINT: use the same code to build x_vals and y_vals

“””

x_vals = [ random() for k in range(num_trials) ] # <—

Your code here

y_vals = [ random() for k in range(num_trials) ] # <—

Your code here

plt.figure(num=None, figsize=(10, 10))

plt.title(‘Graph of Uniform Distribution of ‘+str(num_trials)+’ p

oints in 2D.’,fontsize=12)

plt.grid(color=’0.95′)

plt.ylim(0, 1)

plt.xlim(0,1)

plt.scatter(x_vals, y_vals,marker=”x”,color=”r”)

plt.show()

# Comment out the next line and run this cell several times to see th

e distribution of points;

# put the seed command back in before you submit!

seed(0)

random_plane_plot(500)

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 12/35

[End of Problem One]

Bar Charts

If we do the exact same thing as we did with a simple plot, but use the function bar(…) we get a bar chart:

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 13/35

In [13]: # To plot the points (1,2), (2,3), (3,6), (4,8) we would list the x v

alues and the corresponding y values:

plt.figure(num=None, figsize=(8, 6))

plt.bar([1,2,3,4], [2,3,6,8])

plt.title(‘A Bar Chart’)

plt.xlabel(“The X Values”)

plt.ylabel(“The Y Values”)

plt.show()

If the Y axis is probabilities (in the range 0 .. 1), we get a distribution of the probabilities among the outcomes of

an experiment:

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 14/35

In [14]: # Show the distribution of probabilities for a coin flip:

x = [0,1]

y = [0.5, 0.5]

labels = [‘Heads’, ‘Tails’]

plt.figure(num=None, figsize=(8, 6))

plt.xticks(x, labels)

plt.bar(x,y)

plt.title(‘Probability Distribution for Coin Flips’)

plt.ylabel(“Probability”)

plt.xlabel(“Outcomes”)

plt.show()

With a few tweaks, you can create an attractive bar chart for arbitrary probability distributions (we will cover the

topic of distributions in a few weeks).

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 15/35

In [15]: # Show the distribution of probabilities for flipping two dice

# We will consider this example in lecture

x = [k for k in range(2,13)]

y = [1/36,2/36,3/36,4/36,5/36,6/36,5/36,4/36,3/36,2/36,1/36]

plt.figure(num=None, figsize=(8, 6))

plt.bar(x,y, width=1.0,edgecolor=’black’) # <— Note how we set t

he width and edge color

plt.title(‘Probability Distribution for Tossing Two Dice’)

plt.ylabel(“Probability”)

plt.xlabel(“Outcomes”)

plt.show()

Histograms

If you give a list of values to hist(…) it will create a histogram counting how many of each value occur;

this list can be unordered;

You will get a cleaner display if you specify where the edges of the bins are, and make sure the edges of the

bins are visible, as shown in this example:

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 16/35

In [16]: plt.figure(num=None, figsize=(8, 6))

plt.hist([1,2,4,2,6,2,4,5,6,4,6,3,4,3],bins=[0.5,1.5,2.5,3.5,4.5,5.6,

6.5],edgecolor=’black’)

plt.title(‘Sample Histogram’)

plt.xlabel(“Outcomes”)

plt.ylabel(“Frequency”)

plt.show()

Problem 2

Read and understand the function role_die(…) below, which simulates the experiment of rolling a fair, sixsided die num_trials times. Note carefully:

The sample space is .

The experiment is equi-probable, i.e., the probability of any particular outcome is .

If we record the outcome for a large number of experiments, we would expect the number of outcomes to be

“evenly distributed.” In other words, for a large number of trials, we would expect the probability of each

outcome to be

TO DO: For this first problem, simply provide the Python code which would display a histogram of the results of

the experiment for 100,000 trials with appropriate labels. You should use the Numpy function randint(…) ,

as shown in the next cell.

{1, 2, 3, 4, 5, 6}

1

6

k ∈ {1, 2, 3, 4, 5, 6}

≈

number of times we observed a value k

num_trials

1

6

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 17/35

In [17]: # Demo of randint(lo,hi), which generates a random integer from the s

equence

# [lo,lo+1,…,hi-1].

# In other words the upper bound is exclusive, to be consistent with

the indices in lists,

# the Python range function, and so on.

randint(0,4)

In [18]: # You can also ask it for an array, since it is a Numpy function:

randint(0,4,10)

In [19]: seed(0)

def roll_die(num_trials = 100000): # <– note the use of the

default parameter value

trials_and_results = randint(1,7,num_trials) # this creates a 1D

array of length num_trials of random integers 1..6

return trials_and_results

example_trials = roll_die() # <– now we don’t have

to specify unless different

Out[17]: 1

Out[18]: array([1, 2, 0, 2, 1, 0, 0, 0, 3, 2])

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 18/35

In [20]: # Your code here

plt.figure(num=None, figsize=(8, 6))

plt.hist(example_trials,bins=[0.5,1.5,2.5,3.5,4.5,5.6,6.5],edgecolor=

‘black’)

plt.title(‘Sample Histogram’)

plt.xlabel(“Outcomes”)

plt.ylabel(“Frequency”)

plt.show()

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 19/35

Problem 3

Now we will display the same results showing the distribution of probabilities, instead of an explicit histogram;

since the experiment is equi-probable, if we record the outcome for a large number of experiments, we would

expect the number of outcomes to be “evenly distributed.” In other words, for a large number of trials, we would

expect the probability of each outcome to be

To calculate the probabilities, you will need to count the number of occurrences of each of the outcomes,

you may find the function Counter(…) useful for this (Google “Numpy Counter” to find out how this

works);

Once you have the frequency of each outcome, divide by the total number of trials to get the probability for

each.

TO DO: Complete the function stub below which takes the list returned by roll_die(…) , or any other

experiment returning numerical results, and produces a frequency distribution; this should have the same shape

as the histogram, but the Y axis will be probabilities instead of the frequency. Again, create appropriate labels.

Demonstrate your function, again, on the list example_trials produced in Problem 1.

k ∈ {1, 2, 3, 4, 5, 6}

≈

number of times we observed a value k

num_trials

1

6

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 20/35

In [21]: # Solution

seed(0)

def show_distribution(outcomes, title=’Probability Distribution’):

total = len(outcomes)

count = Counter(outcomes)

probs = [count[i]/total for i in range(min(outcomes), max(outcome

s)+1)]

plt.figure(num=None, figsize=(8, 6))

plt.bar([i for i in range(min(outcomes), max(outcomes)+1)],probs,

width=1.0,edgecolor=’black’) # <— Note how we set the width and

edge color

plt.title(title)

plt.ylabel(“Probability”)

plt.xlabel(“Outcomes”)

plt.show()

show_distribution(example_trials,title=’Probability Distribution for

Single Die Toss’)

Motivation for Monte Carlo Simulation

For the case of a fair die, the distribution is very easily computed by hand. But in general, it may be difficult to

write down an analytical solution for the distribution produced by a random experiment. This is where simulation

comes into play: instead of mathematically computing the distribution explicitly, you can use this method of

repeating experiments, and recording outcomes to understand the probabilistic rules governing some real world

event. When you can come up with an analytical result, this is a nice way of confirming its correctness!

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 21/35

Problem 4

You will now do the same thing you did in the previous problems, but with a new experiment: instead of rolling

one die and recording the value, you will simulate rolling dies and recording their sum. For example, if

and the first die shows up as a 3, and the second die shows up as a 1, the sum (and the value we record) would

be 4.

TO DO: Complete the two function stubs below and then demonstrate by providing code which would print out

the probability distribution for rolling 2 dice 100,000 times.

Hint: Not required but think about how you might do this in one line using Numpy and list comprehensions

n n = 2

In [22]: # Solution

seed(0)

def roll_and_add_dice(num_dice, num_trials = 10**6):

return([sum([randint(1,7) for i in range(num_dice)]) for k in ran

ge(num_trials)])

show_distribution(roll_and_add_dice(2),title=’Probability Distributio

n for Sum of Two Dice’)

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 22/35

Problem 5 (Monte Carlo Calculation of )

This final problem is also a Monte Carlo simulation, but this time in the continuous domain: we will calculate the

value of using a variation of Problem 1B.

We will leave this one up to you as it the exact details, but you must use the following fact: a circle inscribed in a

unit square (i.e., with side of length and area 1.0):

has as radius of 0.5 and an area of

Therefore, if you generate num_trials random points in the unit square, as in Problem 1B, and count how

many land inside the circle, you can calculate an approximation of .

For this problem, you must

(A) Draw the diagram of the unit square with inscribed circle and 500 random points, and

calculate the value of .

(B) Without drawing the diagram, calculate the value of you would get from trials.

(C) After completing (B), try to get a more accurate value for by increasing the number of trials.

Your results will depend on your machine, but for comparison, with my new Macbook Pro, I ran it

with trials while I got a cup of coffee, and it had the answer correct to 3 decimal places when

I came back. Sometimes I run big experiments overnight! The key here is to try increasingly large

numbers and see how the time increases.

</blockquote

Hint: Start by copying your code from Problem 1B. You might find Mr. Pythagoras’s formula

useful.

π

π

π ∗ (0.5 ) = .

2 π

4

π

π

π 10

5

π

10

8

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 23/35

In [23]: # (A)

def monte_carlo(num_trials=500):

incircle = 0

x_vals = [ random() for k in range(num_trials) ]

y_vals = [ random() for k in range(num_trials) ]

plt.figure(num=None, figsize=(10, 10), dpi=89)

plt.plot([0,1],[0,0],color=’orange’) # Line connecting (0,0) to

(1,0)

plt.plot([0,0],[0,1],color=’orange’) # Line connecting (0,0) to

(0,1)

plt.plot([0,1],[1,1],color=’orange’) # Line connecting (0,1) to

(1,1)

plt.plot([1,1],[0,1],color=’orange’) # Line connecting (1,0) to

(1,1)

theta = np.linspace(0, 2*np.pi, 100)

r = np.sqrt(0.25)

x1 = r*np.cos(theta)+0.5

x2 = r*np.sin(theta)+0.5

for (x,y) in zip(x_vals, y_vals):

if(((x-0.5)**2+(y-0.5)**2) <= 0.25):

incircle += 1

pi_val = 4*incircle/num_trials

plt.text(0.8,1.01, “The value of pi is “+str(pi_val)+”.”)

plt.plot(x1,x2, color=’orange’)

plt.title(‘Graph of Uniform Distribution of ‘+str(num_trials)+’ p

oints in 2D.’,fontsize=12)

plt.grid(color=’0.95′)

plt.scatter(x_vals, y_vals,marker=”x”,color=”r”)

plt.show()

monte_carlo()

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 24/35

In [24]: # (B)

def monte_carlo_without_diagram(num_trials=10**3):

incircle=0

x_vals = [ random() for k in range(num_trials) ]

y_vals = [ random() for k in range(num_trials) ]

for (x,y) in zip(x_vals, y_vals):

if(((x-0.5)**2+(y-0.5)**2) <= 0.25):

incircle += 1

pi_val = 4*incircle/num_trials

print(“Value of pi is “+str(pi_val)+”.”)

monte_carlo_without_diagram(num_trials=10**5)

In [25]: # (C)

monte_carlo_without_diagram(num_trials=10**8)

Value of pi is 3.1462.

Value of pi is 3.14150952.

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 25/35

Appendix: Customizing Your Plots

One thing you have probably noticed is that when you write “bare-bones” code such as we have above, certain

defaults are used for the size and layout of the figure and the style of the drawing. One of the most noticable is

that when you draw multiple lines, Matplotlib will change the color each time you call the same function (notice

that this doesn’t happen when calling a different function, e.g., plot followed by scatter).

Using Colors

Matplotlib cycles through a sequence of 10 colors, which is fine if that is what you want. For my taste, they are

pretty ugly, and in the next section we will show you how to use the colors you want.

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 26/35

In [26]: print(“\nThe 10 Matplotlib color sequence, starting at 12 o\’clock an

d going clockwise:”)

plt.figure(figsize=(10,10))

for k in np.arange(0,2*np.pi,np.pi/20): # arange is l

ike range, except it allows you to use floats

plt.plot([0,np.sin(k)],[0,np.cos(k)],lw=4)

plt.title(‘Line Colors’,fontsize=14)

plt.xlim([-1.2,1.2])

plt.ylim([-1.2,1.2])

plt.show()

Here is an example where we simply change the colors of the plot using the appropriate parameter; see a

complete list of colors here: https://matplotlib.org/2.0.2/api/colors_api.html

(https://matplotlib.org/2.0.2/api/colors_api.html)

The 10 Matplotlib color sequence, starting at 12 o’clock and going cl

ockwise:

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 27/35

In [27]: # EXAMPLE: Plotting a square with lines of different colors

plt.figure(num=None, figsize=(8, 8), dpi=89)

plt.plot([0,1],[0,0],color=’red’) # Line connecting (0,0) to (1,0)

plt.plot([0,0],[0,1],color=’green’) # Line connecting (0,0) to (0,1)

plt.plot([0,1],[1,1],color=’orange’) # Line connecting (0,1) to (1,1)

plt.plot([1,1],[0,1],color=’black’) # Line connecting (1,0) to (1,1)

Out[27]: [<matplotlib.lines.Line2D at 0x7efc35fd51d0]

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 28/35

Changing the Style of Plots

Here is an example showing how to

change the size of the whole figure

change the color of lines or points

change the style of lines or points

To see a complete list of lines styles see: https://matplotlib.org/2.0.2/api/lines_api.html

(https://matplotlib.org/2.0.2/api/lines_api.html)

To see a complete list of colors see: https://matplotlib.org/2.0.2/api/colors_api.html

(https://matplotlib.org/2.0.2/api/colors_api.html)

To see a complete list of marker (point) styles see: https://matplotlib.org/2.0.2/api/markers_api.html#modulematplotlib.markers (https://matplotlib.org/2.0.2/api/markers_api.html#module-matplotlib.markers)

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 29/35

In [28]: # EXAMPLE: Plotting a square via lines

plt.figure(figsize=(12, 12)) # the size is (horizontal, v

ertical)

plt.title(“Line Colors and Styles”,fontsize=16)

plt.plot([0,10],[0,0], color=’red’) # Line connecting (0,0) to (1,0)

plt.plot([0,0],[0,10], color=’green’) # Line connecting (0,0) to (0,

1)

plt.plot([0,10],[10,10],color=’orange’) # Line connecting (0,1) to

(1,1)

plt.plot([10,10],[0,10],color=’black’) # Line connecting (1,0) to (1,

1)

plt.plot([1,9],[9,9], linewidth=5) # give a linewidth in points, d

efault is 1.0

plt.plot([1,9],[8,8], linewidth=5,color = ‘#eaafff’) # for custom

color give the RGB value in hex

plt.plot([1,9],[7,7], linewidth=5,color=’0.75′) # for grey give the p

ercentage of white in quotes

plt.plot([1,9],[6,6], lw=4,linestyle=’–‘) # Linestyles

plt.plot([1,9],[5,5], lw=3,linestyle=’-.’) # Linestyles

plt.plot([1,9],[4,4], lw=2,linestyle=’:’) # Linestyles

plt.scatter(range(1,10),[3.5]*9,marker=’.’) # various markers, if yo

u don’t specify the colors it will cycle

plt.scatter(range(1,10),[3]*9,marker=’o’) # through a bunch of col

ors, starting with blue, orange, green, etc.

plt.scatter(range(1,10),[2.5]*9,marker=’x’)

plt.scatter(range(1,10),[2]*9,marker=’s’)

plt.scatter(range(1,10),[1.5]*9,marker=’^’)

plt.scatter(range(1,10),[1]*9,marker=’D’)

print()

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 30/35

Et Cetera

Then you can start getting obsessive, adding gridlines, changing the background color, adding legends, text, and

so on.

Another nice feature of matplotlib is that you can insert simple Latex commands into titles and text…..

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 31/35

In [29]: # Plotting a smooth curve for the function x^2

x = [i for i in range(11)]

y = [i**2 for i in x]

plt.figure(figsize=(8, 8))

plt.title(‘Graph of $x = x^2$’)

plt.xlabel(“X”)

plt.ylabel(“Y”)

plt.grid()

plt.plot(x,y)

plt.show()

plt.figure(figsize=(8, 8))

plt.title(‘Graph of $y = x^2$’)

plt.grid(color=’w’) # grid of white lines — don’t use

points with this, they look funny

plt.gca().set_facecolor(‘0.95′) # background of light grey

plt.plot(x,y,color=’b’)

plt.xlabel(“X”)

plt.ylabel(“Y”)

plt.show()

plt.figure(figsize=(8, 8))

plt.title(‘Graph of $y = x^2$’)

plt.grid(color=’r’,alpha=0.1) # alpha sets the transparency, 0

= invisible and 1 = normal

plt.plot(x,y,color=’r’,lw=0.5,label=’Curve’)

plt.scatter(x,y,color=’r’,marker=’o’,label=’Points’)

plt.legend()

plt.xlabel(“X”)

plt.ylabel(“Y”)

plt.show()

plt.figure(figsize=(8, 8))

plt.title(‘Graph of $y = x^2$’,fontsize=16)

plt.xlabel(“X”,fontsize=14)

plt.ylabel(“Y”,rotation=0,fontsize=14)

plt.grid(color=’0.95′)

plt.text(0,90,”The title has been enlarged from default 12 points to

16 points.”)

plt.text(0,80,”Notice that the $y$ axis label is rotated to be uprigh

t, \nand the x and y labels are also bigger, at 14 points.”) # lowe

r left corner of text string is at point (0,60)

plt.text(0,60,”When drawing points and lines together it looks \nbett

er if you make the lines thinner.”)

plt.text(0,40,”Honestly I think it is also better to just use\nthe de

fault marker (circles) when you draw \nlines, these triangles are kin

da fussy\nand they don’t seem to be centered on \nthe data point.”)

plt.plot(x,y,color=’b’,lw=0.5)

plt.scatter(x,y,color=’b’,marker=’^’)

plt.show()

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 32/35

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 33/35

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 34/35

9/12/2019 hw01

file:///home/arasi/Downloads/hw01.html 35/35

In [ ]: