python大数据之numpy

numpy

创建数组

• arange()：类似列表里面的range
• reshape()：重塑
• array（）：可以使用dtype定义参数类型（int64，float32，complex）
• linspace（）：按个数来创建数组而不是step
• logspace（）:按照指数来进行计算。
• zeros,ones,empty,eye：创建全0，全1，随机，对角矩阵
• 属性查看：ndim（维度），shape（形状）元组的size就是阶数，dtype（类型），itemsize（字节），size（长度）
• r_函数：可支持操作符运算

# ndarray is class about array
import numpy as np 

a = np.arange(15).reshape(3,5)
print(f"ndim:{a.ndim}\nshape:{a.shape}\ndtype:{a.dtype}\nitemsize:{a.itemsize}\n{a}")

# create an array by 'list' or 'tuple'

c = np.array( [ [1,2], [3,4] ], dtype=complex )   # complex is scientific notation
print(f"dtype:{c.dtype}\n{c}")

# zeros,ones,empty   ; create an array is easier than growing an array
np.arange( 0, 2, 0.3 )                 # it accepts float arguments

# linspace
from numpy import pi
x = np.linspace(0,pi,100)   # use linspace can get an detal number
f = np.sin(x)
print(f)

```
ndim:2
shape:(3, 5)
dtype:int64
itemsize:8
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

dtype:complex128
[[1.+0.j 2.+0.j]
 [3.+0.j 4.+0.j]]
array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])

[0.00000000e+00 3.17279335e-02 6.34239197e-02 9.50560433e-02
 1.26592454e-01 1.58001396e-01 1.89251244e-01 2.20310533e-01
 2.51147987e-01 2.81732557e-01 3.12033446e-01 3.42020143e-01
 3.71662456e-01 4.00930535e-01 4.29794912e-01 4.58226522e-01
 4.86196736e-01 5.13677392e-01 5.40640817e-01 5.67059864e-01
 5.92907929e-01 6.18158986e-01 6.42787610e-01 6.66769001e-01
 6.90079011e-01 7.12694171e-01 7.34591709e-01 7.55749574e-01
 7.76146464e-01 7.95761841e-01 8.14575952e-01 8.32569855e-01
 8.49725430e-01 8.66025404e-01 8.81453363e-01 8.95993774e-01
 9.09631995e-01 9.22354294e-01 9.34147860e-01 9.45000819e-01
 9.54902241e-01 9.63842159e-01 9.71811568e-01 9.78802446e-01
 9.84807753e-01 9.89821442e-01 9.93838464e-01 9.96854776e-01
 9.98867339e-01 9.99874128e-01 9.99874128e-01 9.98867339e-01
 9.96854776e-01 9.93838464e-01 9.89821442e-01 9.84807753e-01
 9.78802446e-01 9.71811568e-01 9.63842159e-01 9.54902241e-01
 9.45000819e-01 9.34147860e-01 9.22354294e-01 9.09631995e-01
 8.95993774e-01 8.81453363e-01 8.66025404e-01 8.49725430e-01
 8.32569855e-01 8.14575952e-01 7.95761841e-01 7.76146464e-01
 7.55749574e-01 7.34591709e-01 7.12694171e-01 6.90079011e-01
 6.66769001e-01 6.42787610e-01 6.18158986e-01 5.92907929e-01
 5.67059864e-01 5.40640817e-01 5.13677392e-01 4.86196736e-01
 4.58226522e-01 4.29794912e-01 4.00930535e-01 3.71662456e-01
 3.42020143e-01 3.12033446e-01 2.81732557e-01 2.51147987e-01
 2.20310533e-01 1.89251244e-01 1.58001396e-01 1.26592454e-01
 9.50560433e-02 6.34239197e-02 3.17279335e-02 1.22464680e-16]
```

如果数据太多，他会自动显示边角数据，想要显示全部数据

import sys

np.set_printoptions(threshold=sys.maxsize) # sys module should be imported

基本运算

• 元素运算：数组里面，元素和元素相互运算
• 矩阵运算：矩阵之间的计算方式
• sum，min，max:求所有元素的和，或者最小，最大值

# elementwise product

A = np.array( [[1,1],[0,1]] )
B = np.array( [[2,0],[3,4]] )

a = A - B
b = B**2
c = A*B
print(f"{a}\n{b}\n{c}")

#matrix product
d = A@B
g =  d == A.dot(B)
print(f"{d}\n{g}")

# += and *= is useful
# sum, min, max

```
[[-1  1]
 [-3 -3]]
[[ 4  0]
 [ 9 16]]
[[2 0]
 [0 4]]
[[5 4]
 [3 4]]
[[ True  True]
 [ True  True]]
```

轴的概念

每一个【】代表一个轴，轴里面的可以看作元素，如果该元素也有【】，可以看成另一个轴。轴的数量也能反映维度

# axis can be operate by seting

b = np.arange(12).reshape(3,4)

print(f"{b}\n{b.cumsum(axis=1)}")

```
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  3  6]
 [ 4  9 15 22]
 [ 8 17 27 38]]
```

ufunc函数

# sin, cos, exp and add is ufunc
'''
 all, any, apply_along_axis, argmax, argmin, argsort, average, bincount,
 ceil, clip, conj, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor,
 inner, INV, lexsort, max, maximun, mean, median, min, minimum, nonzero,
 outer, prod, re, round, sort, std, sum, trace, transpose, var, vdot,
 vectorize, where.
'''

切片等操作

• 和python 的列表操作类似
• 还可以通过函数来创建数组

# The operation of a one-dimensional array is the same as the python list operation

# Multidimensional Arrays
def f(x,y):
    return 10*x+y

b = np.fromfunction(f,(5,4),dtype=int)

print(b)
print(b[1:5,2])
print(b[-1])   # the last row. Equivalent to b[-1,:]

# b[-1,...] Equivalent to b[-1,:,:], if b is 3D.

```
[[ 0  1  2  3]
 [10 11 12 13]
 [20 21 22 23]
 [30 31 32 33]
 [40 41 42 43]]
[12 22 32 42]
[40 41 42 43]
```

遍历数组

• 普通的遍历，一层接着一层
• 直接遍历所有元素

for element in b.flat:
    print(element)

```
0
1
2
3
10
11
12
13
20
21
22
23
30
31
32
33
40
41
42
43
```

修改数组三种方式

• ravel（）：变成一维向量，临时的，不影响原矩阵
• reshape（）：任意修改，但是需要数值合理，-1参数可以自己计算矩阵形状，临时的，不影响原矩阵
• resize（）：原矩阵被修改

# 三个命令都返回一个修改后的数组，但不会更改原始数组
print(f"{b.ravel()}\n{b.reshape(2,10)}\n{b.T}")

# 修改数组本身的参数，resize
b.resize((2,10))
print(b)

b.reshape(5,-1)

```
[ 0  1  2  3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43]
[[ 0  1  2  3 10 11 12 13 20 21]
 [22 23 30 31 32 33 40 41 42 43]]
[[ 0 22]
 [ 1 23]
 [ 2 30]
 [ 3 31]
 [10 32]
 [11 33]
 [12 40]
 [13 41]
 [20 42]
 [21 43]]
[[ 0  1  2  3 10 11 12 13 20 21]
 [22 23 30 31 32 33 40 41 42 43]]
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33],
       [40, 41, 42, 43]])
```

数组的堆叠

# 将不同的数组堆叠在一起
from numpy import newaxis

a = np.floor(10*np.random.random((2,2)))
b = np.floor(10*np.random.random((2,2)))
print(f"{np.vstack((a,b))}\n{np.hstack((a,b))}")  #vstack 上下拼接， 左右拼接

a = np.array([4.,2.])
b = np.array([3.,8.])
print(np.column_stack((a,b)))
# column_stack 向量拼接
#把1维数组作为列向量堆叠到2D数组上
print(a[:,newaxis])
print(np.column_stack((a[:,newaxis],b[:,newaxis])))

```
[[7. 6.]
 [4. 3.]
 [7. 2.]
 [4. 9.]]
[[7. 6. 7. 2.]
 [4. 3. 4. 9.]]
[[4. 3.]
 [2. 8.]]
[[4.]
 [2.]]
[[4. 3.]
 [2. 8.]]
```

分割数组 and Others

• r_(),c_(),ix_()：一些特殊的方法
• hsplit（）：把大数组分解成小数组

# r_ 和 c_ 函数，支持范围操作符

np.r_[2:4,6,0:2,5]

#分割数组

a = np.floor(10*np.random.random((2,12)))
print(a)
print(np.hsplit(a,3))  # Split a into 3
np.hsplit(a,(3,4))   # Split a after the third and the fourth column

# ix_()函数，如果需要计算如a+b*c，函数可以自己组合不同的向量
# 这个函数肯定有他独特的用处，配合着算法

```
[[0. 0. 9. 3. 0. 7. 0. 2. 3. 2. 6. 7.]
 [6. 1. 9. 4. 0. 7. 0. 3. 7. 8. 9. 4.]]
[array([[0., 0., 9., 3.],
       [6., 1., 9., 4.]]), array([[0., 7., 0., 2.],
       [0., 7., 0., 3.]]), array([[3., 2., 6., 7.],
       [7., 8., 9., 4.]])]
[array([[0., 0., 9.],
        [6., 1., 9.]]), array([[3.],
        [4.]]), array([[0., 7., 0., 2., 3., 2., 6., 7.],
        [0., 7., 0., 3., 7., 8., 9., 4.]])]
```

浅拷贝与深拷贝

• 共享数据以及对象：只是换了标签，或者说引用
• 共享数据，但是形状可以不一样：拷贝的比较浅
• 完全独立的副本：什么都不共享，深拷贝

# 简单分配不会复制数组对象或其数据
# python将可变对象作为引用传递，因此函数调用不会复制

# 试图或浅拷贝
a = np.arange(12)
b = a
c = a.view()
d = a.copy()
e = a[:]
print(f"{a}")

# e.resize(3,4)
# e[1,3] = 1000
# print(e)
# print(a)
# 该方式在python的列表中可以做到完全的拷贝

# b.resize((3,4))
# print(a)
# b的方式，他们共享其数据

# c[5] = 1000
# c.resize((3,4))
# print(c)
# print(a)
# c的方式，他们可以拥有不同的形状，但是还是共享其数据

# 深拷贝
d.resize(3,4)
d[1,3] = 1000
print(d)
print(a)
# d的方式，他们的数据和形状都不共享，完整的复制了原先的数据

```
[ 0  1  2  3  4  5  6  7  8  9 10 11]
[[   0    1    2    3]
 [   4    5    6 1000]
 [   8    9   10   11]]
[ 0  1  2  3  4  5  6  7  8  9 10 11]
```

花式索引

• 通过整数数组来索引，可以是多维
• 通过布尔数组进行索引

# 花式索引：能够使用整数数组和布尔数组进行索引
# 常见用法是搜索与时间相关的系列的最大值

time = np.linspace(20, 145, 5)                 # time scale
data = np.sin(np.arange(20)).reshape(5,4)      # 4 time-dependent series
ind = data.argmax(axis=0) 

print(data)
print(ind)

```
[[ 0.          0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
 [ 0.98935825  0.41211849 -0.54402111 -0.99999021]
 [-0.53657292  0.42016704  0.99060736  0.65028784]
 [-0.28790332 -0.96139749 -0.75098725  0.14987721]]
[2 0 3 1]
```

线性代数

• 一些基本的运算方法

# 线性代数运算
a = np.array([[1.0, 2.0], [3.0, 4.0]])

print(f"{a.T}\n{a.transpose()}")   #转置
print(np.linalg.inv(a))   #矩阵的逆，没有逆则会报错
print(np.eye(5))     #对角矩阵
print(a@a)  #矩阵乘法
print(np.trace(a))  #矩阵的迹

#解线性方程
y = np.array([[5.], [7.]])
result = np.linalg.solve(a, y)
print(result)

```
[[1. 3.]
 [2. 4.]]
[[1. 3.]
 [2. 4.]]
[[-2.   1. ]
 [ 1.5 -0.5]]
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]
[[ 7. 10.]
 [15. 22.]]
5.0
[[-3.]
 [ 4.]]
```