Python For Data Science Cheat Sheet

Selecting List Elements

Import libraries

>>> import numpy

>>> import numpy as np

Selective import

>>> from math import pi

>>> help(str)

Python For Data Science Cheat Sheet

Python Basics

Learn More Python for Data Science Interactively at www.datacamp.com

Variable Assignment

Strings

>>> x=5

>>> x

>>> x+2 Sum of two variables

>>> x-2 Subtraction of two variables

>>> x*2 Multiplication of two variables

>>> x**2 Exponentiation of a variable

>>> x%2 Remainder of a variable

>>> x/oat(2) Division of a variable

2.5

Variables and Data Types

str() '5', '3.45', 'True'

int() 5, 3, 1

oat() 5.0, 1.0

bool() True, True, True

Variables to strings

Variables to integers

Variables to ﬂoats

Variables to booleans

Lists

>>> a = 'is'

>>> b = 'nice'

>>> my_list = ['my', 'list', a, b]

>>> my_list2 = [[4,5,6,7], [3,4,5,6]]

Subset

>>> my_list[1]

>>> my_list[-3]

Slice

>>> my_list[1:3]

>>> my_list[1:]

>>> my_list[:3]

>>> my_list[:]

Subset Lists of Lists

>>> my_list2[1][0]

>>> my_list2[1][:2]

Also see NumPy Arrays

>>>

my_list.index(a)

>>>

my_list.count(a)

>>>

my_list.append('!')

>>>

my_list.remove('!')

>>> del(my_list[0:1])

>>>

my_list.reverse()

>>>

my_list.extend('!')

>>> my_list.pop(-1)

>>> my_list.insert(0,'!')

>>> my_list.sort()

Get the index of an item

Count an item

Append an item at a time

Remove an item

Reverse the list

Append an item

Remove an item

Insert an item

Sort the list

Index starts at 0

Select item at index 1

Select 3rd last item

Select items at index 1 and 2

Select items aer index 0

Select items before index 3

Copy my_list

my_list[list][itemOfList]

Libraries

>>> my_string.upper()

>>> my_string.lower()

>>> my_string.count('w')

>>> my_string.replace('e', 'i')

>>> my_string.strip()

>>> my_string = 'thisStringIsAwesome'

>>> my_string

'thisStringIsAwesome'

Numpy Arrays

>>> my_list = [1, 2, 3, 4]

>>> my_array = np.array(my_list)

>>> my_2darray = np.array([[1,2,3],[4,5,6]])

>>> my_array.shape

>>> np.append(other_array)

>>> np.insert(my_array, 1, 5)

>>> np.delete(my_array,[1])

>>> np.mean(my_array)

>>> np.median(my_array)

>>> my_array.corrcoef()

>>> np.std(my_array)

Asking For Help

>>> my_string[3]

>>> my_string[4:9]

Subset

>>> my_array[1]

Slice

>>> my_array[0:2]

array([1, 2])

Subset 2D Numpy arrays

>>> my_2darray[:,0]

array([1, 4])

>>> my_list + my_list

['my', 'list', 'is', 'nice', 'my', 'list', 'is', 'nice']

>>> my_list * 2

['my', 'list', 'is', 'nice', 'my', 'list', 'is', 'nice']

>>> my_list2 > 4

True

>>> my_array > 3

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

>>> my_array * 2

array([2, 4, 6, 8])

>>> my_array + np.array([5, 6, 7, 8])

array([6, 8, 10, 12])

>>> my_string * 2

'thisStringIsAwesomethisStringIsAwesome'

>>> my_string + 'Innit'

'thisStringIsAwesomeInnit'

>>> 'm' in my_string

True

DataCamp

Learn Python for Data Science Interactively

Scientiﬁc computing

Data analysis

2D ploing

Machine learning

Also see Lists

Get the dimensions of the array

Append items to an array

Insert items in an array

Delete items in an array

Mean of the array

Median of the array

Correlation coeﬃcient

Standard deviation

String to uppercase

String to lowercase

Count String elements

Replace String elements

Strip whitespaces

Select item at index 1

Select items at index 0 and 1

my_2darray[rows, columns]

Install Python

Calculations With Variables

Leading open data science platform

Free IDE that is included

with Anaconda

Create and share

documents with live code,

visualizations, text, ...

Types and Type Conversion

String Operations

List Operations

List Methods

Index starts at 0

String Methods

String Operations

Selecting Numpy Array Elements

Index starts at 0

Numpy Array Operations

Numpy Array Functions

DataCamp

Learn Python for Data Science Interactively

Saving/Loading Notebooks

Working with Dierent Programming Languages

Asking For Help

Widgets

Python For Data Science Cheat Sheet

Jupyter Notebook

Learn More Python for Data Science Interacvely at www.DataCamp.com

Kernels provide computaon and communicaon with front-end interfaces

like the notebooks. There are three main kernels:

Installing Jupyter Notebook will automacally install the IPython kernel.

Create new notebook

Open an exisng

notebook

Make a copy of the

current notebook

Rename notebook

Wring Code And Text

Save current notebook

and record checkpoint

Revert notebook to a

previous checkpoint

Preview of the printed

notebook

Download notebook as

- IPython notebook

- Python

- HTML

- Markdown

- reST

- LaTeX

- PDF

Close notebook & stop

running any scripts

IRkernel IJulia

Cut currently selected cells

to clipboard

Copy cells from

clipboard to current

cursor posion

Paste cells from

clipboard above

current cell

Paste cells from

clipboard below

current cell

Paste cells from

clipboard on top

of current cel

Delete current cells

Revert “Delete Cells”

invocaon

Split up a cell from

current cursor

posion

Merge current cell

with the one above

Merge current cell

with the one below

Move current cell up

Move current cell

down

Adjust metadata

underlying the

current notebook

Find and replace

in selected cells

Insert image in

selected cells

Restart kernel

Restart kernel & run

all cells

Restart kernel & run

all cells

Interrupt kernel

Interrupt kernel &

clear all output

Connect back to a

remote notebook

Run other installed

kernels

Code and text are encapsulated by 3 basic cell types: markdown cells, code

cells, and raw NBConvert cells.

Edit Cells

Insert Cells

View Cells

Notebook widgets provide the ability to visualize and control changes

in your data, oen as a control like a slider, textbox, etc.

You can use them to build interacve GUIs for your notebooks or to

synchronize stateful and stateless informaon between Python and

JavaScript.

Toggle display of Jupyter

logo and lename

Toggle display of toolbar

Toggle line numbers

in cells

Toggle display of cell

acon icons:

- None

- Edit metadata

- Raw cell format

- Slideshow

- Aachments

- Tags

Add new cell above the

current one

Add new cell below the

current one

Execung Cells

Run selected cell(s)

Run current cells down

and create a new one

below

Run current cells down

and create a new one

above

Run all cells

Save notebook

with interacve

widgets

Download serialized

state of all widget

models in use

Embed current

widgets

Walk through a UI tour

List of built-in keyboard

shortcuts

Edit the built-in

keyboard shortcuts

Notebook help topics

Descripon of

markdown available

in notebook

About Jupyter Notebook

Informaon on

unocial Jupyter

Notebook extensions

Python help topics

IPython help topics

NumPy help topics

SciPy help topics

Pandas help topics

SymPy help topics

Matplotlib help topics

Run all cells above the

current cell

Run all cells below

the current cell

Change the cell type of

current cell

toggle, toggle

scrolling and clear

current outputs

toggle, toggle

scrolling and clear

all output

1. Save and checkpoint

2. Insert cell below

3. Cut cell

4. Copy cell(s)

5. Paste cell(s) below

6. Move cell up

7. Move cell down

8. Run current cell

9. Interrupt kernel

10. Restart kernel

11. Display characteriscs

12. Open command palee

13. Current kernel

14. Kernel status

15. Log out from notebook server

Command Mode:

Edit Mode:

1 2 3 4 5 6 7 8 9 10 11 12

13 14

Copy aachments of

current cell

Remove cell

aachments

Paste aachments of

current cell

Python For Data Science Cheat Sheet

NumPy Basics

Learn Python for Data Science Interactively at www.DataCamp.com

NumPy

DataCamp

Learn Python for Data Science Interactively

The NumPy library is the core library for scientiﬁc computing in

Python. It provides a high-performance multidimensional array

object, and tools for working with these arrays.

>>> import numpy as np

Use the following import convention:

Creating Arrays

>>> np.zeros((3,4)) Create an array of zeros

>>> np.ones((2,3,4),dtype=np.int16) Create an array of ones

>>> d = np.arange(10,25,5) Create an array of evenly

spaced values (step value)

>>> np.linspace(0,2,9) Create an array of evenly

spaced values (number of samples)

>>> e = np.full((2,2),7) Create a constant array

>>> f = np.eye(2) Create a 2X2 identity matrix

>>> np.random.random((2,2)) Create an array with random values

>>> np.empty((3,2)) Create an empty array

Array Mathematics

>>> g = a - b Subtraction

array([[-0.5, 0. , 0. ],

[-3. , -3. , -3. ]])

>>> np.subtract(a,b) Subtraction

>>> b + a Addition

array([[ 2.5, 4. , 6. ],

[ 5. , 7. , 9. ]])

>>> np.add(b,a) Addition

>>> a / b Division

array([[ 0.66666667, 1. , 1. ],

[ 0.25 , 0.4 , 0.5 ]])

>>> np.divide(a,b) Division

>>> a * b Multiplication

array([[ 1.5, 4. , 9. ],

[ 4. , 10. , 18. ]])

>>> np.multiply(a,b) Multiplication

>>> np.exp(b) Exponentiation

>>> np.sqrt(b) Square root

>>> np.sin(a) Print sines of an array

>>> np.cos(b) Element-wise cosine

>>> np.log(a) Element-wise natural logarithm

>>> e.dot(f) Dot product

array([[ 7., 7.],

[ 7., 7.]])

Subseing, Slicing, Indexing

>>> a.sum() Array-wise sum

>>> a.min() Array-wise minimum value

>>> b.max(axis=0) Maximum value of an array row

>>> b.cumsum(axis=1) Cumulative sum of the elements

>>> a.mean() Mean

>>> b.median() Median

>>> a.corrcoef() Correlation coeﬃcient

>>> np.std(b) Standard deviation

Comparison

>>> a == b Element-wise comparison

array([[False, True, True],

[False, False, False]], dtype=bool)

>>> a < 2 Element-wise comparison

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

>>> np.array_equal(a, b) Array-wise comparison

1 2 3

1D array 2D array 3D array

1.5 2 3

4 5 6

Array Manipulation

NumPy Arrays

axis 0

axis 1

axis 0

axis 1

axis 2

Arithmetic Operations

Transposing Array

>>> i = np.transpose(b) Permute array dimensions

>>> i.T Permute array dimensions

Changing Array Shape

>>> b.ravel() Flaen the array

>>> g.reshape(3,-2) Reshape, but don’t change data

Adding/Removing Elements

>>> h.resize((2,6)) Return a new array with shape (2,6)

>>> np.append(h,g) Append items to an array

>>> np.insert(a, 1, 5) Insert items in an array

>>> np.delete(a,[1]) Delete items from an array

Combining Arrays

>>> np.concatenate((a,d),axis=0) Concatenate arrays

array([ 1, 2, 3, 10, 15, 20])

>>> np.vstack((a,b)) Stack arrays vertically (row-wise)

array([[ 1. , 2. , 3. ],

[ 1.5, 2. , 3. ],

[ 4. , 5. , 6. ]])

>>> np.r_[e,f] Stack arrays vertically (row-wise)

>>> np.hstack((e,f)) Stack arrays horizontally (column-wise)

array([[ 7., 7., 1., 0.],

[ 7., 7., 0., 1.]])

>>> np.column_stack((a,d))

Create stacked column-wise arrays

array([[ 1, 10],

[ 2, 15],

[ 3, 20]])

>>> np.c_[a,d] Create stacked column-wise arrays

Spliing Arrays

>>> np.hsplit(a,3) Split the array horizontally at the 3rd

[array([1]),array([2]),array([3])] index

>>> np.vsplit(c,2) Split the array vertically at the 2nd index

[array([[[ 1.5, 2. , 1. ],

[ 4. , 5. , 6. ]]]),

array([[[ 3., 2., 3.],

[ 4., 5., 6.]]])]

Also see Lists

Subseing

>>> a[2] Select the element at the 2nd index

>>> b[1,2] Select the element at row 0 column 2

6.0 (equivalent to b[1][2])

Slicing

>>> a[0:2] Select items at index 0 and 1

array([1, 2])

>>> b[0:2,1] Select items at rows 0 and 1 in column 1

array([ 2., 5.])

>>> b[:1] Select all items at row 0

array ( [[1.5, 2., 3.]]) (equivalent to b[0:1, :])

>>> c[1,...] Same as [1,:,:]

array ( [[[ 3., 2., 1.],

[ 4., 5., 6.]]])

>>> a[ : :-1] Reversed array a

array([3, 2, 1])

Boolean Indexing

>>> a[a<2] Select elements from a less than 2

array([1])

Fancy Indexing

>>> b [[1, 0, 1, 0],[0, 1, 2, 0]] Select elements (1,0),(0,1),(1,2) and (0,0)

arr a y ( [ 4. , 2. , 6. , 1.5])

>>> b [[1, 0, 1, 0]][:,[0,1,2,0]] Select a subset of the matrix’s rows

array ( [[ 4. ,5. , 6. , 4. ], and columns

[ 1.5, 2. , 3. , 1.5],

[ 4. , 5. , 6. , 4. ],

[ 1.5, 2. , 3. , 1.5]])

>>> a = np.array([1,2,3])

>>> b = np.array([(1.5,2,3), (4,5,6)], dtype = oat)

>>> c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]],

dtype = oat)

Initial Placeholders

Aggregate Functions

>>> np.loadtxt("myle.txt")

>>> np.genfromtxt("my_le.csv", delimiter=',')

>>> np.savetxt("myarray.txt", a, delimiter=" ")

I/O

1 2 3

1.5 2

4 5 6

Copying Arrays

>>> h = a.view() Create a view of the array with the same data

>>> np.copy(a) Create a copy of the array

>>> h = a.copy() Create a deep copy of the array

Saving & Loading Text Files

Saving & Loading On Disk

>>> np.save('my_array', a)

>>> np.savez('array.npz', a, b)

>>> np.load('my_array.npy')

>>> a.shape Array dimensions

>>> len(a) Length of array

>>> b.ndim Number of array dimensions

>>> e.size Number of array elements

>>> b.dtype Data type of array elements

>>> b.dtype.name Name of data type

>>> b.astype(int) Convert an array to a diﬀerent type

Inspecting Your Array

>>> np.info(np.ndarray.dtype)

Asking For Help

Sorting Arrays

>>> a.sort() Sort an array

>>> c.sort(axis=0) Sort the elements of an array's axis

Data Types

>>> np.int64 Signed 64-bit integer types

>>> np.oat32 Standard double-precision ﬂoating point

>>> np.complex Complex numbers represented by 128 ﬂoats

>>> np.bool Boolean type storing TRUE and FALSE values

>>> np.object Python object type

>>> np.string_ Fixed-length string type

>>> np.unicode_ Fixed-length unicode type

1 2 3

1.5 2 3

4 5 6

1.5 2 3

4 5 6

1 2 3

Python For Data Science Cheat Sheet

SciPy - Linear Algebra

Learn More Python for Data Science Interactively at www.datacamp.com

SciPy

DataCamp

Learn Python for Data Science Interactively

Interacting With NumPy

Also see NumPy

The SciPy library is one of the core packages for

scientiﬁc computing that provides mathematical

algorithms and convenience functions built on the

NumPy extension of Python.

Index Tricks

>>> np.mgrid[0:5,0:5] Create a dense meshgrid

>>> np.ogrid[0:2,0:2] Create an open meshgrid

>>> np.r_[[3,[0]*5,-1:1:10j] Stack arrays vertically (row-wise)

>>> np.c_[b,c] Create stacked column-wise arrays

Shape Manipulation

Polynomials

Vectorizing Functions

Type Handling

>>> np.angle(b,deg=True) Return the angle of the complex argument

>>> g = np.linspace(0,np.pi,num=5) Create an array of evenly spaced values

(number of samples)

>>> g [3:] += np.pi

>>> np.unwrap(g) Unwrap

>>> np.logspace(0,10,3) Create an array of evenly spaced values (log scale)

>>> np.select([c<4],[c*2]) Return values from a list of arrays depending on

conditions

>>> misc.factorial(a) Factorial

>>> misc.comb(10,3,exact=True) Combine N things taken at k time

>>> misc.central_diff_weights(3) Weights for Np-point central derivative

>>> misc.derivative(myfunc,1.0) Find the n-th derivative of a function at a point

Other Useful Functions

>>> np.real(c) Return the real part of the array elements

>>> np.imag(c) Return the imaginary part of the array elements

>>> np.real_if_close(c,tol=1000) Return a real array if complex parts close to 0

>>> np.cast['f'](np.pi) Cast object to a data type

>>> def myfunc(a):

if a < 0:

return a*2

else:

return a/2

>>> np.vectorize(myfunc) Vectorize functions

>>> from numpy import poly1d

>>> p = poly1d([3,4,5]) Create a polynomial object

>>> np.transpose(b)

Permute array dimensions

>>> b.atten() Flaen the array

>>> np.hstack((b,c)) Stack arrays horizontally (column-wise)

>>> np.vstack((a,b)) Stack arrays vertically (row-wise)

>>> np.hsplit(c,2) Split the array horizontally at the 2nd index

>>> np.vpslit(d,2) Split the array vertically at the 2nd index

>>> import numpy as np

>>> a = np.array([1,2,3])

>>> b = np.array([(1+5j,2j,3j), (4j,5j,6j)])

>>> c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]])

>>> help(scipy.linalg.diagsvd)

>>> np.info(np.matrix)

Linear Algebra

You’ll use the linalg and sparse modules. Note that scipy.linalg contains and expands on numpy.linalg.

>>> from scipy import linalg, sparse

Creating Matrices

>>> A = np.matrix(np.random.random((2,2)))

>>> B = np.asmatrix(b)

>>> C = np.mat(np.random.random((10,5)))

>>> D = np.mat([[3,4], [5,6]])

Also see NumPy

Basic Matrix Routines

Inverse

>>> A.I Inverse

>>> linalg.inv(A) Inverse

>>> A.T Tranpose matrix

>>> A.H Conjugate transposition

>>> np.trace(A) Tra ce

Norm

>>> linalg.norm(A) Frobenius norm

>>> linalg.norm(A,1) L1 norm (max column sum)

>>> linalg.norm(A,np.inf) L inf norm (max row sum)

Rank

>>> np.linalg.matrix_rank(C) Matrix rank

Determinant

>>> linalg.det(A) Determinant

Solving linear problems

>>> linalg.solve(A,b) Solver for dense matrices

>>> E = np.mat(a).T Solver for dense matrices

>>> linalg.lstsq(D,E) Least-squares solution to linear matrix

equation

Generalized inverse

>>> linalg.pinv(C) Compute the pseudo-inverse of a matrix

(least-squares solver)

>>> linalg.pinv2(C) Compute the pseudo-inverse of a matrix

(SVD)

Addition

>>> np.add(A,D) Addition

Subtraction

>>> np.subtract(A,D) Subtraction

Division

>>> np.divide(A,D) Division

Multiplication

>>> np.multiply(D,A) Multiplication

>>> np.dot(A,D) Dot product

>>> np.vdot(A,D) Vector dot product

>>> np.inner(A,D) Inner product

>>> np.outer(A,D) Outer product

>>> np.tensordot(A,D) Tensor dot product

>>> np.kron(A,D) Kronecker product

Exponential Functions

>>> linalg.expm(A) Matrix exponential

>>> linalg.expm2(A) Matrix exponential (Taylor Series)

>>> linalg.expm3(D) Matrix exponential (eigenvalue

decomposition)

Logarithm Function

>>> linalg.logm(A) Matrix logarithm

Trigonometric Tunctions

>>> linalg.sinm(D) Matrix sine

>>> linalg.cosm(D) Matrix cosine

>>> linalg.tanm(A) Matrix tangent

Hyperbolic Trigonometric Functions

>>> linalg.sinhm(D) Hypberbolic matrix sine

>>> linalg.coshm(D) Hyperbolic matrix cosine

>>> linalg.tanhm(A) Hyperbolic matrix tangent

Matrix Sign Function

>>> np.sigm(A) Matrix sign function

Matrix Square Root

>>> linalg.sqrtm(A) Matrix square root

Arbitrary Functions

>>> linalg.funm(A, lambda x: x*x) Evaluate matrix function

Matrix Functions

Asking For Help

Decompositions

Eigenvalues and Eigenvectors

>>> la, v = linalg.eig(A) Solve ordinary or generalized

eigenvalue problem for square matrix

>>> l1, l2 = la Unpack eigenvalues

>>> v[:,0] First eigenvector

>>> v[:,1] Second eigenvector

>>> linalg.eigvals(A) Unpack eigenvalues

Singular Value Decomposition

>>> U,s,Vh = linalg.svd(B) Singular Value Decomposition (SVD)

>>> M,N = B.shape

>>> Sig = linalg.diagsvd(s,M,N) Construct sigma matrix in SVD

LU Decomposition

>>> P,L,U = linalg.lu(C) LU Decomposition

>>> F = np.eye(3, k=1) Create a 2X2 identity matrix

>>> G = np.mat(np.identity(2)) Create a 2x2 identity matrix

>>> C[C > 0.5] = 0

>>> H = sparse.csr_matrix(C) Compressed Sparse Row matrix

>>> I = sparse.csc_matrix(D) Compressed Sparse Column matrix

>>> J = sparse.dok_matrix(A) Dictionary Of Keys matrix

>>> E.todense() Sparse matrix to full matrix

>>> sparse.isspmatrix_csc(A) Identify sparse matrix

Creating Sparse Matrices

Inverse

>>> sparse.linalg.inv(I)

Inverse

Norm

>>> sparse.linalg.norm(I)

Norm

Solving linear problems

>>> sparse.linalg.spsolve(H,I)

Solver for sparse matrices

Sparse Matrix Routines

Sparse Matrix Functions

>>> sparse.linalg.expm(I) Sparse matrix exponential

Sparse Matrix Decompositions

>>> la, v = sparse.linalg.eigs(F,1) Eigenvalues and eigenvectors

>>> sparse.linalg.svds(H, 2) SVD

Python For Data Science Cheat Sheet

Pandas Basics

Learn Python for Data Science Interactively at www.DataCamp.com

Pandas

DataCamp

Learn Python for Data Science Interactively

Series

DataFrame

-5

A one-dimensional labeled array

capable of holding any data type

Index

Columns

A two-dimensional labeled

data structure with columns

of potentially diﬀerent types

The Pandas library is built on NumPy and provides easy-to-use

data structures and data analysis tools for the Python

programming language.

>>> import pandas as pd

Use the following import convention:

Pandas Data Structures

>>> s = pd.Series([3, -5, 7, 4], index=['a', 'b', 'c', 'd'])

>>> data = {'Country': ['Belgium', 'India', 'Brazil'],

'Capital': ['Brussels', 'New Delhi', 'Brasília'],

'Population': [11190846, 1303171035, 207847528]}

>>> df = pd.DataFrame(data,

columns=['Country', 'Capital', 'Population'])

Selection

>>> s['b'] Get one element

-5

>>> df[1:] Get subset of a DataFrame

Country Capital Population

1 India New Delhi 1303171035

2 Brazil Brasília 207847528

By Position

>>> df.iloc([0],[0]) Select single value by row &

'Belgium' column

>>> df.iat([0],[0])

'Belgium'

By Label

>>> df.loc([0], ['Country']) Select single value by row &

'Belgium' column labels

>>> df.at([0], ['Country'])

'Belgium'

By Label/Position

>>> df.ix[2] Select single row of

Country Brazil

subset of rows

Capital Brasília

Population 207847528

>>> df.ix[:,'Capital'] Select a single column of

0 Brussels subset of columns

1 New Delhi

2 Brasília

>>> df.ix[1,'Capital'] Select rows and columns

'New Delhi'

Boolean Indexing

>>> s[~(s > 1)] Series s where value is not >1

>>> s[(s < -1) | (s > 2)] s where value is <-1 or >2

>>> df[df['Population']>1200000000] Use ﬁlter to adjust DataFrame

Seing

>>> s['a'] = 6 Set index a of Series s to 6

Applying Functions

>>> f = lambda x: x*2

>>> df.apply(f) Apply function

>>> df.applymap(f) Apply function element-wise

Retrieving Series/DataFrame Information

>>> df.shape (rows,columns)

>>> df.index Describe index

>>> df.columns Describe DataFrame columns

>>> df.info() Info on DataFrame

>>> df.count() Number of non-NA values

Geing

Also see NumPy Arrays

Selecting, Boolean Indexing & Seing

Basic Information

Summary

>>> df.sum() Sum of values

>>> df.cumsum() Cummulative sum of values

>>> df.min()/df.max() Minimum/maximum values

>>> df.idxmin()/df.idxmax() Minimum/Maximum index value

>>> df.describe() Summary statistics

>>> df.mean() Mean of values

>>> df.median() Median of values

Dropping

>>> s.drop(['a', 'c']) Drop values from rows (axis=0)

>>> df.drop('Country', axis=1) Drop values from columns(axis=1)

Data Alignment

>>> s.add(s3, ll_value=0)

a 10.0

b -5.0

c 5.0

d 7.0

>>> s.sub(s3, ll_value=2)

>>> s.div(s3, ll_value=4)

>>> s.mul(s3, ll_value=3)

>>> s3 = pd.Series([7, -2, 3], index=['a', 'c', 'd'])

>>> s + s3

a 10.0

b NaN

c 5.0

d 7.0

Arithmetic Operations with Fill Methods

Internal Data Alignment

NA values are introduced in the indices that don’t overlap:

You can also do the internal data alignment yourself with

the help of the ﬁll methods:

Sort & Rank

>>> df.sort_index() Sort by labels along an axis

>>> df.sort_values(by='Country') Sort by the values along an axis

>>> df.rank() Assign ranks to entries

Belgium

Brussels

India

New Delhi

Brazil

Brasília

Country

Capital

11190846

1303171035

207847528

Population

I/O

Read and Write to CSV

>>> pd.read_csv('le.csv', header=None, nrows=5)

>>> df.to_csv('myDataFrame.csv')

Read and Write to Excel

>>> pd.read_excel('le.xlsx')

>>> pd.to_excel('dir/myDataFrame.xlsx', sheet_name='Sheet1')

Read multiple sheets from the same ﬁle

>>> xlsx = pd.ExcelFile('le.xls')

>>> df = pd.read_excel(xlsx, 'Sheet1')

>>> help(pd.Series.loc)

Asking For Help

Read and Write to SQL Query or Database Table

>>> from sqlalchemy import create_engine

>>> engine = create_engine('sqlite:///:memory:')

>>> pd.read_sql("SELECT * FROM my_table;", engine)

>>> pd.read_sql_table('my_table', engine)

>>> pd.read_sql_query("SELECT * FROM my_table;", engine)

>>> pd.to_sql('myDf', engine)

read_sql()is a convenience wrapper around read_sql_table() and

read_sql_query()

Python For Data Science Cheat Sheet

Scikit-Learn

Learn Python for data science Interactively at www.DataCamp.com

Scikit-learn

DataCamp

Learn Python for Data Science Interactively

Loading The Data

Also see NumPy & Pandas

Scikit-learn is an open source Python library that

implements a range of machine learning,

preprocessing, cross-validation and visualization

algorithms using a uniﬁed interface.

>>> import numpy as np

>>> X = np.random.random((10,5))

>>> y = np.array(['M','M','F','F','M','F','M','M','F','F','F'])

>>> X[X < 0.7] = 0

Your data needs to be numeric and stored as NumPy arrays or SciPy sparse

matrices. Other types that are convertible to numeric arrays, such as Pandas

DataFrame, are also acceptable.

Create Your Model

Model Fiing

Prediction

Tune Your Model

Evaluate Your Model’s Performance

Grid Search

Randomized Parameter Optimization

Linear Regression

>>> from sklearn.linear_model import LinearRegression

>>> lr = LinearRegression(normalize=True)

Support Vector Machines (SVM)

>>> from sklearn.svm import SVC

>>> svc = SVC(kernel='linear')

Naive Bayes

>>> from sklearn.naive_bayes import GaussianNB

>>> gnb = GaussianNB()

KNN

>>> from sklearn import neighbors

>>> knn = neighbors.KNeighborsClassier(n_neighbors=5)

Supervised learning

>>> lr.t(X, y)

>>> knn.t(X_train, y_train)

>>> svc.t(X_train, y_train)

Unsupervised Learning

>>> k_means.t(X_train)

>>> pca_model = pca.t_transform(X_train)

Accuracy Score

>>> knn.score(X_test, y_test)

>>> from sklearn.metrics import accuracy_score

>>> accuracy_score(y_test, y_pred)

Classiﬁcation Report

>>> from sklearn.metrics import classication_report

>>> print(classication_report(y_test, y_pred))

Confusion Matrix

>>> from sklearn.metrics import confusion_matrix

>>> print(confusion_matrix(y_test, y_pred))

Cross-Validation

>>> from sklearn.cross_validation import cross_val_score

>>> print(cross_val_score(knn, X_train, y_train, cv=4))

>>> print(cross_val_score(lr, X, y, cv=2))

Classiﬁcation Metrics

>>> from sklearn.grid_search import GridSearchCV

>>> params = {"n_neighbors": np.arange(1,3),

"metric": ["euclidean", "cityblock"]}

>>> grid = GridSearchCV(estimator=knn,

param_grid=params)

>>> grid.t(X_train, y_train)

>>> print(grid.best_score_)

>>> print(grid.best_estimator_.n_neighbors)

>>> from sklearn.grid_search import RandomizedSearchCV

>>> params = {"n_neighbors": range(1,5),

"weights": ["uniform", "distance"]}

>>> rsearch = RandomizedSearchCV(estimator=knn,

param_distributions=params,

cv=4,

n_iter=8,

random_state=5)

>>> rsearch.t(X_train, y_train)

>>> print(rsearch.best_score_)

A Basic Example

>>> from sklearn import neighbors, datasets, preprocessing

>>> from sklearn.model_selection import train_test_split

>>> from sklearn.metrics import accuracy_score

>>> iris = datasets.load_iris()

>>> X, y = iris.data[:, :2], iris.target

>>> X_train, X_test, y_train, y_test = train_test_split(X, y , random_state=33)

>>> scaler = preprocessing.StandardScaler().t(X_train)

>>> X_train = scaler.transform(X_train)

>>> X_test = scaler.transform(X_test)

>>> knn = neighbors.KNeighborsClassier(n_neighbors=5)

>>> knn.t(X_train, y_train)

>>> y_pred = knn.predict(X_test)

>>> accuracy_score(y_test, y_pred)

Supervised Learning Estimators

Unsupervised Learning Estimators

Principal Component Analysis (PCA)

>>> from sklearn.decomposition import PCA

>>> pca = PCA(n_components=0.95)

K Means

>>> from sklearn.cluster import KMeans

>>> k_means = KMeans(n_clusters=3, random_state=0)

Fit the model to the data

Fit to data, then transform it

Preprocessing The Data

Standardization

Normalization

>>> from sklearn.preprocessing import Normalizer

>>> scaler = Normalizer().t(X_train)

>>> normalized_X = scaler.transform(X_train)

>>> normalized_X_test = scaler.transform(X_test)

Training And Test Data

>>> from sklearn.model_selection import train_test_split

> > > X_train, X_test, y_train, y_test = train_test_split(X ,

random_state=0)

>>> from sklearn.preprocessing import StandardScaler

>>> scaler = StandardScaler().t(X_train)

>>> standardized_X = scaler.transform(X_train)

>>> standardized_X_test = scaler.transform(X_test)

Binarization

>>> from sklearn.preprocessing import Binarizer

>>> binarizer = Binarizer(threshold=0.0).t(X)

>>> binary_X = binarizer.transform(X)

Encoding Categorical Features

Supervised Estimators

>>> y_pred = svc.predict(np.random.random((2,5)))

>>> y_pred = lr.predict(X_test)

>>> y_pred = knn.predict_proba(X_test)

Unsupervised Estimators

>>> y_pred = k_means.predict(X_test)

>>> from sklearn.preprocessing import LabelEncoder

>>> enc = LabelEncoder()

>>> y = enc.t_transform(y)

Imputing Missing Values

Predict labels

Estimate probability of a label

Predict labels in clustering algos

>>> from sklearn.preprocessing import Imputer

>>> imp = Imputer(missing_values=0, strategy='mean', axis=0)

>>> imp.t_transform(X_train)

Generating Polynomial Features

>>> from sklearn.preprocessing import PolynomialFeatures

>>> poly = PolynomialFeatures(5)

>>> poly.t_transform(X)

Regression Metrics

Mean Absolute Error

>>> from sklearn.metrics import mean_absolute_error

>>> y_true = [3, -0.5, 2]

>>> mean_absolute_error(y_true, y_pred)

Mean Squared Error

>>> from sklearn.metrics import mean_squared_error

>>> mean_squared_error(y_test, y_pred)

R² Score

>>> from sklearn.metrics import r2_score

>>> r2_score(y_true, y_pred)

Clustering Metrics

Adjusted Rand Index

>>> from sklearn.metrics import adjusted_rand_score

>>> adjusted_rand_score(y_true, y_pred)

Homogeneity

>>> from sklearn.metrics import homogeneity_score

>>> homogeneity_score(y_true, y_pred)

V-measure

>>> from sklearn.metrics import v_measure_score

>>> metrics.v_measure_score(y_true, y_pred)

Estimator score method

Metric scoring functions

Precision, recall, f1-score

and support

Python For Data Science Cheat Sheet

Matplotlib

Learn Python Interactively at www.DataCamp.com

Matplotlib

DataCamp

Learn Python for Data Science Interactively

Prepare The Data

Also see Lists & NumPy

Matplotlib is a Python 2D ploing library which produces

publication-quality ﬁgures in a variety of hardcopy formats

and interactive environments across

platforms.

>>> import numpy as np

>>> x = np.linspace(0, 10, 100)

>>> y = np.cos(x)

>>> z = np.sin(x)

Show Plot

>>> plt.show()

Matplotlib 2.0.0 - Updated on: 02/2017

Save Plot

Save ﬁgures

>>> plt.saveg('foo.png')

Save transparent ﬁgures

>>> plt.saveg('foo.png', transparent=True)

>>> g = plt.gure()

>>> g2 = plt.gure(gsize=plt.gaspect(2.0))

Create Plot

Plot Anatomy & Workﬂow

All ploing is done with respect to an Axes. In most cases, a

subplot will ﬁt your needs. A subplot is an axes on a grid system.

>>> g.add_axes()

>>> ax1 = g.add_subplot(221) # row-col-num

>>> ax3 = g.add_subplot(212)

>>> g3, axes = plt.subplots(nrows=2,ncols=2)

>>> g4, axes2 = plt.subplots(ncols=3)

Customize Plot

Colors, Color Bars & Color Maps

Markers

Linestyles

Mathtext

Text & Annotations

Limits, Legends & Layouts

The basic steps to creating plots with matplotlib are:

1 Prepare data 2 Create plot 3 Plot 4 Customize plot 5 Save plot 6 Show plot

>>> import matplotlib.pyplot as plt

>>> x = [1,2,3,4]

>>> y = [10,20,25,30]

>>> g = plt.gure()

>>> ax = g.add_subplot(111)

>>> ax.plot(x, y, color='lightblue', linewidth=3)

>>> ax.scatter([2,4,6],

[5,15,25],

color='darkgreen',

marker='^')

>>> ax.set_xlim(1, 6.5)

>>> plt.saveg('foo.png')

>>> plt.show()

Step 3, 4

Step 2

Step 1

Step 3

Step 6

Plot Anatomy Workﬂow

Limits & Autoscaling

>>> ax.margins(x=0.0,y=0.1) Add padding to a plot

>>> ax.axis('equal') Set the aspect ratio of the plot to 1

>>> ax.set(xlim=[0,10.5],ylim=[-1.5,1.5]) Set limits for x-and y-axis

>>> ax.set_xlim(0,10.5) Set limits for x-axis

Legends

>>> ax.set(title='An Example Axes', Set a title and x-and y-axis labels

ylabel='Y-Axis',

xlabel='X-Axis')

>>> ax.legend(loc='best') No overlapping plot elements

Ticks

>>> ax.xaxis.set(ticks=range(1,5), Manually set x-ticks

ticklabels=[3,100,-12,"foo"])

>>> ax.tick_params(axis='y', Make y-ticks longer and go in and out

direction='inout',

length=10)

Subplot Spacing

>>> g3.subplots_adjust(wspace=0.5, Adjust the spacing between subplots

hspace=0.3,

left=0.125,

right=0.9,

top=0.9,

bottom=0.1)

>>> g.tight_layout()

Fit subplot(s) in to the ﬁgure area

Axis Spines

>>> ax1.spines['top'].set_visible(False) Make the top axis line for a plot invisible

>>> ax1.spines['bottom'].set_position(('outward',10)) Move the boom axis line outward

Figure

Axes

>>> data = 2 * np.random.random((10, 10))

>>> data2 = 3 * np.random.random((10, 10))

>>> Y, X = np.mgrid[-3:3:100j, -3:3:100j]

>>> U = -1 - X**2 + Y

>>> V = 1 + X - Y**2

>>> from matplotlib.cbook import get_sample_data

>>> img = np.load(get_sample_data('axes_grid/bivariate_normal.npy'))

>>> g, ax = plt.subplots()

>>> lines = ax.plot(x,y) Draw points with lines or markers connecting them

>>> ax.scatter(x,y) Draw unconnected points, scaled or colored

>>> axes[0,0].bar([1,2,3],[3,4,5]) Plot vertical rectangles (constant width)

>>> axes[1,0].barh([0.5,1,2.5],[0,1,2]) Plot horiontal rectangles (constant height)

>>> axes[1,1].axhline(0.45) Draw a horizontal line across axes

>>> axes[0,1].axvline(0.65) Draw a vertical line across axes

>>> ax.ll(x,y,color='blue') Draw ﬁlled polygons

>>> ax.ll_between(x,y,color='yellow') Fill between y-values and 0

Ploing Routines

1D Data

>>> g, ax = plt.subplots()

>>> im = ax.imshow(img, Colormapped or RGB arrays

cmap='gist_earth',

interpolation='nearest',

vmin=-2,

vmax=2)

2D Data or Images

Vector Fields

>>> axes[0,1].arrow(0,0,0.5,0.5) Add an arrow to the axes

>>> axes[1,1].quiver(y,z) Plot a 2D ﬁeld of arrows

>>> axes[0,1].streamplot(X,Y,U,V) Plot a 2D ﬁeld of arrows

Data Distributions

>>> ax1.hist(y) Plot a histogram

>>> ax3.boxplot(y) Make a box and whisker plot

>>> ax3.violinplot(z) Make a violin plot

>>> axes2[0].pcolor(data2) Pseudocolor plot of 2D array

>>> axes2[0].pcolormesh(data) Pseudocolor plot of 2D array

>>> CS = plt.contour(Y,X,U) Plot contours

>>> axes2[2].contourf(data1) Plot ﬁlled contours

>>> axes2[2]= ax.clabel(CS) Label a contour plot

Figure

Axes/Subplot

Y-axis

X-axis

1D Data

2D Data or Images

>>> plt.plot(x, x, x, x**2, x, x**3)

>>> ax.plot(x, y, alpha = 0.4)

>>> ax.plot(x, y, c='k')

>>> g.colorbar(im, orientation='horizontal')

>>> im = ax.imshow(img,

cmap='seismic')

>>> g, ax = plt.subplots()

>>> ax.scatter(x,y,marker=".")

>>> ax.plot(x,y,marker="o")

>>> plt.title(r'$sigma_i=15$', fontsize=20)

>>> ax.text(1,

-2.1,

'Example Graph',

style='italic')

>>> ax.annotate("Sine",

xy=(8, 0),

xycoords='data',

xytext=(10.5, 0),

textcoords='data',

arrowprops=dict(arrowstyle="->",

connectionstyle="arc3"),)

>>> plt.plot(x,y,linewidth=4.0)

>>> plt.plot(x,y,ls='solid')

>>> plt.plot(x,y,ls='--')

>>> plt.plot(x,y,'--',x**2,y**2,'-.')

>>> plt.setp(lines,color='r',linewidth=4.0)

>>> import matplotlib.pyplot as plt

Close & Clear

>>> plt.cla() Clear an axis

>>> plt.clf() Clear the entire ﬁgure

>>> plt.close() Close a window

Python For Data Science Cheat Sheet

Seaborn

Learn Data Science Interactively at www.DataCamp.com

Statistical Data Visualization With Seaborn

DataCamp

Learn Python for Data Science Interactively

Figure Aesthetics

Data

The Python visualization library Seaborn is based on

matplotlib and provides a high-level interface for drawing

aractive statistical graphics.

Make use of the following aliases to import the libraries:

The basic steps to creating plots with Seaborn are:

1. Prepare some data

2. Control ﬁgure aesthetics

3. Plot with Seaborn

4. Further customize your plot

>>> import pandas as pd

>>> import numpy as np

>>> uniform_data = np.random.rand(10, 12)

>>> data = pd.DataFrame({'x':np.arange(1,101),

'y':np.random.normal(0,4,100)})

>>> import matplotlib.pyplot as plt

>>> import seaborn as sns

Ploing With Seaborn

>>> import matplotlib.pyplot as plt

>>> import seaborn as sns

>>> tips = sns.load_dataset("tips")

>>> sns.set_style("whitegrid")

>>> g = sns.lmplot(x="tip",

y="total_bill",

data=tips,

aspect=2)

>>> g = (g.set_axis_labels("Tip","Total bill(USD)").

set(xlim=(0,10),ylim=(0,100)))

>>> plt.title("title")

>>> plt.show(g)

Step 4

Step 2

Step 1

Step 5

Step 3

>>> titanic = sns.load_dataset("titanic")

>>> iris = sns.load_dataset("iris")

Seaborn also oﬀers built-in data sets:

Further Customizations

Show or Save Plot

>>> sns.set() (Re)set the seaborn default

>>> sns.set_style("whitegrid") Set the matplotlib parameters

>>> sns.set_style("ticks", Set the matplotlib parameters

{"xtick.major.size":8,

"ytick.major.size":8})

>>> sns.axes_style("whitegrid") Return a dict of params or use with

with to temporarily set the style

Axis Grids

>>> f, ax = plt.subplots(gsize=(5,6)) Create a ﬁgure and one subplot

>>> plt.title("A Title") Add plot title

>>> plt.ylabel("Survived") Adjust the label of the y-axis

>>> plt.xlabel("Sex") Adjust the label of the x-axis

>>> plt.ylim(0,100) Adjust the limits of the y-axis

>>> plt.xlim(0,10) Adjust the limits of the x-axis

>>> plt.setp(ax,yticks=[0,5]) Adjust a plot property

>>> plt.tight_layout() Adjust subplot params

>>> plt.show() Show the plot

>>> plt.saveg("foo.png") Save the plot as a ﬁgure

>>> plt.saveg("foo.png", Save transparent ﬁgure

transparent=True)

>>> sns.regplot(x="sepal_width", Plot data and a linear regression

y="sepal_length", model ﬁt

data=iris,

ax=ax)

>>> g.despine(left=True) Remove le spine

>>> g.set_ylabels("Survived") Set the labels of the y-axis

>>> g.set_xticklabels(rotation=45) Set the tick labels for x

>>> g.set_axis_labels("Survived", Set the axis labels

"Sex")

>>> h.set(xlim=(0,5), Set the limit and ticks of the

ylim=(0,5), x-and y-axis

xticks=[0,2.5,5],

yticks=[0,2.5,5])

Close & Clear

>>> plt.cla() Clear an axis

>>> plt.clf() Clear an entire ﬁgure

>>> plt.close() Close a window

Also see Lists, NumPy & Pandas

Also see Matplotlib

Context Functions

>>> sns.set_context("talk") Set context to "talk"

>>> sns.set_context("notebook", Set context to "notebook",

font_scale=1.5, cale font elements and

rc={"lines.linewidth":2.5}) override param mapping

Seaborn styles

>>> sns.set_palette("husl",3) Deﬁne the color palee

>>> sns.color_palette("husl") Use with with to temporarily set palee

>>> atui = ["#9b59b6","#3498db","#95a5a6","#e74c3c","#34495e","#2ecc71"]

>>> sns.set_palette(atui) Set your own color palee

Color Palee

Plot

Axisgrid Objects

>>> g = sns.FacetGrid(titanic, Subplot grid for ploing conditional

col="survived", relationships

row="sex")

>>> g = g.map(plt.hist,"age")

>>> sns.factorplot(x="pclass", Draw a categorical plot onto a

y="survived", Facetgrid

hue="sex",

data=titanic)

>>> sns.lmplot(x="sepal_width", Plot data and regression model ﬁts

y="sepal_length", across a FacetGrid

hue="species",

data=iris)

Regression Plots

Categorical Plots

Scaerplot

>>> sns.stripplot(x="species", Scaerplot with one

y="petal_length", categorical variable

data=iris)

>>> sns.swarmplot(x="species", Categorical scaerplot with

y="petal_length", non-overlapping points

data=iris)

Bar Chart

>>> sns.barplot(x="sex", Show point estimates and

y="survived", conﬁdence intervals with

hue="class", scaerplot glyphs

data=titanic)

Count Plot

>>> sns.countplot(x="deck", Show count of observations

data=titanic,

palette="Greens_d")

Point Plot

>>> sns.pointplot(x="class", Show point estimates and

y="survived", conﬁdence intervals as

hue="sex", rectangular bars

data=titanic,

palette={"male":"g",

"female":"m"},

markers=["^","o"],

linestyles=["-","--"])

Boxplot

>>> sns.boxplot(x="alive", Boxplot

y="age",

hue="adult_male",

data=titanic)

>>> sns.boxplot(data=iris,orient="h") Boxplot with wide-form data

Violinplot

>>> sns.violinplot(x="age", Violin plot

y="sex",

hue="survived",

data=titanic)

>>> plot = sns.distplot(data.y,

Plot univariate distribution

kde=False,

color="b")

Distribution Plots

>>> h = sns.PairGrid(iris)

Subplot grid for ploing pairwise

>>> h = h.map(plt.scatter)

relationships

>>> sns.pairplot(iris) Plot pairwise bivariate distributions

>>> i = sns.JointGrid(x="x", Grid for bivariate plot with marginal

y="y", univariate plots

data=data)

>>> i = i.plot(sns.regplot,

sns.distplot)

>>> sns.jointplot("sepal_length", Plot bivariate distribution

"sepal_width",

data=iris,

kind='kde')

Matrix Plots

>>> sns.heatmap(uniform_data,vmin=0,vmax=1)

Heatmap

Python For Data Science Cheat Sheet

Bokeh

Learn Bokeh Interactively at www.DataCamp.com,

taught by Bryan Van de Ven, core contributor

Ploing With Bokeh

DataCamp

Learn Python for Data Science Interactively

>>> from bokeh.plotting import gure

>>> p1 = gure(plot_width=300, tools='pan,box_zoom')

>>> p2 = gure(plot_width=300, plot_height=300,

x_range=(0, 8), y_range=(0, 8))

>>> p3 = gure()

>>> from bokeh.io import output_notebook, show

>>> output_notebook()

Ploing

Components

>>> from bokeh.embed import components

>>> script, div = components(p)

Selection and Non-Selection Glyphs

>>> p = gure(tools='box_select')

>>> p.circle('mpg', 'cyl', source=cds_df,

selection_color='red',

nonselection_alpha=0.1)

Hover Glyphs

>>> from bokeh.models import HoverTool

>>> hover = HoverTool(tooltips=None, mode='vline')

>>> p3.add_tools(hover)

Colormapping

>>> from bokeh.models import CategoricalColorMapper

>>> color_mapper = CategoricalColorMapper(

factors=['US', 'Asia', 'Europe'],

palette=['blue', 'red', 'green'])

>>> p3.circle('mpg', 'cyl', source=cds_df,

color=dict(eld='origin',

transform=color_mapper),

legend='Origin')

>>> from bokeh.io import output_le, show

>>> output_le('my_bar_chart.html', mode='cdn')

>>> from bokeh.models import ColumnDataSource

>>> cds_df = ColumnDataSource(df)

Data

Also see Lists, NumPy & Pandas

Under the hood, your data is converted to Column Data

Sources. You can also do this manually:

Customized Glyphs

The Python interactive visualization library Bokeh

enables high-performance visual presentation of

large datasets in modern web browsers.

Bokeh’s mid-level general purpose bokeh.plotting

interface is centered around two main components: data

and glyphs.

The basic steps to creating plots with the bokeh.plotting

interface are:

1. Prepare some data:

Python lists, NumPy arrays, Pandas DataFrames and other sequences of values

2. Create a new plot

3. Add renderers for your data, with visual customizations

4. Specify where to generate the output

5. Show or save the results

+ =

data glyphs plot

>>> from bokeh.plotting import gure

>>> from bokeh.io import output_le, show

>>> x = [1, 2, 3, 4, 5]

>>> y = [6, 7, 2, 4, 5]

>>> p = gure(title="simple line example",

x_axis_label='x',

y_axis_label='y')

>>> p.line(x, y, legend="Temp.", line_width=2)

>>> output_le("lines.html")

>>> show(p)

Step 4

Step 2

Step 1

Step 5

Step 3

Renderers & Visual Customizations

Scaer Markers

>>> p1.circle(np.array([1,2,3]), np.array([3,2,1]),

ll_color='white')

>>> p2.square(np.array([1.5,3.5,5.5]), [1,4,3],

color='blue', size=1)

Line Glyphs

>>> p1.line([1,2,3,4], [3,4,5,6], line_width=2)

>>> p2.multi_line(pd.DataFrame([[1,2,3],[5,6,7]]),

pd.DataFrame([[3,4,5],[3,2,1]]),

color="blue")

Glyphs

Output & Export

>>> import numpy as np

>>> import pandas as pd

>>> df = pd.DataFrame(np.array([[33.9,4,65, 'US'],

[32.4,4,66, 'Asia'],

[21.4,4,109, 'Europe']]),

columns=['mpg','cyl', 'hp', 'origin'],

index=['Toyota', 'Fiat', 'Volvo'])

Also see Data

HTML

Asia

Europe

Grid Layout

>>> from bokeh.layouts import gridplot

>>> row1 = [p1,p2]

>>> row2 = [p3]

>>> layout = gridplot([[p1,p2],[p3]])

Tabbed Layout

>>> from bokeh.models.widgets import Panel, Tabs

>>> tab1 = Panel(child=p1, title="tab1")

>>> tab2 = Panel(child=p2, title="tab2")

>>> layout = Tabs(tabs=[tab1, tab2])

Linked Plots

Inside Plot Area

>>> p.legend.location = 'bottom_left'

Outside Plot Area

>>> from bokeh.models import Legend

>>> r1 = p2.asterisk(np.array([1,2,3]), np.array([3,2,1])

>>> r2 = p2.line([1,2,3,4], [3,4,5,6])

>>> legend = Legend(items=[("One" ,[p1, r1]),("Two",[r2])],

location=(0, -30))

>>> p.add_layout(legend, 'right')

Legend Location

Linked Axes

>>> p2.x_range = p1.x_range

>>> p2.y_range = p1.y_range

Linked Brushing

>>> p4 = gure(plot_width = 100,

tools='box_select,lasso_select')

>>> p4.circle(

'mpg', 'cyl'

, source=cds_df)

>>> p5 = gure(plot_width = 200,

tools='box_select,lasso_select')

>>> p5.circle(

'mpg', 'hp'

, source=cds_df)

>>> layout = row(p4,p5)

>>> show(p1) >>> show(layout)

>>> save(p1) >>> save(layout)

Show or Save Your Plots

>>> p.legend.orientation = "horizontal"

>>> p.legend.orientation = "vertical"

>>> p.legend.border_line_color = "navy"

>>> p.legend.background_ll_color = "white"

Legend Orientation

Legend Background & Border

Rows & Columns Layout

Rows

>>> from bokeh.layouts import row

>>> layout = row(p1,p2,p3)

Columns

>>> from bokeh.layouts import columns

>>> layout = column(p1,p2,p3)

Nesting Rows & Columns

>>>layout = row(column(p1,p2), p3)

PNG

>>> from bokeh.io import export_png

>>> export_png(p, lename="plot.png")

SVG

>>> from bokeh.io import export_svgs

>>> p.output_backend = "svg"

>>> export_svgs(p, lename="plot.svg")

Notebook

Standalone HTML

>>> from bokeh.embed import le_html

>>> from bokeh.resources import CDN

>>> html = le_html(p, CDN, "my_plot")