Fr

Python has a handful of open source libraries for numerical

computations that involve optimization, linear algebra,
integration, interpolation, and other special functions using
array objects, machine learning, data mining, and plotting.
This book offers practical guidance to help you on the
journey to effective data visualization. Commencing with
a chapter on the data framework, the book covers the
complete visualization process, using the most popular
Python libraries with working examples. You will learn how
to use NumPy, SciPy, IPython, matplotlib, pandas, patsy,
and scikit-learn, with a focus on generating results that
can be visualized in many different ways. Further chapters
are aimed at not only demonstrating advanced techniques
such as interactive plotting; numerical, graphical linear, and
nonlinear regression; and clustering and classification,
but also helping you understand the aesthetics and best
practices of data visualization. The book concludes with
interesting examples such as social networks, directed
graph examples in real life, data structures appropriate for
these problems, and network analysis.

Who this book is written for

Gather, cleanse, access, and map data to a

visual framework
Recognize which visualization method is
applicable and learn best practices for
data visualization
Get acquainted with reader-driven narratives,
author-driven narratives, and the principles
of perception
Understand why Python is an effective tool for
numerical computation much like MATLAB,
and explore some interesting data structures
that come with it
Use various visualization techniques to explore
how Python can be very useful for financial
and statistical computations
Compare Python with other visualization
approaches using Julia and a JavaScript-based
framework such as D3.js
Discover how Python can be used in conjunction
with NoSQL, such as Hive, to produce results
efficiently in a distributed environment

$ 54.99 US
34.99 UK

community experience distilled

P U B L I S H I N G

Kirthi Raman

If you are a Python developer who performs data visualization

and wants to develop your existing Python knowledge,
then this book is for you. A basic knowledge level and
understanding of Python libraries is assumed.

What you will learn from this book

Mastering Python Data Visualization

Mastering Python
Data Visualization

ee

pl

C o m m u n i t y

E x p e r i e n c e

D i s t i l l e d

Mastering Python
Data Visualization
Generate effective results in a variety of visually appealing charts
using the plotting packages in Python

Prices do not include

local sales tax or VAT
where applicable

Visit www.PacktPub.com for books, eBooks,

code, downloads, and PacktLib.

Sa
m

Kirthi Raman

In this package, you will find:

The author biography

A preview chapter from the book, Chapter 4 'Numerical Computing and
Interactive Plotting'
A synopsis of the books content
More information on Mastering Python Data Visualization

About the Author

Kirthi Raman is currently working as a lead data engineer with Neustar Inc, based
in Mclean, Virginia USA. Kirthi has worked on data visualization, with a focus on
JavaScript, Python, R, and Java, and is a distinguished engineer. Previously, he
worked as a principle architect, data analyst, and information retrieval specialist at
Quotient, Inc. Kirthi has also worked as a technical lead and manager for a start-up.
He has taught discrete mathematics and computer science for several years. Kirthi
has a graduate degree in mathematics and computer science from IIT Delhi and an
MS in computer science from the University of Maryland. He has written several
white papers on data analysis and big data.

Preface
Data visualization is intended to provide information clearly and help the viewer
understand them qualitatively. The well-known expression that a picture is worth
a thousand words may be rephrased as "a picture tells a story as well as a large
collection of words". Visualization is, therefore, a very precious tool that helps the
viewer understand a concept quickly. However, data visualization is more of an art
than a skill because if you try to overdo it, it could have a reverse effect.
We are currently faced with a plethora of data containing many insights that hold the
key to success in the modern day. It is important to find the data, clean it, and use the
right tool to visualize it. This book explains several different ways to visualize data
using Python packages, along with very useful examples in many different areas
such as numerical computing, financial models, statistical and machine learning, and
genetics and networks.
This book presents an example code developed on Mac OS X 10.10.5 using Python
2.7, IPython 0.13.2, matplotlib 1.4.3, NumPy 1.9.2, SciPy 0.16.0, and conda build
version 1.14.1.

What this book covers

Chapter 1, A Conceptual Framework for Data Visualization, expounds that data
visualization should actually be referred to as "the visualization of information for
knowledge inference". This chapter covers the framework, explaining the transition
from data/information to knowledge and how meaningful representations (through
logarithms, colormaps, scatterplots, correlations, and others) can make knowledge
much easier to grasp.

Preface

Chapter 2, Data Analysis and Visualization, explains the importance of visualization

and shows several steps in the visualization process, including several options of
tools to choose from. Visualization methods have existed for a long time, and we
are exposed to them very early; for instance, even young children can interpret bar
charts. Interactive visualization has many strengths, and this chapter explains them
with examples.
Chapter 3, Getting Started with the Python IDE, explains how you can use Anaconda
from Continuum Analytics without worrying about installing each Python library
individually. Anaconda has simplified packaging and deployment methods that
make it easier to run the IPython notebook alongside other libraries.
Chapter 4, Numerical Computing and Interactive Plotting, covers interactive plotting
methods with working examples in computational physics and applied mathematics.
Some notable examples are interpolation methods, approximation, clustering,
sampling, correlation, and convex optimization using SciPy.
Chapter 5, Financial and Statistical Models, explores financial engineering, which has
many numerical and graphical methods that make an interesting use case to explore
Python. This chapter covers stock quotes, regression analysis, the Monte Carlo
algorithm, and simulation methods with examples.
Chapter 6, Statistical and Machine Learning, covers statistical methods such as linear
and nonlinear regression and clustering and classification methods using numpy,
scipy, matplotlib, and scikit-learn.
Chapter 7, Bioinformatics, Genetics, and Network Models, covers interesting examples
such as social network and instances of directed graphs in real life, data structures
that are appropriate for these problems, and network analysis. This chapter uses
specific libraries such as graph-tool, NetworkX, matplotlib, scipy, and numpy.
Chapter 8, Advanced Visualization, covers simulation methods and examples of signal
processing to show several visualization methods. Here, we also have a comparison
of other advanced tools out there, such as Julia and D3.js.
Appendix, Go Forth and Explore Visualization, gives an overview of conda and lists out
various Python libraries.

Numerical Computing and

Interactive Plotting
The field of high-performance numerical computing lies at the crossroads of
a number of disciplines and skill sets. In order to be successful at using highperformance computing today, it requires knowledge and skills of programming,
data science, and applied mathematics. In addition to these, efficient implementation
of the computational problems requires some understanding of processing and
storage devices.
The role of computing in science has evolved to a different level in recent years.
Programming languages (such as R and MATLAB) were common in academic
research and scientific computing. Today, Python plays a big role in scientific
computing for a good reason. The Python community has put together many efficient
tools and packages that is being used not only by the research community, but also
successful commercial organizations such as Yahoo, Google, Facebook, and Amazon.
There are two popular packages that are widely used in scientific computing. They
are Numerical Python Package (NumPy) and Scientific Python Package (SciPy).
NumPy is popular for efficient arrays and in particular the ease of indexing. In the
following sections, we will discuss the following topics:

NumPy, SciPy, and MKL functions

Numerical indexing and logical indexing

Data structuresstacks, queues, tuples, sets, tries, and dictionaries

Visualizing plots using matplotlib, and so on

Optimization and interpolation using NumPy and SciPy with examples

Integrating Cython with NumPy and advantages of Cython

[ 121 ]

Numerical Computing and Interactive Plotting

NumPy, SciPy, and MKL functions

Almost all scientific and numerical computing requires the representation of data in
the form of vectors and matrices, and NumPy handles all these in terms of arrays.
NumPy and SciPy are computational modules of Python that provide convenient
mathematical and numerical methods in precompiled, fast functions. The NumPy
package provides basic routines to manipulate large arrays and matrices of numeric
data. The SciPy package extends NumPy with a collection of useful algorithms
with applied mathematical techniques. In NumPy, ndarray is an array object that
represents a multidimensional, homogeneous array of items that have a known size.

NumPy
NumPy not only uses array objects, but also linear algebraic functions that can be
conveniently used for computations. It provides a fast implementation of arrays and
associated array functionalities. Using an array object, one can perform operations
that include matrix multiplication, transposition of vectors and matrices, solve
systems of equations, perform vector multiplication and normalization, and so on.

NumPy universal functions

A universal function (ufunc) is a function that operates on ndarrays by each element,
supporting type casting and several other standard features. In other words, ufunc
is a vectorized wrapper for a function that takes scalar inputs and produces scalar
outputs. Many built-in functions are implemented in the compiled C code, which
makes it faster.
NumPy universal functions are faster than Python functions because looping is
performed in compiled code. Also, since arrays are typed, their type is known before
any sort of computation occurs.
A simple example of ufunc operating on each element is shown here:
import numpy as np
x = np.random.random(5)
print x
print x + 1
# add 1 to each element of x
[ 0.62229809
[ 1.62229809

0.18010463
1.18010463

0.28126201
1.28126201

Other examples are np.add and np.subtract.

[ 122 ]

0.30701477
1.30701477

0.39013144]
1.39013144]

Chapter 4

NumPy's ndarray is similar to the lists in Python, but it is rather strict in storing
only a homogeneous type of object. In other words, with a Python list, one can mix
the element types, such as the first element as a number, the second element as a
list, and the next element as another list (or dictionary). The performance in terms of
operating the elements of ndarray is significantly faster for a large size array, which
will be demonstrated here. The example here demonstrates that it is faster because we
will measure the running time. However, for readers who are curious about NumPy
implementations in C, there is a documentation on the same available at http://
docs.scipy.org/doc/numpy/reference/internals.code-explanations.html.
import numpy as np
arr = np.arange(10000000)
listarr = arr.tolist()
def scalar_multiple(alist, scalar):
for i, val in enumerate(alist):
alist[i] = val * scalar
return alist
# Using IPython's magic timeit command
timeit arr * 2.4
10 loops, best of 3: 31.7 ms per loop
# above result shows 31.7 ms (not seconds)
timeit scalar_multiple(listarr, 2.4)
1 loops, best of 3: 1.39 s per loop
# above result shows 1.39 seconds (not ms)

In the preceding code, each array element occupies 4 bytes. Therefore, a million
integer arrays occupy approximately 44 MB of memory, and the list uses 711 MB
of memory. However, arrays are slower for small collection sizes, but for large
collection sizes, they use less memory space and are significantly faster than lists.
NumPy comes with many useful functions that are broadly categorized as
trigonometric functions, arithmetic functions, exponent and logarithmic functions,
and miscellaneous functions. Among many miscellaneous functions, convolve() for
linear convolution and interp() for linear interpolation are popular. In addition,
for most experimental work that involve equally spaced data, the linspace() and
random.rand() functions are among a few that are used widely.

[ 123 ]

Numerical Computing and Interactive Plotting

Shape and reshape manipulation

Changing the shape of an existing array can be more efficient than creating a new
array from the old data with a new shape. In the first example, reshape happens in
memory (the array is not stored in a variable), whereas in the following code, the
array is first stored in a variable a and then a is reshaped:
import numpy as np
np.dandom.rand(2,4)
array([[ 0.96432148,
[
0.27086909,

0.63192759,
0.92865208,

0.12976726,
0.27762891,

0.56131001],
0.40429701]])

np.random.rand(8).reshape(2,4)
array([[ 0.39698544, 0.88843637,
[ 0.97622822, 0.47652548,

0.66260474,
0.56163488,

0.61106802],
0.43602828]])

In the preceding example, after creating 8 values, they are reshaped into a valid
dimension of choice, as shown in the following code:
#another example
a = np.array([[11,12,13,14,15,16],[17,18,19,20,21,22]])
print a
[[11, 12, 13, 14, 15, 16], [17, 18, 19, 20, 21, 22]]
# the following shows shape is used to know the dimensions
a.shape
(2,6)
#Now change the shape of the array
a.shape=(3,4)
print a
[[11 12 13] [14 15 16] [17 18 19]

[20 21 22]]

xrange is used instead of range because it is faster for loops and avoids the storage
of the list of integers; it just generates them one by one. The opposite of shape and
reshape is ravel(), as shown in the following code:
#ravel example
a = np.array([[11,12,13,14,15,16],[17,18,19,20,21,22]])
a.ravel()
array([11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22])

[ 124 ]

Chapter 4

An example of interpolation
Here is an example of interpolation using interp():
n=30
# create n values of x from 0 to 2*pi
x = np.linspace(0,2*np.pi,n)
y = np.zeros(n)
#for range of x values, evaluate y values
for i in xrange(n):
y[i] = np.sin(x[i])

The image displayed in the following picture is the result of a simple sine curve
interpolation:

The following code shows the plotting curves with and without interpolation:
import numpy as np
import matplotlib.pyplot as plt
# create n values of x from 0 to 2*pi
x = np.linspace(0, 8*np.pi, 100)
y = np.sin(x/2)
#interpolate new y-values
yinterp = np.interp(x, x, y)

[ 125 ]

Numerical Computing and Interactive Plotting

#plot x,y values using circle marker (line style)
plt.plot(x, y, 'o')
#plot interpolated curve using dash x marker
plt.plot(xvals, yinterp, '-x')
plt.show()

Vectorizing functions
Vectorizing functions via vectorize() in NumPy and SciPy can be very efficient.
Vectorize has the capability to convert a function that takes scalars as arguments to
a function that takes arrays as arguments by applying the same rule element-wise.
We will demonstrate this here with two examples.
The first example uses a function that takes three scalar arguments to produce a
vectorized function that takes three array arguments, as shown in the following code:
import numpy as np
def addition(x, y, z):
return x + y + z
def addpoly():
i = np.random.randint(25)
poly1 = np.arange(i, i+10)
i = np.random.randint(25)
poly2 = np.arange(i, i+10)
poly3 = np.arange(10, 18)
print poly1
print poly2
print poly3
print '-' * 32
vecf = np.vectorize(addition)
print vecf(poly1,poly2,poly3)
addpoly()
[ 4 5 6 7 8 9 10 11 12 13]
[13 14 15 16 17 18 19 20 21 22]
[10 11 12 13 14 15 16 17 18 19]
-------------------------------[27 30 33 36 39 42 45 48 51 54]

Note that arrange is an array-valued version of the built-in Python range function.
[ 126 ]

Chapter 4

The second example uses a function that takes one scalar argument to produce a
vectorized function that takes an array argument, as shown in the following code:
import numpy as np
def posquare(x):
if x >= 0: return x**2
else: return -x
i = np.random.randint(25)
poly1 = np.arange(i,i+10)
print poly1
vecfunc = vectorize(posquare, otypes=[float])
vecfunc(poly1)
[14 15 16 17 18 19 20 21 22 23]
array([ 196., 225., 256., 289., 324., 361., 400., 441., 484., 529.])

There is yet another example that is interesting to study with the help of an example
code. This example shows three ways to increment the array elements by a constant
and measure the running time to determine which method is faster:
import numpy as np
from time import time
def incrembyone(x):
return x + 1
dataarray=np.linspace(1,5,1000000)
t1=time()
lendata = len(dataarray)
print "Len = "+str(lendata)
print dataarray[1:7]
for i in range(lendata):
dataarray[i]+=1
print " time for loop (No vectorization)->" + str(time() - t1)
t2=time()
vecincr = np.vectorize(incrembyone) #1
vecincr(dataarray) #2
print " time for vectorized version-1:" + str(time() - t2)
t3 = time()

[ 127 ]

Numerical Computing and Interactive Plotting

# This way to increment array elements with one line
# is pretty powerful, accomplishes same thing as #1 and #2
dataarray+=1 # how does this achieve the results
print dataarray[1:7]
print " time for vectorized version-2:" + str(time() - t3)
Len = 1000000
[ 1.000004 1.000008 1.000012 1.000016 1.00002 1.000024]
time for loop (No vectorization)->0.473765850067
time for vectorized version-1:0.221153974533 # half the time
[ 3.000004 3.000008 3.000012 3.000016 3.00002 3.000024]
time for vectorized version-2:0.00192213058472 # in fraction time

Besides the vectorizing techniques, there is another simple coding practice that could
make programs more efficient. If there are prefix notations that are being used in
loops, it is best practice to create a local alias and use this alias in the loop. One such
example is shown here:
fastsin = math.sin
x = range(1000000)
for i in x:
x[i] = fastsin(x[i])

Summary of NumPy linear algebra

The following is a list of some well-known functions that NumPy offers in
linear algebra:
Name

Description

dot(a,b)
linalg.norm(x)

This is a dot product of two arrays

linalg.cond(x)

This specifies the condition number

linalg.solve(A,b)

This solves linear system Ax=b

linalg.inv(A)

This represents an inverse of A

This is a matrix or vector norm

linalg.pinv(A)

This specifies a pseudo-inverse of A

linalg.eig(A)

These are eigenvalues/vectors of square A

linalg.eigvals(A)

These are eigenvalues of general A

linalg.svd(A)

This is a singular value decomposition

[ 128 ]

Chapter 4

SciPy
NumPy has already many convenient functions that can be used in computation.
Then, why do we need SciPy? SciPy is an extension of NumPy for mathematics,
science, and engineering that has many packages available for linear algebra,
integration, interpolation, fast Fourier transforms, large matrix manipulation,
statistical computation, and so on. The following table shows a brief description
of these packages:
Subpackage
scipy.cluster

Brief description of functionalities

This specifies the functions for clustering, including vector
quantization and k-means.

scipy.fftpack

This denotes the functions of fast Fourier transform.

scipy.
integrate

This specifies the functions for performing numerical integration

using trapezoidal, Simpson's, Romberg, and other methods. It also
specifies methods for integration of ordinary differential equations.
One can perform single, double, and triple integrations on a function
object with the functions quad, dblquad, and tplquad.

scipy.
interpolate

This denotes the functions and classes for interpolation objects with
discrete numeric data and linear and spline interpolation.

scipy.linalg

This is a wrapper for the package linalg in NumPy. All the

functionalities from NumPy is part of scipy.linalg, along with
several other functions.

scipy.
optimize

This denotes the maximization and minimization functions that

include Neider-Mead Simplex, Powell's, conjugate gradient BFGS,
least squares, constrained optimizers, simulated annealing, Newton's
method, bisection method, Broyden Anderson, and line search.

scipy.sparse

This specifies the functions that can work with large sparse matrices.

scipy.special

This has special functions for computational physics, such as elliptic,

bessel, gamma, beta, hypergeometric, parabolic, cylinder, mathieu,
and spheroidal wave.

In addition to the preceding listed subpackages, SciPy also has a scipy.io package
that has functions to load a matrix called spio.loadmat(), save a matrix called
spio.savemat(), and read images via scio.imread(). When there is a need to
develop computational programs in Python, it is good practice to check the SciPy
documentation to see whether it contains the functions that already accomplish the
intended task.
Let's take a look at an example using scipy.polyId():
import scipy as sp
# function that multiplies two polynomials
[ 129 ]

Numerical Computing and Interactive Plotting

def multiplyPoly():
#cubic1 has coefficients 3, 4, 5 and 5
cubic1 = sp.poly1d([3, 4, 5, 5])
#cubic2 has coefficients 4, 1, -3 and 3
cubic2 = sp.poly1d([4, 1, -3, 3])
print cubic1
print cubic2
print '-' * 36
#print results of polynomial multiplication
print cubic1 * cubic2
multiplyPoly()

# produces the following result

3
2
3 x + 4 x + 5 x + 5
3
2
4 x + 1 x - 3 x + 3
-----------------------------------6
5
4
3
2
12 x + 19 x + 15 x + 22 x + 2 x + 15

The result matches with the multiplication done in the traditional term-by-term
method, as follows:

As such, polynomial representation can be used for integration, differentiation, and

other computational physics. These capabilities along with many more functions in
NumPy, SciPy, and other package extensions clearly indicate that Python is another
alternative to MATLAB and is therefore used in some academic environments.
There are many different kinds of interpolation that SciPy offers. The following
example uses interpolate.splev, which uses B-spline and its derivatives and
interpolate.splprep for the B-spline representation of two-dimensional curves
(N-dimensional in general):
import numpy as np
import matplotlib.pyplot as plt
import scipy as sp

[ 130 ]

Chapter 4
t = np.arange(0, 2.5, .1)
x = np.sin(2*np.pi*t)
y = np.cos(2*np.pi*t)
tcktuples,uarray = sp.interpolate.splprep([x,y], s=0)
unew = np.arange(0, 1.01, 0.01)
splinevalues = sp.interpolate.splev(unew, tcktuples)
plt.figure(figsize=(10,10))
plt.plot(x, y, 'x', splinevalues[0], splinevalues[1],
np.sin(2*np.pi*unew), np.cos(2*np.pi*unew), x, y, 'b')
plt.legend(['Linear', 'Cubic Spline', 'True'])
plt.axis([-1.25, 1.25, -1.25, 1.25])
plt.title('Parametric Spline Interpolation Curve')
plt.show()

The following diagram is the result of this spline interpolation using SciPy and NumPy:

[ 131 ]

Numerical Computing and Interactive Plotting

Let's take a look at an example in numerical integration and solve linear equations using
some of the SciPy functions (such as Simpson's and Romberg) and compare these with
the NumPy function trapezoidal. We know that when a function such as f(x) = 9 x2 is
integrated from -3 to 3, we expect 36 units, as shown in the following diagram:

The preceding plot shows the 9-x2 function (which is symmetric along the Y axis).
Mathematically, the integration from -3 to 3 is twice that of the integration from 0 to
3. How do we numerically integrate using SciPy? The following code shows one way
to perform it using the trapezoidal method from NumPy:
import numpy as np
from scipy.integrate import simps, romberg
a = -3.0; b = 3.0;
N = 10
x = np.linspace(a, b, N)
y = 9-x*x
yromb = lambda x: (9-x*x)
t = np.trapz(y, x)
s = simps(y, x)
r = romberg(yromb, a, b)
#actual integral value
aiv = (9*b-(b*b*b)/3.0) - (9*a-(a*a*a)/3.0)
print 'trapezoidal = {0} ({1:%} error)'.format(t, (t - aiv)/aiv)
print 'simpsons = {0} ({1:%} error)'.format(s, (s - aiv)/aiv)
print 'romberg = {0} ({1:%} error)'.format(r, (r - aiv)/aiv)
[ 132 ]

Chapter 4
print 'actual value = {0}'.format(aiv)
trapezoidal = 35.5555555556 (-1.234568% error)
simpsons = 35.950617284 (-0.137174% error)
romberg = 36.0 (0.000000% error)
actual value = 36.0

An example of linear equations

Let's try to solve a set of linear equations in three variables (x, y, and z) as follows:

x + 2y z = 2

2x 3y + 2z = 2

3x + y z = 2

NumPy offers a convenient method np.linalg.solve() to solve linear equations.

However, the inputs are expected in vector form. The following program shows how
one can solve linear equations.
import numpy as np
# Matrix A has coefficients of x,y and z
A = np.array([[1, 2, -1],
[2, -3, 2],
[3, 1, -1]])
#constant vector
b = np.array([2, 2, 2])
#Solve these equations by calling linalg.solve
v = np.linalg.solve(A, b)
# v is the vector that has solutions
print "The solution vector is "
print v
# Reconstruct Av to see if it produces identical values
print np.dot(A,v) == b
The solution vector is
[ 1. 2. 3.]
[ True True True]

Note that np.dot(A,v) is a matrix multiplication (not A*v). The solution vector
v = [1,2,3] is the correct expected result.

[ 133 ]

Numerical Computing and Interactive Plotting

The vectorized numerical derivative

Now as the last example in this section, we will take a look at the vectorized
numeric derivatives that NumPy offers. We do know that the derivative is
by applying the quotient rule of differentiation.
However, by applying the vectorized methods in Python to compute the derivatives
without loop, we will see the following code:
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-np.pi/2, np.pi/2, 44)
y = 1/(1+np.cos(x)*np.cos(x))
dy_actual = np.sin(2*x)/(1+np.cos(x)*np.cos(x))**2
fig = plt.figure(figsize=(10,10))
ax=fig.add_subplot(111,axisbg='white')
# we need to specify the size of dy ahead because diff returns
dy = np.zeros(y.shape, np.float) #we know it will be this size
dy[0:-1] = np.diff(y) / np.diff(x)
dy[-1] = (y[-1] - y[-2]) / (x[-1] - x[-2])
plt.plot(x,y, linewidth=3, color='b', label='actual function')
plt.plot(x,dy_actual,label='actual derivative', linewidth=2,
color='r')
plt.plot(x,dy,label='forward diff', linewidth=2, color='g')
plt.legend(loc='upper center')
plt.show()

In the following example, we can see how you can plot the actual function, its
derivative, and the forward difference in the same plot. The actual derivative is
plugged into dy_actual, and the forward difference is calculated using diff()
from NumPy.

[ 134 ]

Chapter 4

The following plot diagram is the result of this program:

[ 135 ]

Numerical Computing and Interactive Plotting

MKL functions
The MKL functions from Intel provide high-performance routines on vectors and
matrices. In addition, they include FFT functions and vector statistical functions.
These functions have been enhanced and optimized to work efficiently on Intel
processors. For Anaconda users, Continuum has packaged these FFT functions
into binary versions of Python libraries for MKL optimizations. However MKL
optimizations are available as an add-on as part of the Anaconda Accelerate package.
The graph here shows the difference in slowness without MKL:

The preceding graph has been taken from

https://store.continuum.io/cshop/mkl-optimizations/.

[ 136 ]

Chapter 4

For larger array inputs, MKL offers a significant improvement over performance, as
shown in the following screenshot:

The preceding image has been taken from https://software.intel.com/en-us/

articles/numpyscipy-with-intel-mkl.

The performance of Python

Python programmers often try to rewrite their innermost loops in C and call the
compiled C functions from Python for performance reasons. There are many projects
aimed at making this kind of optimization easier, such as Cython. However, it
would be preferable to make their existing Python code faster without depending on
another programming language.

[ 137 ]

Numerical Computing and Interactive Plotting

There are few other options available to improve the performance of the
computationally intensive programs in Python:

Use Numbapro: This is a Python compiler from Continuum Analytics that

can compile the Python code for execution on CUDA-capable GPUs or
multicore CPUs. This compiled code runs the native compiled code and is
several times faster than the interpreted code. Numbapro works by enabling
compilation at runtime (this is just-in-time or the JIT compilation). With
Numbapro, it is possible to write standard Python functions and run them on
a CUDA-capable GPU. Numbapro is designed for array-oriented computing
tasks, such as the widely used NumPy library. Numbapro is an enhanced
version of Numba and is part of Anaconda Accelerate, a commercially
licensed product from Continuum Analytics.

Use Scipy.weave: This is a module that lets you insert snippets of the C code
and seamlessly transports the arrays of NumPy into the C layer. It also has
some efficient macros.

Use multicore approach: The multiprocessing package of Python 2.6 or

higher provides a relatively simple mechanism to create a subprocess. Even
desktop computers these days have multicore processors; it makes sense to
put all the processors to work. This is much simpler than using threading.

Use process pool called pool: This is another class in the multiprocessing
package. With pool, you can define the number of worker processes to be
created in the pool and then pass an iterable object containing the parameters
for each process.

Use Python in a distributed computing package (such as Disco): This is a

lightweight, open source framework for distributed computing based on the
MapReduce paradigm (http://discoproject.org). Other similar packages
are Hadoop Streaming, mrjob, dumbo, hadoopy, and pydoop.

Scalar selection
Scalar selection is the simplest method to select elements from an array and
is implemented using [rowindex] for one-dimensional arrays, [rowindex,
columnindex] for two-dimensional arrays, and so on. The following is a simple code
that shows an array element reference:
import numpy as np
x = np.array([[2.0,4,5,6], [1,3,5,9]])
x[1,2]
5.0

[ 138 ]

Chapter 4

A pure scalar selection always returns a single element and not an array. The data
type of the selected element matches the data type of the array used in the selection.
Scalar selection can also be used to assign a value to an array element, as shown in
the following code:
x[1,2] = 8
x
array([[2, 4, 5, 6],[1, 3, 8, 9]])

Slicing
Arrays can be sliced just like lists and tuples. Array slicing is identical to list slicing,
except that the syntax is simpler. Arrays are sliced using the [ : , :, ... :]
syntax, where the number of dimensions of the arrays determine the size of the slice,
except that these dimensions for which slices are omitted, all elements are selected.
For example, if b is a three-dimensional array, b[0:2] is the same as b[0:2,:,:].
There are shorthand notations for slicing. Some common ones are:

: and: are the same as 0:n:1, where n is the length of the array

m: and m:n: are the same as m:n:1, where n is the length of the array

:n: is the same as 0:n:1

::d: is the same as 0:n:d, where n is the length of the array

All these slicing methods have been referenced with the usage of arrays. This can
also be applicable to lists. Slicing of one-dimensional arrays is identical to slicing
a simple list (as one-dimensional arrays can be seen equivalent to a list), and the
returned type of all the slicing operations matches the array being sliced. The
following is a simple mechanism that shows array slices:
x = array([5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20])
# interpret like this default start but end index is 2
y = x[:2]
array([5, 6])
# interpretation default start and end, but steps of 2
y = x[::2]
array([5,7,9,11,13,15,17,19])

[ 139 ]

Numerical Computing and Interactive Plotting

NumPy attempts to convert data type automatically if an element with one data type is
inserted into an array with a different data type. For example, if an array has an integer
data type, place a float into the array results in the float being truncated and store it as
an integer. This can be dangerous; therefore in such cases, arrays should be initialized
to contain floats unless a considered decision is taken to use a different data type for
a good reason. This example shows that even if one element is float and the rest is
integer, it is assumed to be the float type for the benefit of making it work properly:
a = [1.0, 2,3,6,7]
b = array(a)
b.dtype
dtype('float64')

Slice using flat

Data in matrices are stored in a row-major order, which means elements are indexed
first by counting along the rows and then down the columns. For example, in the
following matrix, there are three rows and three columns; the elements are read in
the order 4,5,6,7,8,9,1,2,3 (for each row, column-wise):

Linear slicing assigns an index to each element of the array in the order of the
elements read. In two-dimensional arrays or lists, linear slicing works by first
counting across the rows and then down the columns. In order to use linear slicing,
you have to use the flat function, as shown in the following code:
a=array([[4,5,6],[7,8,9],[1,2,3]])
b = a.flat[:]
print b
[4, 5, 6, 7, 8, 9, 1, 2, 3]

Array indexing
Elements from NumPy arrays can be selected using four methods: scalar selection,
slicing, numerical indexing, and logical (or Boolean) indexing. Scalar selection and slicing
are the basic methods to access elements in an array, which has already been discussed
here. Numerical indexing and logical indexing are closely related and allows more
flexible selection. Numerical indexing uses lists or arrays of locations to select elements,
whereas logical indexing uses arrays that contain Boolean values to select elements.
[ 140 ]

Chapter 4

Numerical indexing
Numerical indexing is an alternative to slice notation. The idea in numerical indexing
is to use coordinates to select elements. This is similar to slicing. Arrays created using
numerical indexing create copies of data, whereas slices are only views of data, and
not copies. For performance sake, slicing should be used. Slices are similar to onedimensional arrays, but the shape of the slice is determined by the slice inputs.
Numerical indexing in one-dimensional arrays uses the numerical index values
as locations in the array (0-based indexing) and returns an array with the same
dimensions as the numerical index.
Note that the numerical index can be either a list or a NumPy array and must contain
integer data, as shown in the following code:
a = 10 * arange(4.0)
array([0.,10.,20.,30.])
a[[1]] # arrays index is list with first element
array([ 10.])
a[[0,3,2]] # arrays index are 0-th, 3-rd and 2-nd
array([ 0., 30., 20.])
sel = array([3,1,4,2,3,3])
a[sel]
array([ 30. 10.
0. 20.

# array with repetition

30.

30.])

sel = array([4,1],[3,2]])
a[sel]
array([[ 30.,10.], [ 0.,20.]])

These examples show that the numerical indices determine the element location, and
the shape of the numerical index array determines the shape of the output.
Similar to slicing, numerical indexing can be combined using the flat function to
select elements from an array using the row-major ordering of the array. The behavior
of numerical indexing with flat is identical to that of using numerical indexing on a
flattened version of the underlying array. A few examples are shown here:
a = 10 * arange(8.0)
array([ 0., 10., 20.,

30.,

40., 50., 60., 70.])

a.flat[[3,4,1]]
array([ 30., 40., 10.])
a.flat[[[3,4,7],[1,5,3]]]
array([[ 30., 40., 70.], [ 10., 50., 30.]])
[ 141 ]

Numerical Computing and Interactive Plotting

Logical indexing
Logical indexing is different from slicing and numeric indexing; it rather uses logical
indices to select elements, rows, or columns. Logical indices act as light switches and
are either true or false. Pure logical indexing uses a logical indexing array with the
same size as the array being used for selection and always returns a one-dimensional
array, as shown in the following code:
x = arange(-4,5)
x < 0
array([True, True, True, True, False, False, False, False, False],
dtype=bool)
x[x>0]
array([1, 2, 3, 4])
x[abs(x) >= 2]
array([-4, -3, -2,

2,

3,

4])

#Even for 2-dimension it still does the same

x = reshape(arange(-8, 8), (4,4))
x
array([[-8, -7, -6, -5], [-4, -3, -2, -1], [ 0,
6, 7]])

1,

2,

3], [ 4,

5,

x[x<0]
array([-8, -7, -6, -5, -4, -3, -2, -1])

Here is another example to demonstrate logical indexing:

from math import isnan
a = [[3, 4, float('NaN')], [5, 9, 8], [3, 3, 2], [9, -1,
float('NaN')]]
list2 = [3, 4, 5, 6]
list1_valid = [elem for elem in list1 if not any([isnan(element) for
element in elem])]
list1_valid
[[3, 7, 8], [1, 1, 1]]
list2_valid = [list2[index] for index, elem in enumerate(list1) if not
any([isnan(element) for element in elem])]
list2_valid
[4, 5]
[ 142 ]

Chapter 4

Other data structures

Python has data structures such as stacks, lists, sets, sequences, tuples, lists, heaps,
arrays, dictionaries, and deque. We have already discussed lists while attempting
to understand arrays. Tuples are typically more memory efficient than lists because
they are immutable.

Stacks
The list method is very convenient to be used as a stack, which is known to be
an abstract data type with the principle of operation last-in, first-out. The known
operations include adding of an item at the top of the stack using append(),
extracting of the item from the top of the stack using pop(), and removing of the
item using remove(item-value), as shown in the following code:
stack = [5, 6, 8]
stack.append(6)
stack.append(8)
stack
[5, 6, 8, 6, 8]
stack.remove(8)
stack
[5, 6, 6, 8]
stack.pop()
8
stack.remove(8)
Traceback (most recent call last):
File "<ipython-input-339-61d6322e3bb8>", line 1, in <module>
stack.remove(8)
ValueError: list.remove(x): x not in list

The pop() function is most efficient (constant-time) because all the other elements
remain in their location. However, the parameterized version, pop(k), removes the
element that is at the k < n index of a list, shifting all the subsequent elements to
fill the gap that results from the removal. The efficiency of this operation is linear
because the amount of shifting depends on the choice of index k, as illustrated in the
following image:

[ 143 ]

Numerical Computing and Interactive Plotting

Tuples
A tuple is a sequence of immutable objects that look similar to lists. Tuples are
heterogeneous data structures, which means that their elements have different
meanings, whereas lists are a homogeneous sequence of elements. Tuples have
structure, and lists have order. Some examples of tuples are days of the week, course
names, and grading scales, as shown in the following code:
#days of the week
weekdays = ("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
"Friday", "Saturday")
#course names
courses = ("Chemistry", "Physics", "Mathematics", "Digital Logic",
"Circuit Theory")
#grades
grades = ("A+", "A", "B+", "B", "C+", "C", "I")

Tuples have immutable objects. This means that you cannot change or remove them
from tuple. However, the tuple can be deleted completely, for example, "del grades"
will delete this tuple. After this, if an attempt is made to use that tuple, an error will
occur. The following are the built-in tuple functions:

cmp(tup1, tup2): This function can be used to compare the elements of two

len(tuple): This function can be used to get the total length of the tuple

tuples

max(tuple): This function can be used to determine the maximum value in

the tuple

min(tuple): This function can be used to determine the minimum value in

the tuple

tuple(lista): This function can be used to convert lista to tuple

Python has a max() function that behaves as expected for numerical values.
However, if we pass a list of strings, max() returns the item that is the longest.
weekdays = ("Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
"Friday", "Saturday")
print max(weekdays)
Wednesday

Similarly min() has the same behavior for strings.

print min(weekdays)
Friday
[ 144 ]

Chapter 4

When we need to find how many elements are in an array or list, len() is a
convenient method that does the job.
len(weekdays)
7

Sets
Sets are similar to lists, but are different in two aspects. Firstly, they are an unordered
collection as compared to lists (which are ordered by location or index). Secondly,
they do not have duplicates (if you know the mathematical definition of sets). The
notation used for a set is shown in the following command:
setoftrees = { 'Basswood', 'Red Pine', 'Chestnut', 'Gray Birch',
'Black Cherry'}
newtree = 'Tulip Tree'
if newtree not in setoftrees:

setoftrees.add(newtree)

Now with this command, you can see what is on setoftrees:

setoftrees # typing this shows list of elements shown below
{'Basswood', 'Black Cherry', 'Chestnut', 'Gray Birch', 'Red Pine',
'Tulip Tree'}

Then, build charsinmath and charsinchem using the appropriate spelling, as shown
in the following code
#example of set of operation on letters
charsinmath = set('mathematics')
charsinchem = set('chem')

Now, let's try to see what the values are in these sets:
Charsinmath # typing this shows letters in charsinmath
{'a', 'c', 'e', 'h', 'i', 'm', 's', 't'}
charsinchem # typing this shows letters in charsinchem
{'c', 'e', 'h', 'm'}

In order to find the set difference, we need to display charsinmath charsinchem

as follows:
# take away letters from charsinchem from charsinmath
charsinmath - charsinchem
{'a', 'i', 's', 't'}

[ 145 ]

Numerical Computing and Interactive Plotting

Queues
Just like stacks, it is possible to use a list as a queue. However, the difference is that
elements can be added or removed from the end of the list or from the beginning of the
list. Although adding and removing from the end of a list is efficient, doing the same
from the beginning is not efficient because in this case, elements have to be shifted.
Fortunately, Python has deque in its collections package that efficiently implements
the adding and removing of elements from both ends using append(), pop(),
appendleft(), and popleft(), as shown in the following code:
from collections import deque
queue = deque(["Daniel", "Sid", "Mathew", "Michael"])
queue.append("Dirk")
# Dirk arrives
queue.append("Monte")
# Monte arrives queue
queue
deque(['Daniel', 'Sid', 'Mathew', 'Michael', 'Dirk', 'Monte'])
queue.popleft()
'Daniel'
queue.pop()
'Monte'
queue.appendleft('William')
queue
deque(['William', 'Sid', 'Mathew', 'Michael', 'Dirk'])
queue.append('Lastone')
queue
deque(['William', 'Sid', 'Mathew', 'Michael', 'Dirk', 'Lastone'])

Dictionaries
Dictionaries are a collection of unordered data values that are composed of a
key/value pair, which has the unique advantage of accessing a value based on the
key as an index. The question is that if the key is a string, then how does the indexing
work? The key has to be hashable: a hash function is applied on the key to extract
the location where the value is stored. In other words, the hash function takes a key
value and returns an integer. Dictionaries then use these integers (or hash values) to
store and retrieve the value. Some examples are shown here:

[ 146 ]

Chapter 4
#example 1: Top 10 GDP of Africa
gdp_dict = { 'South Africa': 285.4, 'Egypt': 188.4, 'Nigeria': 173,
'Algeria': 140.6, 'Morocco': 91.4, 'Angola': 75.5, 'Libya': 62.3,
'Tunisia': 39.6, 'Kenya': 29.4, 'Ethiopia': 28.5, 'Ghana': 26.2,
'Cameron': 22.2}
gdp_dict['Angola']
75.5
#example 2: English to Spanish for numbers one to ten
english2spanish = { 'one' : 'uno', 'two' : 'dos', 'three': 'tres',
'four': 'cuatro', 'five': 'cinvo', 'six': 'seis', 'seven': 'seite',
'eight': 'ocho', 'nine': 'nueve', 'ten': 'diez'}
english2spanish['four']
'cuatro'

The keys should be immutable to have a predictable hash value; otherwise, the hash
value change will result in a different location. Also, unpredictable things could
occur. The default dictionary does not keep the values in the order they is inserted;
therefore, by iterating after the insertion, the order of the key/value pair is arbitrary.
Python's collections package has an equivalent OrderedDict() function that keeps
the order of pairs in the inserted order. One additional difference between the
default dictionary and the ordered dictionary is that in the former, equality always
returns true if they have an identical set of key/value pairs (not necessarily in the
same order), and in the latter, equality returns true only when they have an identical
set of key/value pairs and when they are in the same order. The following example
demonstrates this:
# using default dictionary
dict = {}
dict['cat-ds1']
dict['cat-ds2']
dict['cat-la1']
dict['cat-la2']
dict['cat-pda']
dict['cat-ps1']
dict['cat-ps2']

=
=
=
=
=
=
=

'Introduction to Data Structures'

'Advanced Data Structures'
'Python Programming'
'Advanced Python Programming'
'Python for Data Analysis'
'Data Science in Python'
'Doing Data Science'

for key, val in dict.items():

print key,val

cat-ps1 Data Science in Python

cat-ps2 Doing Data Science
[ 147 ]

Numerical Computing and Interactive Plotting

cat-pda
cat-la2
cat-la1
cat-ds1
cat-ds2

Python for Data Analysis

Advanced Python Programming
Python Programming
Introduction to Data Structures
Advanced Data Structures

#using OrderedDict (inserting data the same way as before)

odict = OrderedDict()
odict['cat-ds1']
odict['cat-ds2']
odict['cat-la1']
odict['cat-la2']
odict['cat-pda']
odict['cat-ps1']
odict['cat-ps2']

=
=
=
=
=
=
=

'Introduction to Data Structures'

'Advanced Data Structures'
'Python Programming'
'Advanced Python Programming'
'Python for Data Analysis'
'Data Science in Python'
'Doing Data Science'

for key, val in odict.items():

cat-ds1
cat-ds2
cat-la1
cat-la2
cat-pda
cat-ps1
cat-ps2

print key,val

Introduction to Data Structures

Advanced Data Structures
Python Programming
Advanced Python Programming
Python for Data Analysis
Data Science in Python
Doing Data Science

If you have to implement something similar to this, it is computationally better to

use the ISBN as the key, rather than the catalog number as in a library. However,
there may be old books that do not have an ISBN; therefore, an equivalent unique
key/value has to be used to maintain consistency with other new books that have an
ISBN number. A hash value is usually a number, and with a numeric key, the hash
function might be much easier compared to an alphanumeric key.

Dictionaries for matrix representation

Usually, there are many examples where you can apply dictionaries when there is
a key/value association. For example, state abbreviations and names; either one
could be the key and the other the value, but it would be more efficient to have the
abbreviation as the key. Other examples are word and word count or city names and
population. One interesting area of computation where dictionaries could really be
efficient is the representation of a sparse matrix.

[ 148 ]

Chapter 4

Sparse matrices
Let's examine the space utilization of a matrix; for a 100 x 100 matrix represented
using a list, each element occupies 4 bytes; therefore, the matrix would need 40,000
bytes, which is approximately 40 KB of space. However, among these 40,000 bytes,
if only 100 of them have a nonzero value and the others are all zero, then the space
is wasted. Now, let's consider a smaller matrix for the simplicity of discussion, as
shown in the following image:

This matrix has approximately 20 percent of nonzero values; therefore, finding an

alternative way to represent the nonzero elements of the matrix would be a good
start. There are seven values of 1, five values of 2 and 3 each, and one value of 4, 6,
and 7. This could be represented as follows:
A = {1: [(2,2),(6,6), (0,7),(1,8),(7,8),(3,9),(8,9)],
2: [(5,2),(8,2),(6,3),(0,4),(0,9)],
3: [(5,0),(8,0),(9,1),(1,3),(5,8)],
4:[(1,1)], 6:[(2,0)], 7:[(2,5)]}

However, this representation makes it harder to access the (i,j)th value of A. There
is a better way to represent this sparse matrix using dictionary, as shown in the
following code:
def getElement(row, col):
if (row,col) in A.keys():
r = A[row,col]
else:
r = 0
return r
A={(0,4): 2, (0,7): 1, (1,1): 4, (1,3):3, (1,8): 1, (2,0): 6, (0,9):
2, (2,2):1, (2,5): 7, (3,9): 1, (5,0): 3, (5,2): 2, (5,8): 3, (6,3):
2, (6,6):1, (7,8): 1, (8,0): 3, (8,2): 2, (8,9): 1, (9,1): 3}

[ 149 ]

Numerical Computing and Interactive Plotting

print getElement(1,3)
3
print getElement(1,2)
0

To access an element at (1, 3) of the matrix A, we could use A[(1, 3)], but if the
key does not exist, it will throw an exception. In order to get the nonzero value
using the key and return 0 if the key does not exist, we can use a function called
getElement(), as shown in the preceding code.

Visualizing sparseness
We can visually see how sparse the matrix is with the help of SquareBox diagrams.
The following image shows the sparseDisplay() function. This uses square boxes
for each matrix entry that attempts to view the display. The black color represents
sparseness, whereas the green color represents nonzero elements:

The following code demonstrates how one can display sparseness:

import numpy as np
import matplotlib.pyplot as plt
"""
SquareBox diagrams are useful for visualizing values of a 2D array,
Where black color representing sparse areas.
"""
def sparseDisplay(nonzero, squaresize, ax=None):
ax = ax if ax is not None else plt.gca()
ax.patch.set_facecolor('black')
ax.set_aspect('equal', 'box')
for row in range(0,squaresize):
for col in range(0,squaresize):
[ 150 ]

Chapter 4
if (row,col) in nonzero.keys():
el = nonzero[(row,col)]
if el == 0: color='black'
else: color = '#008000'
rect = plt.Rectangle([col,row], 1, 1,
facecolor=color, edgecolor=color)
ax.add_patch(rect)
ax.autoscale_view()
ax.invert_yaxis()
if __name__ == '__main__':
nonzero={(0,4): 2, (0,7): 1, (1,1): 4, (1,3): 3, (1,8): 1,
(2,0): 6, (0,9): 2, (2,2): 1, (2,5): 7, (3,9): 1, (5,0): 3,
(5,2): 2, (5,8): 3, (6,3): 2, (6,6): 1, (7,8): 1, (8,0): 3, (8,2): 2,
(8,9): 1, (9,1): 3}
plt.figure(figsize=(4,4))
sparseDisplay(nonzero, 10)
plt.show()

This is only a quick example to display the sparse matrix. Imagine that you have a 30
x 30 matrix with only a few nonzero values, then the display would look somewhat
similar to the following image. The saving in this case is 97 percent as far as space
utilization is concerned. In other words, the larger the matrix, the lesser the space
utilized, as shown in the following image:

Having found a way to store the sparse matrix using dictionary, you may have to
remember that there is no need to reinvent the wheel. Moreover, it makes sense
to consider the possibility of storing the sparse matrix to understand the power of
dictionary. However, what is really recommended is to take a look at the SciPy and
pandas package for the sparse matrix. There may be further opportunities in this
book to use these approaches in some examples.
[ 151 ]

Numerical Computing and Interactive Plotting

Dictionaries for memoization

Memoization is an optimization technique in computational science that enables one
to store intermediate results, which otherwise could be expensive. Not every problem
needs memoization, but when there is a pattern of computing the same values by
calling the function, it is often useful to use this approach. One example where this
approach can be used is in the computation of the Fibonacci function using the
dictionary to store the already computed value, so next time, you can just search for
the value, rather than recompute it again, as shown in the following code:
fibvalues = {0: 0, 1: 1, 2:1, 3:2, 4:3, 5:5}
def fibonacci(n):
if n not in fibvalues:
sumvalue = fibonacci(n-1) + fibonacci(n-2)
fibvalues[n] = sumvalue
return fibvalues[n]
fibonacci(40)
102334155

print sorted(fibvalues.values())
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987,
1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393,
196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887,
9227465, 14930352, 24157817, 39088169, 63245986, 102334155]
#regular fibonacci without using dictionary
def fib(n):
if n <= 1 : return 1
sumval = fib(n-1)+fib(n-2)
return sumval

The dictionary of fibvalues is very useful to prevent the recomputation of the

values of Fibonacci, but fibcalled is used here only to demonstrate that by using
dictionary, there cannot be more than one call to fibonacci() for a particular value
of n. By comparing the ratio of the running times for fib() (without using dictionary
to store the computed value) and fibonacci(), we can see that when plotted, it
looks similar to the following screenshot:

[ 152 ]

Chapter 4

from time import time

for nval in range(16,27):
fibvalues = {0: 0, 1: 1, 2:1, 3:2, 4:3, 5:5}
t3 = time()
fibonacci(nval)
diftime1 = time()-t3
t2 = time()
fib(nval)
diftime2 = time()-t2
print "The ratio of time-2/time-1 :"+str(diftime2/diftime1)

Tries
Trie (pronounced trie or trai) is a data structure that has different names (digital tree,
radix tree, or prefix tree). Tries are very efficient for search, insert, and delete functions.
This data structure is very optimal for storage. For example, when the words add,
also, algebra, assoc, all, to, trie, tree, tea, and ten are stored in the trie, it will look similar
to the following diagram:

[ 153 ]

Numerical Computing and Interactive Plotting

The characters are shown in uppercase just for clarity purposes in the preceding
diagram, whereas in real storage, the characters are stored as they appear in words.
In the implementation of trie, it makes sense to store the word count. The search
functionality is very efficient and in particular when the pattern does not match, the
results are even quicker. In other words, if the search is for are, then the failure is
determined at the level when the letter r is not found.
One of the popular functionalities is longest prefix matching. In other words, if we
were to find all the words in the dictionary that have the longest prefix match with a
particular search string: base (for example). The results could be base, based, baseline,
or basement, or even more words if they are found in the dictionary of words.
Python has many different implementations: suffix_tree, pytire, trie, datrie,
and so on. There is a nice comparison study done by J. F. Sebastian that can be
accessed at https://github.com/zed/trie-benchmark.
Most search engines have an implementation of trie called inverted index. This is the
central component where space optimization is very important. Moreover, searching
for this kind of structure is very efficient to find the relevance between
the search string and the documents. Another interesting application of trie is IP
routing, where the ability to contain large ranges of values is particularly suitable.
It also saves space.
A simple implementation in Python (not necessarily the most efficient) is shown in
the following code:
_end = '_end_'
# to search if a word is in trie
def in_trie(trie, word):
current_dict = trie
for letter in word:
if letter in current_dict:
current_dict = current_dict[letter]
else:
return False
else:
if _end in current_dict:
return True
else:
return False
#create trie stored with words
def create_trie(*words):
root = dict()
[ 154 ]

Chapter 4
for word in words:
current_dict = root
for letter in word:
current_dict = current_dict.setdefault(letter, {})
current_dict = current_dict.setdefault(_end, _end)
return root
def insert_word(trie, word):
if in_trie(trie, word): return
current_dict = trie
for letter in word:
current_dict = current_dict.setdefault(letter, {})
current_dict = current_dict.setdefault(_end, _end)
def remove_word(trie, word):
current_dict = trie
for letter in word:
current_dict = current_dict.get(letter, None)
if current_dict is None:
# the trie doesn't contain this word.
break
else:
del current_dict[_end]
dict = create_trie('foo', 'bar', 'baz', 'barz', 'bar')
print dict
print in_trie(dict, 'bar')
print in_trie(dict, 'bars')
insert_word(dict, 'bars')
print dict
print in_trie(dict, 'bars')

Visualization using matplotlib

matplotlib has been a popular plotting package besides a few other that are
available today. The capability of matplotlib is now being realized by the Python

community. John Hunter, the creator and project leader of this package summed it
up as matplotlib tries to make easy things easy and hard things possible. You can generate
very high-quality, publication-ready graphs with very little effort. In this section, we
will pick a few interesting examples to illustrate the power of matplotlib.

[ 155 ]

Numerical Computing and Interactive Plotting

Word clouds
Word clouds give greater prominence to words that appear more frequently in any
given text. They are also called tag clouds or weighted words. You can tweak word
clouds with different fonts, layouts, and color schemes. The significance of a word's
strength in terms of the number of occurrences visually maps to the size of their
appearance. In other words, the word that appears the largest in visualization is the
one that has appeared the most in the text.
Beyond the obvious map to their occurrences, word clouds have several useful
applications for social media and marketing. Some of the applications are as follows:

Businesses can get to know their customers and how they view their
products. Some organizations have used a very creative method of asking
their fans or followers to post words about what they think of their brand,
taking all these words into a word cloud to better understand the most
common impressions of their product brand.

Finding ways to learn about their competitors by identifying a brand whose

online presence is popular. Creating a word cloud from their content to
better understand what words and themes hook the product target market.

In order to create a word cloud, you can write the Python code or use something
that already exists. Andreas Mueller from the NYU Center for Data Science created
a pretty simple and easy-to-use word cloud in Python. It can be installed with the
instructions given in the next section.

Installing word clouds

For faster installation, you can just use pip with sudo access, as shown in the
following code:
sudo pip install git+git://github.com/amueller/word_cloud.git

Alternatively, you can obtain the package via wget on Linux or curl on Mac OS with
the following code:
wget https://github.com/amueller/word_cloud/archive/master.zip
unzip master.zip
rm master.zip
cd word_cloud-master
sudo pip install -r requirements.txt

[ 156 ]

Chapter 4

For the Anaconda IDE, you will have to install it using conda with the following
three steps:
#step-1 command
conda install wordcloud

Fetching package metadata: ....

Error: No packages found in current osx-64 channels matching: wordcloud

You can search for this package on Binstar with

# This only means one has to search the source location
binstar search -t conda wordcloud

Run 'binstar show <USER/PACKAGE>' to get more details:

Packages:
Name | Access

| Package Types

------------------------- | ------------ | --------------- |

derickl/wordcloud | public

| conda

Found 1 packages

# step-2 command
binstar show derickl/wordcloud

Using binstar api site https://api.binstar.org

Name:

wordcloud

Summary:
Access:

public

Package Types:

conda

Versions:
+ 1.0

To install this package with conda run:

conda install --channel https://conda.binstar.org/derickl wordcloud

# step-3 command
conda install --channel https://conda.binstar.org/derickl wordcloud

[ 157 ]

Numerical Computing and Interactive Plotting

Fetching package metadata: ......
Solving package specifications: .
Package plan for installation in environment /Users/MacBook/anaconda:

The following packages will be downloaded:

package

build

---------------------------|----------------cython-0.22

py27_0

2.2 MB

django-1.8

py27_0

3.2 MB

pillow-2.8.1

py27_1

454 KB

image-1.3.4

py27_0

24 KB

setuptools-15.1

py27_1

435 KB

wordcloud-1.0

np19py27_1

58 KB

conda-3.11.0

py27_0

167 KB

-----------------------------------------------------------Total:

The following NEW packages will be INSTALLED:

django:

1.8-py27_0

image:

1.3.4-py27_0

pillow:

2.8.1-py27_1

wordcloud:

1.0-np19py27_1

The following packages will be UPDATED:

conda:

3.10.1-py27_0 --> 3.11.0-py27_0

cython:

0.21-py27_0

--> 0.22-py27_0

setuptools: 15.0-py27_0

--> 15.1-py27_1

The following packages will be DOWNGRADED:

libtiff:

4.0.3-0

--> 4.0.2-1

Proceed ([y]/n)? y
[ 158 ]

6.5 MB

Chapter 4

Input for word clouds

In this section, there will be two sources where you can extract words to construct
word clouds. The first example shows how to extract text from the web feeds of
some known websites and how to extract the words from its description. The second
example shows how to extract text from tweets with the help of search keywords.
The two examples will need the feedparser package and the tweepy package, and
by following similar steps (as mentioned for other packages previously), you can
easily install them.
Our approach will be to collect words from both these examples and use them as the
input for a common word cloud program.

Web feeds
There are well grouped and structured RSS or atom feeds in most of the news and
technology service websites today. Although our aim is to restrict the context to
technology alone, we can determine a handful of feed lists, as shown in the following
code. In order to be able to parse these feeds, the parser() method of feedparser
comes in handy. Word cloud has its own stopwords list, but in addition to this, we
can also use one while collecting the data, as shown here (stopwords here is not
complete, but you can gather more from any known resource on the Internet):
import feedparser
from os import path
import re
d = path.dirname(__file__)
mystopwords = [ 'test', 'quot', 'nbsp']
feedlist = ['http://www.techcrunch.com/rssfeeds/',
'http://www.computerweekly.com/rss',
'http://feeds.twit.tv/tnt.xml',
'https://www.apple.com/pr/feeds/pr.rss',
'https://news.google.com/?output=rss'
'http://www.forbes.com/technology/feed/'
'http://rss.
nytimes.com/services/xml/rss/nyt/Technology.xml',
'http://www.
nytimes.com/roomfordebate/topics/technology.rss',
'http://feeds.webservice.techradar.com/us/rss/reviews'
'http://feeds.webservice.techradar.com/us/rss/news/software',
'http://feeds.webservice.techradar.com/us/rss',
'http://www.cnet.com/rss/',
'http://feeds.feedburner.com/ibm-big-data-hub?format=xml',
'http://feeds.feedburner.com/ResearchDiscussions-DataScien
ceCentral?format=xml',
'http://feeds.feedburner.com/
BdnDailyPressReleasesDiscussions-BigDataNews?format=xml',
[ 159 ]

Numerical Computing and Interactive Plotting

'http://http://feeds.feedburner.com/ibm-big-data-hubgalleries?format=xml',
'http://http://feeds.feedburner.com/
PlanetBigData?format=xml',
'http://rss.cnn.com/rss/cnn_tech.rss',
'http://news.yahoo.com/rss/tech',
'http://slashdot.org/slashdot.rdf',
'http://bbc.com/news/technology/']
def extractPlainText(ht):
plaintxt=''
s=0
for char in ht:
if char == '<': s = 1
elif char == '>':
s = 0
plaintxt += ' '
elif s == 0: plaintxt += char
return plaintxt
def separatewords(text):
splitter = re.compile('\\W*')
return [s.lower() for s in splitter.split(text) if len(s) > 3]
def combineWordsFromFeed(filename):
with open(filename, 'w') as wfile:
for feed in feedlist:
print "Parsing " + feed
fp = feedparser.parse(feed)
for e in fp.entries:
txt = e.title.encode('utf8') +
extractPlainText(e.description.encode('utf8'))
words = separatewords(txt)
for word in words:
if word.isdigit() == False and word not in mystopwords:
wfile.write(word)
wfile.write(" ")
wfile.write("\n")
wfile.close()
return
combineWordsFromFeed("wordcloudInput_FromFeeds.txt")

[ 160 ]

Chapter 4

The Twitter text

In order to access the Twitter API, you will need the access token and consumer
credentials that consist of four parameters: access_token, access_token_secret,
consumer_key, and consumer_secret. In order to obtain these keys, you will have
to use a Twitter account. The steps involved in obtaining these keys are available on
the Twitter website. The steps involved are:
1. Log in to the Twitter account.
2. Navigate to developer.twitter.com and use Manage My Apps to follow
through and obtain the parameters mentioned before.
Assuming that these parameters are ready, with the tweepy package, you can access
tweets via Python. The following code displays a simple custom stream listener.
Here, as the tweets are streamed, there is a listener that listens to the status and
writes the state to a file. This can be used later to create word clouds.
The stream uses a filter to narrow the Twitter text that is focused on the Python
program, data visualization, big data, machine learning, and statistics. The tweepy stream
provides the tweets that are extracted. This can run forever because there is unlimited
data available out there. How do we set it to stop? The accessing speed may be slower
than you would expect, and for the purposes of creating a word cloud, you would
imagine that extracting a certain number of tweets is probably sufficient. We therefore
set a limit and called it MAX_TWEETS to be 50, as shown in the following code:
import
import
import
import

tweepy
json
sys
codecs

counter = 0
MAX_TWEETS = 500
#Variables that contains the user credentials to access Twitter API
access_token = "Access Token"
access_token_secret = "Access Secret"
consumer_key = "Consumer Key"
consumer_secret = "Consumer Secret"
fp = codecs.open("filtered_tweets.txt", "w", "utf-8")
class CustomStreamListener(tweepy.StreamListener):
def on_status(self, status):
global counter
[ 161 ]

Numerical Computing and Interactive Plotting

fp.write(status.text)
print "Tweet-count:" +str(counter)
counter += 1
if counter >= MAX_TWEETS: sys.exit()
def on_error(self, status):
print status
if __name__ == '__main__':
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
streaming_api = tweepy.streaming.Stream(auth,
CustomStreamListener(), timeout=60)
streaming_api.filter(track=['python program', 'statistics',
'data visualization', 'big data', 'machine learning'])

Using any bag of words, you can write fewer than 20 lines of the Python code to
generate word clouds. A word cloud generates an image, and using matplotlib.
pyplot, you can use imshow() to display the word cloud image. The following word
cloud can be used with any input file of words:
from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt
from os import path
d = path.dirname("__file__")
text = open(path.join(d, 'filtered_tweets.txt')).read()
wordcloud = WordCloud(
font_path='/Users/MacBook/kirthi/RemachineScript.ttf',
stopwords=STOPWORDS,
background_color='#222222',
width=1000,
height=800).generate(text)
# Open a plot of the generated image.
plt.figure(figsize=(13,13))
plt.imshow(wordcloud)
plt.axis("off")
plt.show()

[ 162 ]

Chapter 4

The required font file can be downloaded from any of a number of sites
(one specific resource for this font is available at http://www.dafont.com/
remachine-script.font). Wherever the font file is located, you will have to use this
exact path set to font_path. For using the data from feeds, there is only one line that
changes, as shown in the following code:
text = open(path.join(d, 'wordcloudInput_fromFeeds.txt')).read()

[ 163 ]

Numerical Computing and Interactive Plotting

Using the similar idea of extracting text from tweets to create word clouds, you could
extract text within the context of mobile phone vendors with keywords, such as iPhone,
Samsung Galaxy, Amazon Fire, LG Optimus, Nokia Lumia, and so on, to determine the
sentiments of consumers. In this case, you may need an additional set of information,
that is, the positive and negative sentiment values associated with words.
There are a few approaches that you can follow in a sentiment analysis on tweets in a
restricted context. First, a very nave approach would be to just associate weights to
words that correspond to a positive sentiment as wp and a negative sentiment as wn,
applying the following notation p(+) as the probability of a positive sentiment and
p(-) for a negative sentiment:

The second approach would be to use a natural language processing tool and apply
trained classifiers to obtain better results. TextBlob is a text processing package that
also has sentiment analysis (http://textblob.readthedocs.org/en/dev).
TextBlob builds a text classification system and creates a training set in the JSON
format. Later, using this training and the Nave Bayes classifier, it performs the
sentiment analysis. We will attempt to use this tool in later chapters to demonstrate
our working examples.

Plotting the stock price chart

The two biggest stock exchanges in the U.S. are the New York Stock Exchange (NYSE),
founded in 1792 and the NASDAQ founded in 1971. Today, most stock market trades
are executed electronically. Even the stocks themselves are almost always held in the
electronic form, not as physical certificates. There are numerous other websites that also
provide real-time stock price data, apart from NASDAQ and NYSE.

Obtaining data
One of the websites to obtain data is Yahoo, which provides data via the API, for
example, to obtain the stock price (low, high, open, close, and volume) of Amazon,
the URL is http://chartapi.finance.yahoo.com/instrument/1.0/amzn/
chartdata;type=quote;range=3y/csv. Depending on the plotting method you
select, there is some data conversion that is required. For instance, the data obtained
from this resource includes date in a format that does not have any format, as shown
in the following code:

[ 164 ]

Chapter 4
uri:/instrument/1.0/amzn/chartdata;type=quote;range=3y/csv
ticker:amzn
Company-Name:Amazon.com, Inc.
Exchange-Name:NMS
unit:DAY
timestamp:
first-trade:19970516
last-trade:20150430
currency:USD
previous_close_price:231.9000
Date:20120501,20150430
labels:20120501,20120702,20121001,20130102,20130401,20130701,20131001,
20140102,20140401,20140701,20141001,20150102,20150401
values:Date,close,high,low,open,volume
close:208.2200,445.1000
high:211.2300,452.6500
low:206.3700,439.0000
open:207.4000,443.8600
volume:984400,23856100
20120501,230.0400,232.9700,228.4000,229.4000,6754900
20120502,230.2500,231.4400,227.4000,227.8200,4593400
20120503,229.4500,232.5300,228.0300,229.7400,4055500
...
...
20150429,429.3700,434.2400,426.0300,426.7500,3613300
20150430,421.7800,431.7500,419.2400,427.1100,3609700

We will discuss three approaches in creating the plots. Each one has its own
advantages and limitations.
In the first approach, with the matplotlib.cbook package and the pylab package,
you can create a plot with the following lines of code:
from pylab import plotfile show, gca
import matplotlib.cbook as cbook
fname = cbook.get_sample_data('/Users/MacBook/stocks/amzn.csv',
asfileobj=False)
plotfile(fname, ('date', 'high', 'low', 'close'), subplots=False)
show()

[ 165 ]

Numerical Computing and Interactive Plotting

This will create a plot similar to the one shown in the following screenshot:

There is one additional programming effort that is required before attempting to plot
using this approach. The date values have to be formatted to represent 20150430 as
%d-%b-%Y. With this approach, the plot can also be split into two, one showing the
stock price and the other showing the volume, as shown in the following code:
from pylab import plotfile show, gca
import matplotlib.cbook as cbook
fname = cbook.get_sample_data('/Users/MacBook/stocks/amzn.csv',
asfileobj=False)
plotfile(fname, (0,1,5), plotfuncs={f:'bar'})
show()

[ 166 ]

Chapter 4

The second approach is to use the subpackages of matplotlib.mlab and

matplotlib.finance. This has convenient methods to fetch the stock data from
http://ichart.finance.yahoo.com/table.csv?s=GOOG&a=04&b=12&c=2014&d=0
6&e=20&f=2015&g=d, and to just show a sample, here is a code snippet:
ticker='GOOG'
import matplotlib.finance as finance
import matplotlib.mlab as mlab
import datetime
startdate = datetime.date(2014,4,12)
today = enddate = datetime.date.today()
fh = finance.fetch_historical_yahoo(ticker, startdate, enddate)
r = mlab.csv2rec(fh); fh.close()
r.sort()
print r[:2]
[ (datetime.date(2014, 4, 14), 538.25, 544.09998, 529.56, 532.52002,
2568000, 532.52002) (datetime.date(2014, 4, 15), 536.82001,
538.45001, 518.46002, 536.44, 3844500, 536.44)]

When you attempt to plot the stock price comparison, it does not make sense to
display the volume information because for each stock ticker, the volumes are
different. Also, it becomes too cluttered to view the stock chart.
[ 167 ]

Numerical Computing and Interactive Plotting

matplotlib already has a working example to plot the stock chart, which is
elaborate enough and includes Relative Strength Indicator (RSI) and Moving
Average Convergence/Divergence (MACD), and is available at http://
matplotlib.org/examples/pylab_examples/finance_work2.html. For details
on RSI and MACD, you can find many resources online, but there is one interesting
explanation at http://easyforextrading.co/how-to-trade/indicators/.

In an attempt to use the existing code, modify it, and make it work for multiple
charts, a function called plotTicker() was created. This helps in plotting each ticker
within the same axis, as shown in the following code:
import datetime
import numpy as np
import
import
import
import

matplotlib.finance as finance
matplotlib.dates as mdates
matplotlib.mlab as mlab
matplotlib.pyplot as plt

startdate = datetime.date(2014,4,12)
today = enddate = datetime.date.today()
plt.rc('axes', grid=True)
plt.rc('grid', color='0.75', linestyle='-', linewidth=0.5)
rect = [0.4, 0.5, 0.8, 0.5]
fig = plt.figure(facecolor='white', figsize=(12,11))
axescolor = '#f6f6f6' # the axes background color
ax = fig.add_axes(rect, axisbg=axescolor)
ax.set_ylim(10,800)
def plotTicker(ticker, startdate, enddate, fillcolor):
"""
matplotlib.finance has fetch_historical_yahoo() which fetches
stock price data the url where it gets the data from is
http://ichart.yahoo.com/table.csv stores in a numpy record
array with fields:
date, open, high, low, close, volume, adj_close
"""
fh = finance.fetch_historical_yahoo(ticker, startdate, enddate)
r = mlab.csv2rec(fh);
fh.close()
r.sort()
[ 168 ]

Chapter 4
### plot the relative strength indicator
### adjusted close removes the impacts of splits and dividends
prices = r.adj_close
### plot the price and volume data
ax.plot(r.date, prices, color=fillcolor, lw=2, label=ticker)
ax.legend(loc='top right', shadow=True, fancybox=True)
# set the labels rotation and alignment
for label in ax.get_xticklabels():
# To display date label slanting at 30 degrees
label.set_rotation(30)
label.set_horizontalalignment('right')
ax.fmt_xdata = mdates.DateFormatter('%Y-%m-%d')
#plot the tickers now
plotTicker('BIDU', startdate, enddate, 'red')
plotTicker('GOOG', startdate, enddate, '#1066ee')
plotTicker('AMZN', startdate, enddate, '#506612')
plt.show()

When you use this to compare the stock prices of Bidu, Google, and Amazon, the
plot would look similar to the following screenshot:

[ 169 ]

Numerical Computing and Interactive Plotting

Use the following code to compare the stock prices of Twitter, Facebook,
and LinkedIn:
plotTicker('TWTR', startdate, enddate, '#c72020')
plotTicker('LNKD', startdate, enddate, '#103474')
plotTicker('FB', startdate, enddate, '#506612')

Now, you can add the volume plot as well. For a single ticker plot with volume, use
the following code:
import datetime
import
import
import
import

matplotlib.finance as finance
matplotlib.dates as mdates
matplotlib.mlab as mlab
matplotlib.pyplot as plt

startdate = datetime.date(2013,3,1)
today = enddate = datetime.date.today()
rect = [0.1, 0.3, 0.8, 0.4]
fig = plt.figure(facecolor='white', figsize=(10,9))
ax = fig.add_axes(rect, axisbg='#f6f6f6')

[ 170 ]

Chapter 4
def plotSingleTickerWithVolume(ticker, startdate, enddate):
global ax
fh = finance.fetch_historical_yahoo(ticker, startdate, enddate)
# a numpy record array with fields:
#
date, open, high, low, close, volume, adj_close
r = mlab.csv2rec(fh);
fh.close()
r.sort()
plt.rc('axes', grid=True)
plt.rc('grid', color='0.78', linestyle='-', linewidth=0.5)
axt = ax.twinx()
prices = r.adj_close
fcolor = 'darkgoldenrod'
ax.plot(r.date, prices, color=r'#1066ee', lw=2, label=ticker)
ax.fill_between(r.date, prices, 0, prices, facecolor='#BBD7E5')
ax.set_ylim(0.5*prices.max())
ax.legend(loc='upper right', shadow=True, fancybox=True)
volume = (r.close*r.volume)/1e6
vmax = volume.max()

# dollar volume in millions

axt.fill_between(r.date, volume, 0, label='Volume',

facecolor=fcolor, edgecolor=fcolor)
axt.set_ylim(0, 5*vmax)
axt.set_yticks([])
for axis in ax, axt:
for label in axis.get_xticklabels():
label.set_rotation(30)
label.set_horizontalalignment('right')
axis.fmt_xdata = mdates.DateFormatter('%Y-%m-%d')
plotSingleTickerWithVolume ('MSFT', startdate, enddate)
plt.show()
[ 171 ]

Numerical Computing and Interactive Plotting

With the single ticker plot along with volume and the preceding changes in the
earlier code, the plot will look similar to the following screenshot:

You may also have the option of using the third approach: using the blockspring
package. In order to install blockspring, you have to use the following pip command:
pip install blockspring

Blockspring's approach is to generate the HTML code. It autogenerates data for the
plots in the JavaScript format. When this is integrated with D3.js, it provides a very
nice interactive plot. Amazingly, there are only two lines of code:
import blockspring
import json
print blockspring.runParsed("stock-price-comparison",
{ "tickers": "FB, LNKD, TWTR",
"start_date": "2014-01-01", "end_date": "2015-01-01" }).params

Depending on the operating system, when this code is run, it generates the HTML
code in a default area.

[ 172 ]

Chapter 4

The visualization example in sports

Let's consider a different example here to illustrate the various different approaches
to visualizing data. Instead of choosing a computational problem, we will restrict
ourselves to a simple set of data, and show how many different analyses can be done
that ultimately result in visualizations, to help in clarifying these analyses.
There are several major league sports in North American sports, and we will
compare four of them: The National Football League (NFL), Major League Baseball
(MLB), National Basketball Association (NBA), and National Hockey League. NFL
has a combined team value of 9.13 billion dollars and a total revenue of 9.58 billion
dollars. We will select this sport with the following data of team values and their
championships (only part of the data is shown here):

[ 173 ]

Numerical Computing and Interactive Plotting

The team value is one significant factor in comparing different teams, but
championships also have a value. A simple plot of this data with years completed
along the x axis, the number of championships along the y axis, and the bubble size
representing the number of championship per year average would give us something
similar to the following image:

However, unless you can make it interactive by displaying the labels or details,
the preceding plot may not be very useful. The preceding plot is possible with
matplotlib, as shown in the following code:
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(15,10), facecolor='w')
def plotCircle(x,y,radius,color, alphaval):
circle = plt.Circle((x, y), radius=radius, fc=color,\
alpha=alphaval)
fig.gca().add_patch(circle)
nofcircle = plt.Circle((x, y), radius=radius, ec=color, \
fill=False)
fig.gca().add_patch(nofcircle)
x = [55,83,90,13,55,82,96,55,69,19,55,95,62,96,82,30,22,39, \
54,50,69,56,58,55,55,47,55,20,86,78,56]
y = [5,3,4,0,1,0,1,3,5,2,2,0,2,4,6,0,0,1,0,0,0,0,1,1,0,0,3,0, \
0,1,0]
r = [23,17,15,13,13,12,12,11,11,10,10,10,10,10,9,9,9,8,8,8,8, \
8,8,8,7,7,7,7,6,6,6]
for i in range(0,len(x)):
plotCircle(x[i],y[i],r[i],'b', 0.1)

plt.axis('scaled')
plt.show()
[ 174 ]

Chapter 4

You can even use this numeric data to convert into a format that JavaScript can
understand (JSON format) so that when integrated with an SVG map, it is possible to
display the valuation on the map, as shown in the following screenshot:

The preceding map with bubbles would be better if there were associated labels
displayed. However, due to the lack of space in certain regions of the map, it would
make much more sense to add an interactive implementation to this map and have
the information displayed via navigation.
You can refer to the original data source at http://tinyurl.com/oyxk72r.
An alternate source is available at http://www.knapdata.com/python/nfl_
franch.html.
There are several other visualization methods you could apply, apart from the
plain bubble chart and the bubble chart on maps. One of the visual formats that
will look cluttered when displaying the statistics of 32 teams would be a pie chart
or a bar chart.

[ 175 ]

Numerical Computing and Interactive Plotting

It not only looks cluttered, the labels are hardly readable. The whole point in
showing this pie chart is to illustrate that in this sort of data, one has to seek alternate
methods of visualization, as shown in the following image:

If we combine a set of teams within a certain range of their team value, then by
reducing them, we may be able to show them in a more organized fashion, as shown
in the following image:

[ 176 ]

Chapter 4

The preceding image is one alternative to display the value of teams by segregating
them into groups, for example, denote 2300 million dollars for $2300,000,000, which
means 2300 million dollars. This way, the data labels are readable.

Summary
During the last several decades, computing has emerged as a very important
part of many fields. In fact, the curriculum of computer science in many schools,
such as Stanford, UC-Berkeley, MIT, Princeton, Harvard, Caltech, and so on, has
been revised to accommodate interdisciplinary courses because of this change. In
most scientific disciplines, computational work is an important complement to
experiments and theory. Moreover, a vast majority of experimental and theoretical
papers involve some numerical calculations, simulations, or computer modeling.
Python has come a long way, and today the community of Python has grown to the
extent that there are sources and tools to help write minimal code to accomplish
almost everything that one may need in computing very efficiently. We could only
pick a few working examples in this chapter, but in the following chapters, we will
take a look at more examples.
[ 177 ]

Get more information Mastering Python Data Visualization

Where to buy this book

You can buy Mastering Python Data Visualization from the Packt Publishing website.
Alternatively, you can buy the book from Amazon, BN.com, Computer Manuals and most internet
book retailers.
Click here for ordering and shipping details.

www.PacktPub.com

Stay Connected: