Python 

Libraries for 
Data Analysis and
Machine Learning
Overview

 Environment Preparation for Python

 Python Libraries for Data Scientists
 Data Processing & Visualization Using Python
 Python for Basic Machine Learning Models
Environment Preparation for Python
We introduce
◦ Anaconda (https://www.anaconda.com/)
◦ Jupyter Notebook (https://jupyter.org/)
for Python environment.

Other alternatives:
◦ Text Editor + Command line
◦ IDE (Integrated Development Environment): PyCharm, Vscode, …
What is Anaconda?
The open‐source Anaconda is the easiest way to perform Python/R data science 
and machine learning on Linux, Windows, and Mac OS X. With over 19 million 
users worldwide. 
It is the industry standard for developing, testing, and training on a single 
machine, enabling individual data scientists to:
 Quickly download 7,500+ Python/R data science packages
 Analyze data with scalability and performance with Dask, NumPy, pandas, 
and Numba
 Visualize results with Matplotlib, Bokeh, Datashader, and Holoviews
 Develop and train machine learning and deep learning models with scikit‐
learn, TensorFlow, and Theano
Anaconda Installation
Please follow the instruction here to install the Anaconda (for Python 3.7)

https://www.anaconda.com/distribution/#download‐section

•It provides different versions to suit different OS. Please select the one you are 
using.
•Just install according to the default setting, and the environment variables will 
be automatically configured after installation.
What is Jupyter Notebook?
•The Jupyter Notebook is an open‐source web application that allows you to 
create and share documents that contain live code, equations, visualizations and 
narrative text. 
•It includes: data cleaning and transformation, numerical simulation, statistical 
modeling, data visualization, machine learning, and much more.

•Jupyter Notebook is included in the Anaconda.

Basic Operation on Jupyter Notebook
After installing the Anaconda, open Anaconda‐Navigator as below, and you can
find the Jupyter Notebook on the Anaconda. Then click Launch.
Basic Operation on Jupyter Notebook
Jupyter Notebook is presented as a website. Select the path, then under the
button “New”, choose “Python 3” to open a new python file.
Basic Operation on Jupyter Notebook
Type the code into the input box on Jupyter.
Get started learning Python: https://www.learnpython.org/
Basic Operation on Jupyter Notebook
Click “Run”.
The output will be shown in the blank area right below the input box.
Basic Operation on Jupyter Notebook
Jupyter Notebook will help you
save your code automatically in
“.ipynb” format.

If you want to save the code as

“.py” format.

Here, we just use “.ipynb” format.

Python Libraries for Data Scientists
Python toolboxes/libraries for data processing:
◦ NumPy
◦ SciPy
◦ Pandas
Visualization libraries
◦ matplotlib
◦ Seaborn
Machine learning & deep learning
◦ Scikit‐learn
◦ Tensorflow/Pytorch/Theano and many more …
Python Libraries for Data Scientists
NumPy:
 introduces objects for multidimensional arrays and matrices, as well as 
functions that allow to easily perform advanced mathematical and 
statistical operations on those objects

 provides vectorization of mathematical operations on arrays and matrices 
which significantly improves the performance

 many other python libraries are built on NumPy

Link: http://www.numpy.org/
Python Libraries for Data Scientists
SciPy:
 collection of algorithms for linear algebra, differential equations, numerical 
integration, optimization, statistics and more

 part of SciPy Stack

 built on NumPy

Link: https://www.scipy.org/scipylib/
Python Libraries for Data Scientists
Pandas:
 adds data structures and tools designed to work with table‐like data 
(similar to Series and Data Frames in R)

 provides tools for data manipulation: reshaping, merging, sorting, slicing, 
aggregation etc.

 allows handling missing data

Link: http://pandas.pydata.org/
Python Libraries for Data Scientists
matplotlib:
 python 2D plotting library which produces publication quality figures in a 
variety of hardcopy formats

 a set of functionalities similar to those of MATLAB

 line plots, scatter plots, barcharts, histograms, pie charts etc.

 relatively low‐level; some effort needed to create advanced visualization

Link: https://matplotlib.org/
Python Libraries for Data Scientists
Seaborn:
 based on matplotlib

 provides high level interface for drawing attractive statistical graphics

 Similar (in style) to the popular ggplot2 library in R

Link: https://seaborn.pydata.org/
Python Libraries for Data Scientists
SciKit‐Learn:
 provides machine learning algorithms: classification, regression, clustering, 
model validation etc.

 built on NumPy, SciPy and matplotlib

Link: http://scikit‐learn.org/
Loading Python Libraries

Press Shift+Enter to execute the jupyter cell, or just click “Run”.

19
 Reading data using pandas

There is a number of pandas commands to read other data formats:

pd.read_excel('myfile.xlsx',sheet_name='Sheet1', index_col=None, na_values=['NA'])

pd.read_stata('myfile.dta')
pd.read_sas('myfile.sas7bdat')
pd.read_hdf('myfile.h5','df')

20
Exploring data frames

 Try to read the first 10, 20, 50 records
 Try to view the last few records             

21
Data Frame data types
Pandas Type Native Python Type Description
object string The most general dtype. Will be assigned to your column 
if column has mixed types (numbers and strings).
int64 int Numeric characters. 64 refers to the memory allocated to 
hold this character.
float64 float Numeric characters with decimals. If a column contains 
numbers and NaNs, pandas will default to float64, in case 
your missing value has a decimal.
datetime64,  N/A (but see  Values meant to hold time data. Look into these for time 
timedelta[ns] the datetime module in  series experiments.
Python’s standard library)

22
Data Frame data types

23
Data Frames attributes
Python objects have attributes and methods.
df.attribute description
dtypes list the types of the columns
columns list the column names
axes list the row labels and column names
ndim number of dimensions

size number of elements 
shape return a tuple representing the dimensionality 
values numpy representation of the data

24
Data Frames attributes

25
Data Frames methods
Unlike attributes, python methods have parenthesis.
All attributes and methods can be listed with a dir() function: dir(df)
df.method() description
head( [n] ), tail( [n] ) first/last n rows
describe() generate descriptive statistics (for numeric columns only)
max(), min() return max/min values for all numeric columns

mean(), median() return mean/median values for all numeric columns

std() standard deviation

sample([n]) returns a random sample of the data frame

dropna() drop all the records with missing values

26
Data Frames methods

27
Data Frames methods

28
Selecting a column in a Data Frame
Note: If we want to select a column
with a name as the attribute in
DataFrames we should use method 1.
E.G., Since there is an attribute – rank
in DataFrame, if we want to select
the column ‘rank’, we should use
df[‘rank’], and cannot use method 2,
i.e., df.rank, which will return the
attribute rank of the data frame
instead of the column “rank”.

29
Selecting a column in a Data Frame

30
Data Frames groupby method
Using "group by" method we can:
• Split the data into groups based on some criteria
• Calculate statistics (or apply a function) to each group

31
Data Frames groupby method
Once groupby object is create we can calculate various statistics for each group:

Note: If single brackets are used to 
specify the column (e.g. age), then 
the output is Pandas Series object. 
When double brackets are used the 
output is a Data Frame (e.g. age &
balance)
32
Data Frames groupby method
groupby performance notes:
‐ no grouping/splitting occurs until it's needed. Creating the groupby object 
only verifies that you have passed a valid mapping
‐ by default the group keys are sorted during the groupby operation. You may 
want to pass sort=False for potential speedup:

33
Data Frame: filtering
To subset the data we can apply Boolean indexing. This indexing is commonly 
known as a filter.  For example if we want to subset the rows in which the age 
value is greater than 50: 

Any Boolean operator can be used to subset the data:
>   greater;  >= greater or equal;
<   less;           <= less or equal;
== equal;        != not equal;  

34
Data Frames: Slicing
There are a number of ways to subset the Data Frame:
• one or more columns
• one or more rows
• a subset of rows and columns

Rows and columns can be selected by their position or label 

35
Data Frames: Slicing
When selecting one column, it is possible to use single set of brackets, but the 
resulting object will be  a Series (not a DataFrame): 

When we need to select more than one column and/or make the output to be a 
DataFrame, we should use double brackets:

36
Data Frames: Selecting rows
If we need to select a range of rows, we can specify the range using ":" 

Notice that the first row has a position 0, and the last value in the range is omitted:
So for 0:10 range the first 10 rows are returned with the positions starting with 0 
and ending with 9

37
Data Frames: method loc
If we need to select a range of rows, using their labels we can use method loc:

Recall that

38
Data Frames: method iloc
If we need to select a range of rows and/or columns, using their positions we can 
use method iloc:

39
Data Frames: method iloc (summary)
df.iloc[0] # First row of a data frame
df.iloc[i] #(i+1)th row
df.iloc[-1] # Last row

df.iloc[:, 0] # First column

df.iloc[:, -1] # Last column

df.iloc[0:7] #First 7 rows

df.iloc[:, 0:2] #First 2 columns
df.iloc[1:3, 0:2] #Second through third rows and first 2 columns
df.iloc[[0,5], [1,3]] #1st and 6th rows and 2nd and 4th columns

40
Data Frames: Sorting
We can sort the data by a value in the column. By default the sorting will occur in 
ascending order and a new data frame is return. 

41
Data Frames: Sorting
We can sort the data using 2 or more columns:

42
Aggregation Functions in Pandas
Aggregation ‐ computing a summary statistic about each group, i.e.
• compute group sums or means
• compute group sizes/counts

Common aggregation functions:

min, max
count, sum, prod
mean, median, mode, mad
std, var

43
Aggregation Functions in Pandas
agg() method are useful when multiple statistics are computed per column:

44
Basic Descriptive Statistics
df.method() description
describe Basic statistics (count, mean, std, min, quantiles, max)

min, max Minimum and maximum values

mean, median, mode Arithmetic average, median and mode

var, std Variance and standard deviation

sem Standard error of mean

skew Sample skewness

kurt kurtosis

45
Graphics to explore the data
Seaborn package is built on matplotlib but provides high level 
interface for drawing attractive statistical graphics, similar to ggplot2 
library in R. It specifically targets statistical data visualization

To show graphs within Python notebook include inline directive:

46
Graphics
description
histplot histogram
barplot estimate of central tendency for a numeric variable
violinplot similar to boxplot, also shows the probability density of the 
data
jointplot Scatterplot
regplot Regression plot
pairplot Pairplot
boxplot boxplot
swarmplot categorical scatterplot
factorplot General categorical plot

47
Draw Histogram Using Matplotlib

48
Draw Histogram Using Seaborn

49
Draw Barplot Using Matplotlib

50
Draw Barplot Using Seaborn

51
Draw Barplot Using Seaborn

52
Draw Scatterplot Using Seaborn

53
Draw Boxplot Using Seaborn

54
Python for Machine Learning
Machine learning: the problem setting:
In general, a learning problem considers a set of n samples of data and then tries to 
predict properties of unknown data. If each sample is more than a single number and, 
for instance, a multi‐dimensional entry (aka multivariate data), it is said to have several 
attributes or features.

We can separate learning problems in a few large categories:
• Supervised Learning (https://sklearn.org/supervised_learning.html#supervised‐learning)
• Classification
• Regression
• Unsupervised Learning (https://sklearn.org/unsupervised_learning.html#unsupervised‐learning)
• Clustering
55
Python for Machine Learning
Training set and testing set:

Machine learning is about learning some properties of a data set and applying 
them to new data. This is why a common practice in machine learning to 
evaluate an algorithm is to split the data at hand into two sets, one that we call 
the training set on which we learn data properties and one that we call the
testing set on which we test these properties.

scikit‐learn comes with a few standard datasets, for instance the iris and digits

datasets for classification and the boston house prices dataset for regression.

56
Loading an example dataset

A dataset is a dictionary‐like object that holds all the data and some metadata 
about the data. This data is stored in the .data member, which is a (n_samples,
n_features) array. In the case of supervised problem, one or more response 
variables are stored in the .target member.

57
Loading an example dataset ‐ digits
An example showing how the scikit‐learn can be used to recognize images of 
hand‐written digits.

58
Loading an example dataset ‐ digits
For instance, in the case of the digits dataset, digits.data gives access to the 
features that can be used to classify the digits samples:

and digits.target gives the ground truth for the digit dataset, that is the number 

corresponding to each digit image that we are trying to learn:

59
Learning and predicting
In the case of the digits dataset, the task is to predict, given an image, which 
digit it represents. We are given samples of each of the 10 possible classes (the 
digits zero through nine) on which we fit a classifier to be able to predict the 
classes to which unseen samples belong.

In scikit‐learn, a classifier for classification is a Python object that implements 

the methods fit(X, y) and predict(T).

An example of a classifier is the class sklearn.svm.SVC, which implements

support vector classification. The classifier’s constructor takes as arguments 
the model’s parameters.

60
Learning and predicting
For now, we will consider the classifier as a black box:

Choosing the parameters of the model
In this example, we set the value of gamma manually. To find good values for 
these parameters, we can use tools such as grid search and cross validation.

61
Learning and predicting
For the training set, we’ll use all the images from our dataset, except for the last 
image, which we’ll reserve for our predicting. We select the training set with 
the [:‐1] Python syntax, which produces a new array that contains all but the 
last item from digits.data:

62
Learning and predicting
Now you can predict new values. In this case, you’ll predict using the last image 
from digits.data. By predicting, you’ll determine the image from the training set 
that best matches the last image.

The corresponding image is:

63
Model persistence
It is possible to save a model in scikit‐learn by using  pickle:

64