Scipy and Numpy

• linear algbra linalg

import numpy as np

a1 = np.ones((2,5))
a1

array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])

from scipy import linalg as la
arr = np.array([[1,2],[2,3]])
la.det(arr)

-1.0

Array

• append()
• insert()
• read()

ndarray

• ndarray.ndim()
• ndarray.shape()
• ndarray.size()
• ndarray.dtype()
• ndarray.itemsize()
• numpy.arange()
• numpy.random.random((2,2))
• numpy.linspace()
• numpy.ones()
• numpy.zeros()

import numpy as np
np.linspace(1,2,10,endpoint=False)

array([1. , 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9])

np.fromfunction(lambda i,j:(i+1)*(j+1),(5,5))

array([[ 1.,  2.,  3.,  4.,  5.],
       [ 2.,  4.,  6.,  8., 10.],
       [ 3.,  6.,  9., 12., 15.],
       [ 4.,  8., 12., 16., 20.],
       [ 5., 10., 15., 20., 25.]])

arr = np.array([[1,2,3],[4,5,6]])
arr[0:2]

array([[1, 2, 3],
       [4, 5, 6]])

arr = np.array([[1,2,3],[4,5,6]])
arr[:,0:2]

array([[1, 2],
       [4, 5]])

for row in arr:
    print(row)

[1 2 3]
[4 5 6]

Difference between reshape and resize

arr.reshape(3,2)
arr

array([[1, 2, 3],
       [4, 5, 6]])

arr.resize(3,2)
arr

array([[1, 2],
       [3, 4],
       [5, 6]])

arr1 = np.arange(0,16).reshape(4,4)
arr1

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

arr1.reshape(2,-1)

array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15]])

• arr.hstack and arr.vstack

a1 = np.array([1,2,3])
a2 = np.array([4,5,6])
np.vstack((a1,a2))

array([[1, 2, 3],
       [4, 5, 6]])

Arithmetic operator

• '+', '-', '*', '/', and so on.
• .sum()
• .sum(axis=0)
• .sum(axis=1)
• .min()
• .argmax() # return the index of max
• .mean()
• .var()
• .std()

a3 = np.array([[4,5,6],[7,8,9]])
a1 + a3

array([[ 5,  7,  9],
       [ 8, 10, 12]])

a3+2

array([[ 6,  7,  8],
       [ 9, 10, 11]])

a3.sum(axis=0)

array([11, 13, 15])

a3.argmax() 

5

linear algbra in numpy

• np.linalg.det(x)
• np.linalg.inv(x)
• np.dot(x,y)

ufunc (universal function)

• apply_along_axis
• bincount
• argsort
• argmin
• ceil
• clip
• comsum
• comprod
• exp
• cross
• corrcoef

import math
import time
import numpy as np

x = np.arange(0,100,0.01)
tm1 = time.process_time()
for i,t in enumerate(x):
    x[i] = math.pow(math.sin(t),2)
tm2 = time.process_time()
    
y = np.arange(0,100,0.01)
tn1 = time.process_time()
y = np.power(np.sin(y),2)
tn2 = time.process_time()

print('running time by math:', tm2-tm1)
print('running time by numpy:', tn2-tn1)

running time by math: 0.015625
running time by numpy: 0.0

Series in Pandas

• consist of both index and data
• assign the index by yourself
• acess a member according to index
• arithmetic operator

import pandas as pd
s1 = pd.Series([1,2,3,4,'a'])
s1

0    1
1    2
2    3
3    4
4    a
dtype: object

s2 = pd.Series([1,2,3,'a'], index=[1,2,3,4])
s2

1    1
2    2
3    3
4    a
dtype: object

s3 = pd.Series([1,2,3,'SUFE'], index=['a','b','c','d'])
s3

a       1
b       2
c       3
d    SUFE
dtype: object

s3['b']

2

data = {'B':88, 'A':90,'T':91}
index1 = ['B','A','T','H']
s4 = pd.Series(data,index1)
s4

B    88.0
A    90.0
T    91.0
H     NaN
dtype: float64

pd.isnull(s4)

B    False
A    False
T    False
H     True
dtype: bool

s5 = s4
s6 = s4
s4['H'] = 98
s5 + s6

B    176.0
A    180.0
T    182.0
H    196.0
dtype: float64

Datafram in Pandas

• consist of index and value
• df.index
• df.columns
• df.values
• acess clumns: df.name, df['names'], df.iloc[:,1]
• acess members: df.iloc[0,1]

data = {'names':['wang','li','yang','liu','zhou'],'salaries':[4000,5000,3000,6000,4400]}
df1 = pd.DataFrame(data)
df1

	names	salaries
0	wang	4000
1	li	5000
2	yang	3000
3	liu	6000
4	zhou	4400

data = np.array([('wang',4000),('li',5000),('yang',3000),('liu',6000),('zhou',4400)])
df2 = pd.DataFrame(data,index=range(1,6),columns=['names','salaries'])
df2.index
df2.columns
df2.values

array([['wang', '4000'],
       ['li', '5000'],
       ['yang', '3000'],
       ['liu', '6000'],
       ['zhou', '4400']], dtype=object)

df2.salaries
df2['salaries']

1    4000
2    5000
3    3000
4    6000
5    4400
Name: salaries, dtype: object

df2.iloc[:,1]

1    4000
2    5000
3    3000
4    6000
5    4400
Name: salaries, dtype: object

df2.iloc[2,1]

'3000'

df2.iloc[:2,1]

1    4000
2    5000
Name: salaries, dtype: object

data = np.array([('wang',4000),('li',5000),('yang',3000),('liu',6000),('zhou',4400)])
df3 = pd.DataFrame(data,index=range(1,6),columns=['names','salaries'])
df3['names'] = 'admin'
df3

	names	salaries
1	admin	4000
2	admin	5000
3	admin	3000
4	admin	6000
5	admin	4400

del df3['salaries']
df3

	names
1	admin
2	admin
3	admin
4	admin
5	admin

df2.salaries.min()

'3000'

df2[df2.salaries>='5000']

	names	salaries
2	li	5000
4	liu	6000

np.eye(3)
np.eye(4,k=1)
np.eye(4,k=-1)

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

np.random.uniform(0,1,5)

array([0.02100736, 0.47109388, 0.06358623, 0.36710694, 0.15601807])

x1 = np.random.rand(3,5)
x1
#x1.shape[0]

array([[0.56770254, 0.89093686, 0.93961713, 0.40366624, 0.33346843],
       [0.72013447, 0.01398888, 0.04531643, 0.93985577, 0.67832158],
       [0.40438896, 0.49029484, 0.38928032, 0.66411173, 0.48375558]])

y1 = np.random.choice(np.arange(x1.shape[0]),2,replace=True)
y1

array([0, 1])

x1[y1]

array([[0.56770254, 0.89093686, 0.93961713, 0.40366624, 0.33346843],
       [0.72013447, 0.01398888, 0.04531643, 0.93985577, 0.67832158]])

x1[:,y1]

array([[0.56770254, 0.89093686],
       [0.72013447, 0.01398888],
       [0.40438896, 0.49029484]])

z1 = np.arange(5)
#z1<=2
x1[:,z1<=2]

array([[0.56770254, 0.89093686, 0.93961713],
       [0.72013447, 0.01398888, 0.04531643],
       [0.40438896, 0.49029484, 0.38928032]])

np.where(z1<=2)

(array([0, 1, 2], dtype=int64),)

np.where(z1%2)

(array([1, 3], dtype=int64),)