This document provides an overview of NumPy, the core library for scientific computing in Python. It discusses NumPy arrays, which provide a grid of values that are all of the same type and indexed by tuples of integers. NumPy arrays can be initialized from nested lists and accessed using square brackets. NumPy also provides functions to create arrays filled with zeros, ones, random values, or a constant. The document covers slicing NumPy arrays to extract subarrays, and integer array indexing to construct arbitrary arrays from another array's data. It demonstrates how slicing returns views into the original data, while integer indexing allows selecting elements in any order.
Steps To Getting Up And Running Quickly With MyTimeClock Employee Scheduling ...
Python Tutorial
1.
Python - Tutorial
Eueung Mulyana
http://eueung.github.io/EL5244/py-tut
based on the material at CS231n@Stanford | Attribution-ShareAlike CC BY-SA
1 / 42
5. x=3
printtype(x)#Prints"<type'int'>"
printx #Prints"3"
printx+1 #Addition;prints"4"
printx-1 #Subtraction;prints"2"
printx*2 #Multiplication;prints"6"
printx**2 #Exponentiation;prints"9"
x+=1
printx #Prints"4"
x*=2
printx #Prints"8"
y=2.5
printtype(y)#Prints"<type'float'>"
printy,y+1,y*2,y**2#Prints"2.53.55.06.25"
t=True
f=False
printtype(t)#Prints"<type'bool'>"
printtandf#LogicalAND;prints"False"
printtorf #LogicalOR;prints"True"
printnott #LogicalNOT;prints"False"
printt!=f #LogicalXOR;prints"True"
Basic Data Types
Numbers
Integers and floats work as you would
expect from other languages
Does not have unary increment (x++) or
decrement (x--) operators
Other: built-in types for long integers
and complex numbers
Booleans
Python implements all of the usual
operators for Boolean logic, but uses
English words rather than symbols (&&, ||,
etc.):
5 / 42
6. Basic Data Types
Strings
String objects have a lot of useful methods.
hello='hello' #Stringliteralscanusesinglequotes
world="world" #ordoublequotes;itdoesnotmatter.
printhello #Prints"hello"
printlen(hello) #Stringlength;prints"5"
hw=hello+''+world #Stringconcatenation
printhw #prints"helloworld"
hw12='%s%s%d'%(hello,world,12) #sprintfstylestring
printhw12 #prints"helloworld12"
s="hello"
prints.capitalize() #Capitalizeastring;prints"Hello"
prints.upper() #Convertastringtouppercase;prints
prints.rjust(7) #Right-justifyastring,paddingwiths
prints.center(7) #Centerastring,paddingwithspaces;
prints.replace('l','(ell)') #Replaceallinstancesofone
#prints"he(ell)(ell)o"
print' world'.strip() #Stripleadingandtrailingwhitesp
6 / 42
7. xs=[3,1,2] #Createalist
printxs,xs[2] #Prints"[3,1,2]2"
printxs[-1] #Negativeindicescountfromtheendofthelist;prints"2"
xs[2]='foo' #Listscancontainelementsofdifferenttypes
printxs #Prints"[3,1,'foo']"
xs.append('bar')#Addanewelementtotheendofthelist
printxs #Prints
x=xs.pop() #Removeandreturnthelastelementofthelist
printx,xs #Prints"bar[3,1,'foo']"
Container Types
Python includes several built-in container
types: lists, dictionaries, sets, and tuples.
Lists
A list is the Python equivalent of an array,
but is resizeable and can contain elements
of different types.
7 / 42
8. Containers
Lists - Slicing
In addition to accessing list elements one at
a time, Python provides concise syntax to
access sublists; this is known as slicing
Lists - Looping
You can loop over the elements of a list.
If you want access to the index of each
element within the body of a loop, use the
built-in enumeratefunction.
nums=range(5) #rangeisabuilt-infunctionthatcreates
printnums #Prints"[0,1,2,3,4]"
printnums[2:4] #Getaslicefromindex2to4(exclusive)
printnums[2:] #Getaslicefromindex2totheend;prin
printnums[:2] #Getaslicefromthestarttoindex2(ex
printnums[:] #Getasliceofthewholelist;prints["0
printnums[:-1] #Sliceindicescanbenegative;prints["0
nums[2:4]=[8,9]#Assignanewsublisttoaslice
printnums #Prints"[0,1,8,9,4]"
animals=['cat','dog','monkey']
foranimalinanimals:
printanimal
#Prints"cat","dog","monkey",eachonitsownline.
#------
animals=['cat','dog','monkey']
foridx,animalinenumerate(animals):
print'#%d:%s'%(idx+1,animal)
#Prints"#1:cat","#2:dog","#3:monkey",eachonitsownl
8 / 42
10. Containers
Dictionaries
A dictionary stores (key, value) pairs,
similar to a Mapin Java or an objectin
Javascript.
Dicts - Looping
It is easy to iterate over the keys in a
dictionary.
If you want access to keys and their
corresponding values, use the iteritems
method.
d={'cat':'cute','dog':'furry'} #Createanewdictionary
printd['cat'] #Getanentryfromadictionary;prints
print'cat'ind #Checkifadictionaryhasagivenkey;
d['fish']='wet' #Setanentryinadictionary
printd['fish'] #Prints"wet"
#printd['monkey'] #KeyError:'monkey'notakeyofd
printd.get('monkey','N/A') #Getanelementwithadefault;
printd.get('fish','N/A') #Getanelementwithadefault;
deld['fish'] #Removeanelementfromadictionary
printd.get('fish','N/A')#"fish"isnolongerakey;prints
d={'chicken':2,'cat':4,'spider':8}
foranimalind:
legs=d[animal]
print'A%shas%dlegs'%(animal,legs)
#Prints"Achickenhas2legs","Aspiderhas8legs","Acat
d={'chicken':2,'cat':4,'spider':8}
foranimal,legsind.iteritems():
print'A%shas%dlegs'%(animal,legs)
#Prints"Achickenhas2legs","Aspiderhas8legs","Acat
10 / 42
14. Containers
Tuples
A tuple is an (immutable) ordered list of
values. A tuple is in many ways similar to a
list.
One of the most important differences is
that tuples can be used as keys in
dictionaries and as elements of sets, while
lists cannot.
d={(x,x+1):xforxinrange(10)} #Createadictionary
t=(5,6) #Createatuple
printtype(t) #Prints"<type'tuple'>"
printd[t] #Prints"5"
printd[(1,2)] #Prints"1"
14 / 42
19. importnumpyasnp
a=np.array([1,2,3]) #Createarank1array
printtype(a) #Prints"<type'numpy.ndarray'>"
printa.shape #Prints"(3,)"
printa[0],a[1],a[2] #Prints"123"
a[0]=5 #Changeanelementofthearray
printa #Prints"[5,2,3]"
b=np.array([[1,2,3],[4,5,6]]) #Createarank2array
printb.shape #Prints"(2,3)"
printb[0,0],b[0,1],b[1,0] #Prints"124"
#-----
a=np.zeros((2,2)) #Createanarrayofallzeros
printa #Prints"[[0. 0.]
# [0. 0.]]"
b=np.ones((1,2)) #Createanarrayofallones
printb #Prints"[[1. 1.]]"
c=np.full((2,2),7)#Createaconstantarray
printc #Prints"[[7. 7.]
# [7. 7.]]"
d=np.eye(2) #Createa2x2identitymatrix
printd #Prints"[[1. 0.]
# [0. 1.]]"
e=np.random.random((2,2))#Createanarrayfilledwithrandomvalues
printe #Mightprint"[[0.91940167 0.08143941]
# [0.68744134 0.87236687]]"
Numpy
Numpy is the core library for scientific
computing in Python. It provides a high-
performance multidimensional array
object (MATLAB style), and tools for
working with these arrays.
Arrays
A numpy array is a grid of values, all
of the same type, and is indexed by a
tuple of nonnegative integers.
The number of dimensions is the rank
of the array; the shape of an array is a
tuple of integers giving the size of the
array along each dimension.
We can initialize numpy arrays from
nested Python lists, and access
elements using square brackets.
Numpy also provides many functions
to create arrays.
19 / 42
20. Numpy
Array Indexing - Slicing
Numpy offers several ways to index into
arrays.
Similar to Python lists, numpy arrays can
be sliced.
Since arrays may be multidimensional, you
must specify a slice for each dimension of
the array.
importnumpyasnp
#Createthefollowingrank2arraywithshape(3,4)
#[[1 2 3 4]
# [5 6 7 8]
# [9101112]]
a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
#Useslicingtopulloutthesubarrayconsistingofthefirst
#andcolumns1and2;bisthefollowingarrayofshape(2,2
#[[23]
# [67]]
b=a[:2,1:3]
#Asliceofanarrayisaviewintothesamedata,somodifyi
#willmodifytheoriginalarray.
printa[0,1] #Prints"2"
b[0,0]=77 #b[0,0]isthesamepieceofdataasa[0,1]
printa[0,1] #Prints"77"
20 / 42
21. importnumpyasnp
#Createthefollowingrank2arraywithshape(3,4)
#[[1 2 3 4]
# [5 6 7 8]
# [9101112]]
a=np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
#Twowaysofaccessingthedatainthemiddlerowofthearray.
#Mixingintegerindexingwithslicesyieldsanarrayoflowerrank,
#whileusingonlyslicesyieldsanarrayofthesamerankasthe
#originalarray:
row_r1=a[1,:] #Rank1viewofthesecondrowofa
row_r2=a[1:2,:] #Rank2viewofthesecondrowofa
printrow_r1,row_r1.shape #Prints"[5678](4,)"
printrow_r2,row_r2.shape #Prints"[[5678]](1,4)"
#Wecanmakethesamedistinctionwhenaccessingcolumnsofanarray:
col_r1=a[:,1]
col_r2=a[:,1:2]
printcol_r1,col_r1.shape #Prints"[2 610](3,)"
printcol_r2,col_r2.shape #Prints"[[2]
# [6]
# [10]](3,1)"
Numpy
Array Indexing - Slicing
You can also mix integer indexing with
slice indexing.
However, doing so will yield an array of
lower rank than the original array.
Note that this is quite different from the
way that MATLAB handles array slicing.
21 / 42
22. Numpy
Array Indexing - Integer Array
Indexing
When you index into numpy arrays using
slicing, the resulting array view will
always be a subarray of the original array.
In contrast, integer array indexing allows
you to construct arbitrary arrays using the
data from another array.
importnumpyasnp
a=np.array([[1,2],[3,4],[5,6]])
#Anexampleofintegerarrayindexing.
#Thereturnedarraywillhaveshape(3,)and
printa[[0,1,2],[0,1,0]] #Prints"[145]"
#Theaboveexampleofintegerarrayindexingisequivalentto
printnp.array([a[0,0],a[1,1],a[2,0]]) #Prints"[145]
#Whenusingintegerarrayindexing,youcanreusethesame
#elementfromthesourcearray:
printa[[0,0],[1,1]] #Prints"[22]"
#Equivalenttothepreviousintegerarrayindexingexample
printnp.array([a[0,1],a[0,1]]) #Prints"[22]"
22 / 42
24. Numpy
Datatypes
Every numpy array is a grid of elements of
the same type.
Numpy provides a large set of numeric
datatypes that you can use to construct
arrays.
Numpy tries to guess a datatype when you
create an array, but functions that
construct arrays usually also include an
optional argument to explicitly specify the
datatype.
importnumpyasnp
x=np.array([1,2]) #Letnumpychoosethedatatype
printx.dtype #Prints"int64"
x=np.array([1.0,2.0]) #Letnumpychoosethedatatype
printx.dtype #Prints"float64"
x=np.array([1,2],dtype=np.int64) #Forceaparticulardat
printx.dtype #Prints"int64"
24 / 42
26. Numpy
Array Math
Note that unlike MATLAB, *is elementwise
multiplication, not matrix multiplication.
We instead use the dot function to compute
inner products of vectors, to multiply a
vector by a matrix, and to multiply
matrices.
dot is available both as a function in the
numpy module and as an instance method
of array objects
importnumpyasnp
x=np.array([[1,2],[3,4]])
y=np.array([[5,6],[7,8]])
v=np.array([9,10])
w=np.array([11,12])
#Innerproductofvectors;bothproduce219
printv.dot(w)
printnp.dot(v,w)
#Matrix/vectorproduct;bothproducetherank1array[296
printx.dot(v)
printnp.dot(x,v)
#Matrix/matrixproduct;bothproducetherank2array
#[[1922]
# [4350]]
printx.dot(y)
printnp.dot(x,y)
26 / 42
27. importnumpyasnp
x=np.array([[1,2],[3,4]])
printnp.sum(x) #Computesumofallelements;prints"10"
printnp.sum(x,axis=0) #Computesumofeachcolumn;prints"[46]"
printnp.sum(x,axis=1) #Computesumofeachrow;prints"[37]"
importnumpyasnp
x=np.array([[1,2],[3,4]])
printx #Prints"[[12]
# [34]]"
printx.T #Prints"[[13]
# [24]]"
#Notethattakingthetransposeofarank1arraydoesnothing:
v=np.array([1,2,3])
printv #Prints"[123]"
printv.T #Prints"[123]"
Numpy
Array Math
Numpy provides many useful functions for
performing computations on arrays; one of
the most useful is sum.
Apart from computing mathematical
functions using arrays, we frequently need
to reshape or otherwise manipulate data in
arrays.
The simplest example of this type of
operation is transposing a matrix; to
transpose a matrix, simply use the T
attribute of an array object.
27 / 42
28. Numpy
Broadcasting
Broadcasting is a powerful mechanism that
allows numpy to work with arrays of
different shapes when performing
arithmetic operations.
Frequently we have a smaller array and a
larger array, and we want to use the
smaller array multiple times to perform
some operation on the larger array.
For example, suppose that we want to add
a constant vector to each row of a matrix ...
importnumpyasnp
#Wewilladdthevectorvtoeachrowofthematrixx,
#storingtheresultinthematrixy
x=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
v=np.array([1,0,1])
y=np.empty_like(x) #Createanemptymatrixwiththesame
#Addthevectorvtoeachrowofthematrixxwithanexplici
foriinrange(4):
y[i,:]=x[i,:]+v
#Nowyisthefollowing
#[[2 2 4]
# [5 5 7]
# [8 810]
# [111113]]
printy
28 / 42
30. Numpy
Broadcasting
Numpy broadcasting allows us to perform
this computation without actually creating
multiple copies of v. Consider this version,
using broadcasting.
The line y=x+vworks even though xhas
shape (4, 3) and vhas shape (3,) due to
broadcasting.
This line works as if vactually had shape
(4, 3), where each row was a copy of v, and
the sum was performed elementwise.
importnumpyasnp
#Wewilladdthevectorvtoeachrowofthematrixx,
#storingtheresultinthematrixy
x=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
v=np.array([1,0,1])
y=x+v #Addvtoeachrowofxusingbroadcasting
printy #Prints"[[2 2 4]
# [5 5 7]
# [8 810]
# [111113]]"
30 / 42
31. importnumpyasnp
#Computeouterproductofvectors
v=np.array([1,2,3]) #vhasshape(3,)
w=np.array([4,5]) #whasshape(2,)
#Tocomputeanouterproduct,wefirstreshapevtobeacolumn
#vectorofshape(3,1);wecanthenbroadcastitagainstwtoyield
#anoutputofshape(3,2),whichistheouterproductofvandw:
#[[4 5]
# [810]
# [1215]]
printnp.reshape(v,(3,1))*w
#Addavectortoeachrowofamatrix
x=np.array([[1,2,3],[4,5,6]])
#xhasshape(2,3)andvhasshape(3,)sotheybroadcastto(2,3),
#givingthefollowingmatrix:
#[[246]
# [579]]
printx+v
#.....
Broadcasting two arrays together follows
these rules:
If the arrays do not have the same
rank, prepend the shape of the lower
rank array with 1s until both shapes
have the same length.
The two arrays are said to be
compatible in a dimension if they have
the same size in the dimension, or if
one of the arrays has size 1 in that
dimension.
The arrays can be broadcast together if
they are compatible in all dimensions.
After broadcasting, each array behaves
as if it had shape equal to the
elementwise maximum of shapes of
the two input arrays.
In any dimension where one array had
size 1 and the other array had size
greater than 1, the first array behaves
as if it were copied along that
dimension.
31 / 42
32. Numpy
Broadcasting
Functions that support broadcasting are
known as universal functions.
Broadcasting typically makes your code
more concise and faster, so you should
strive to use it where possible.
#.....
#Addavectortoeachcolumnofamatrix
#xhasshape(2,3)andwhasshape(2,).
#Ifwetransposexthenithasshape(3,2)andcanbebroadc
#againstwtoyieldaresultofshape(3,2);transposingthi
#yieldsthefinalresultofshape(2,3)whichisthematrix
#thevectorwaddedtoeachcolumn.Givesthefollowingmatri
#[[5 6 7]
# [91011]]
print(x.T+w).T
#Anothersolutionistoreshapewtobearowvectorofshape
#wecanthenbroadcastitdirectlyagainstxtoproducethes
#output.
printx+np.reshape(w,(2,1))
#Multiplyamatrixbyaconstant:
#xhasshape(2,3).Numpytreatsscalarsasarraysofshape
#thesecanbebroadcasttogethertoshape(2,3),producingt
#followingarray:
#[[2 4 6]
# [81012]]
printx*2
32 / 42
36. SciPy
MATLAB Files
The functions scipy.io.loadmatand
scipy.io.savematallow you to read and
write MATLAB files.
Distance between Points
SciPy defines some useful functions for
computing distances between sets of
points.
The function scipy.spatial.distance.pdist
computes the distance between all pairs of
points in a given set.
A similar function
(scipy.spatial.distance.cdist) computes
the distance between all pairs across two
sets of points.
importnumpyasnp
fromscipy.spatial.distanceimportpdist,squareform
#Createthefollowingarraywhereeachrowisapointin2Ds
#[[01]
# [10]
# [20]]
x=np.array([[0,1],[1,0],[2,0]])
printx
#ComputetheEuclideandistancebetweenallrowsofx.
#d[i,j]istheEuclideandistancebetweenx[i,:]andx[j,:
#anddisthefollowingarray:
#[[0. 1.41421356 2.23606798]
# [1.41421356 0. 1. ]
# [2.23606798 1. 0. ]]
d=squareform(pdist(x,'euclidean'))
printd
36 / 42
40. Matplotlib
Subplots
You can plot different things in the same
figure using the subplot function.
importnumpyasnp
importmatplotlib.pyplotasplt
#Computethexandycoordinatesforpointsonsineandcosin
x=np.arange(0,3*np.pi,0.1)
y_sin=np.sin(x)
y_cos=np.cos(x)
#Setupasubplotgridthathasheight2andwidth1,
#andsetthefirstsuchsubplotasactive.
plt.subplot(2,1,1)
#Makethefirstplot
plt.plot(x,y_sin)
plt.title('Sine')
#Setthesecondsubplotasactive,andmakethesecondplot.
plt.subplot(2,1,2)
plt.plot(x,y_cos)
plt.title('Cosine')
#Showthefigure.
plt.show()
40 / 42