Numpy

2020 年 06 月 04 日 • 阅读数: 138

Numpy

import numpy as np

Numpy中的基本格式 (numpy.arry)

  • numpy中的一个基本数据类型,称为ndarry
  • 实际相当于一个数组,可以是多维的
  • 可以用列表的形式创建一个数组
vector = np.array([5,10,15,20])
matrix = np.array([[5,10,15],[20,25,30],[35,40,45]])
print(vector)
print(matrix)
[ 5 10 15 20]
[[ 5 10 15]
 [20 25 30]
 [35 40 45]]

输出一个数据的格式

  • 通过shape可以得到一个数据的格式
  • 它会返回一个数据是行和列
print(vector.shape)
print(matrix.shape)
(4,)
(3, 3)

在数组中必须传入相同的结构

  • 如果类型不同,则会将全部数据都进行类型转换,转换成更通用的格式
  • int类型中如只要有一个float都会转换成float,有一个str,都会转换成str
na1 = np.array([5,10,15,20])
na2 = np.array([5,10,15,20.0])
na3 = np.array([5,10,15.0,'20'])
print(na1)
print(na2)
print(na3)
print(na1.dtype)
print(na2.dtype)
print(na3.dtype)
[ 5 10 15 20]
[ 5. 10. 15. 20.]
['5' '10' '15.0' '20']
int64
float64
<U32

索引

  • 通过方括号加下标索引
matrix[1,2]
30

切片

  • 单列切片,类似于列表
  • 数组切片,逗号前面的表示对行的操作,逗号后面的表示对列的操作
vector = np.array([5,10,15,20])
matrix = np.array([[5,10,15],[20,25,30],[35,40,45]])
vector[0:3]
array([ 5, 10, 15])
matrix
array([[ 5, 10, 15],
       [20, 25, 30],
       [35, 40, 45]])
print('取一列:\n',matrix[:,1])
print('取一行:\n',matrix[1,:])
print('取前2行,前2列:\n',matrix[0:2,0:2])
print('取第1行,第1列:\n',matrix[1,1])
取一列:
 [10 25 40]
取一行:
 [20 25 30]
取前2行,前2列:
 [[ 5 10]
 [20 25]]
取第1行,第1列:
 25

数组运算

  • 直接用 == 判断一个数是否在数组中
  • 该方法会对数组中的每一个元素进行比较,返回一个bool类型的数组
  • 将一个数组与该返回值进行匹配,返回为True的值
na = np.array([50,55,60,65])
res = (vector == 10)
print(na[res])
print(res)
[55]
[False  True False False]
res = matrix[:,1] == 25
matrix[res,:]
array([[20, 25, 30]])
  • 也可以直接使用运算符对数组进行操作
  • 关系运算用&和|表示
  • 也可以直接用条件运算符
vector = np.array([1,4,6,8,9,12,14,15])
res1 = (vector%2 == 0) & (vector%3 == 0)
print(res1)
res2 = (vector < 5) | (vector > 10)
print(res2)
[False False  True False False  True False False]
[ True  True False False False  True  True  True]

类型转换

  • 用astype()方法对数组类型进行强制转换
vector = np.array(['1','2','3',4,5])
print(vector.dtype)
print(vector)
vector = vector.astype(float)
print(vector.dtype)
print(vector)
vector = vector.astype(int)
print(vector.dtype)
print(vector)
<U1
['1' '2' '3' '4' '5']
float64
[1. 2. 3. 4. 5.]
int64
[1 2 3 4 5]

求和

  • 可以用sum函数进行求和
  • 其中sum有一个重要参数,axis可以用来指定维度,0表示按列求和,1表示按行求和
matrix
array([[ 5, 10, 15],
       [20, 25, 30],
       [35, 40, 45]])
print(matrix.sum())
print(matrix.sum(axis=1))
print(matrix.sum(axis=0))
225
[ 30  75 120]
[60 75 90]

常用函数

  • arange()生成元素
  • reshape()指定数组的外形
print(np.arange(15))
a = np.arange(15).reshape(3,5)
print(a)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

常用属性

  • shape行数和列数
  • ndim维数
  • dtype.name类型名
  • size大小,多维数组求大小不能直接用len()函数
print(a.shape)
print(a.ndim)
print(a.dtype.name)
print(a.size)
(3, 5)
2
int64
15
3

常用的矩阵初始化操作

  • zeros()创建全0的一个矩阵接收一个元组的参数
  • ones()创建全1的一个矩阵
  • arange(),可以接收3个参数,第一个开始值,第二个结束值,第三个间隔
np.zeros((3,5))
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])
np.ones((2,3,4),dtype=np.int32)
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]], dtype=int32)
np.arange(10,100,5).reshape(3,-1)
array([[10, 15, 20, 25, 30, 35],
       [40, 45, 50, 55, 60, 65],
       [70, 75, 80, 85, 90, 95]])

random模块

  • numpy中自带一个random模块
  • 类似于标准库中的random
np.random.random((3,4))
array([[0.62789407, 0.38303378, 0.28460068, 0.06867036],
       [0.30441598, 0.55916501, 0.27891166, 0.70952248],
       [0.08824296, 0.99201707, 0.61598535, 0.2982303 ]])

linspance()函数

  • 该函数接收3个参数,第1个初始值,第2个结束值,第3个数据个数
  • 数据的值是从开始到结束再取平均值得得到的
np.linspace(0,2*np.pi,100)
array([0.        , 0.06346652, 0.12693304, 0.19039955, 0.25386607,
       0.31733259, 0.38079911, 0.44426563, 0.50773215, 0.57119866,
       0.63466518, 0.6981317 , 0.76159822, 0.82506474, 0.88853126,
       0.95199777, 1.01546429, 1.07893081, 1.14239733, 1.20586385,
       1.26933037, 1.33279688, 1.3962634 , 1.45972992, 1.52319644,
       1.58666296, 1.65012947, 1.71359599, 1.77706251, 1.84052903,
       1.90399555, 1.96746207, 2.03092858, 2.0943951 , 2.15786162,
       2.22132814, 2.28479466, 2.34826118, 2.41172769, 2.47519421,
       2.53866073, 2.60212725, 2.66559377, 2.72906028, 2.7925268 ,
       2.85599332, 2.91945984, 2.98292636, 3.04639288, 3.10985939,
       3.17332591, 3.23679243, 3.30025895, 3.36372547, 3.42719199,
       3.4906585 , 3.55412502, 3.61759154, 3.68105806, 3.74452458,
       3.8079911 , 3.87145761, 3.93492413, 3.99839065, 4.06185717,
       4.12532369, 4.1887902 , 4.25225672, 4.31572324, 4.37918976,
       4.44265628, 4.5061228 , 4.56958931, 4.63305583, 4.69652235,
       4.75998887, 4.82345539, 4.88692191, 4.95038842, 5.01385494,
       5.07732146, 5.14078798, 5.2042545 , 5.26772102, 5.33118753,
       5.39465405, 5.45812057, 5.52158709, 5.58505361, 5.64852012,
       5.71198664, 5.77545316, 5.83891968, 5.9023862 , 5.96585272,
       6.02931923, 6.09278575, 6.15625227, 6.21971879, 6.28318531])

算数运算

  • 相同外形的数组按照对应的数据进行运算
  • 一个数组也可以与一个单独的值进行运算,这时候每一个元素都会分别计算
a = np.array([10,20,30,40,50])
b = np.arange(5)
print(a)
print(b)
print(a-b)
print(a+b)
print(a*b)
print(b/a)
[10 20 30 40 50]
[0 1 2 3 4]
[10 19 28 37 46]
[10 21 32 43 54]
[  0  20  60 120 200]
[0.         0.05       0.06666667 0.075      0.08      ]
a = np.array([[10,20,30],[40,50,60]])
b = np.arange(6).reshape(2,3)
print(a)
print(b)
print(a+b)
print(a-b)
[[10 20 30]
 [40 50 60]]
[[0 1 2]
 [3 4 5]]
[[10 21 32]
 [43 54 65]]
[[10 19 28]
 [37 46 55]]
print(a+10)
print(b**2)
[[20 30 40]
 [50 60 70]]
[[ 0  1  4]
 [ 9 16 25]]

矩阵特殊操作

  • 用.dot()进行点乘操作
A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])
print(A.dot(B))
print('--------')
print(np.dot(A,B))
[[5 4]
 [3 4]]
--------
[[5 4]
 [3 4]]

向下取整

  • 通过floor方法取整
  • 小数后直接舍弃
a = 10*np.random.random((3,4))
print(a)
a = np.floor(a)
print(a)
[[9.73905955 5.08071427 7.7515079  5.62716668]
 [9.64926669 1.39220652 7.49929957 2.59475764]
 [5.96838851 6.51645269 0.48367845 0.8061853 ]]
[[9. 5. 7. 5.]
 [9. 1. 7. 2.]
 [5. 6. 0. 0.]]

将一个矩阵转换为向量

  • 通过ravel()函数,将一个多行的矩阵转换为单行
print(a.ravel())
[9. 5. 7. 5. 9. 1. 7. 2. 5. 6. 0. 0.]

转置

a.shape = (6,2)
print(a)
print('---------------------')
print(a.T)
[[9. 5.]
 [7. 5.]
 [9. 1.]
 [7. 2.]
 [5. 6.]
 [0. 0.]]
---------------------
[[9. 7. 9. 7. 5. 0.]
 [5. 5. 1. 2. 6. 0.]]

矩阵的拼接

  • hstack()水平拼接
  • vstack()垂直拼接
a = np.array([[3,1],[0,1]])
b = np.array([[4,2],[9,2]])
print(np.hstack((a,b)))
print(np.hstack((b,a)))
print(np.vstack((a,b)))
[[3 1 4 2]
 [0 1 9 2]]
[[4 2 3 1]
 [9 2 0 1]]
[[3 1]
 [0 1]
 [4 2]
 [9 2]]

矩阵的分割

  • hsplit()水平分割,传单个的数值会平均切成多少份
  • vsplit()垂直分割,传一个元组,会按元组中指定位置进行分割
a = np.random.randint(1,10,(2,12))
print(a)
print('-------------------------')
for each in np.hsplit(a,3):
    print(each)
    print('---------------------')
for foo in np.hsplit(a,(3,5)):
    print(foo)
    print('---------------------')
[[5 1 9 2 3 9 2 8 8 3 6 7]
 [3 4 4 8 9 7 8 5 2 5 3 9]]
-------------------------
[[5 1 9 2]
 [3 4 4 8]]
---------------------
[[3 9 2 8]
 [9 7 8 5]]
---------------------
[[8 3 6 7]
 [2 5 3 9]]
---------------------
[[5 1 9]
 [3 4 4]]
---------------------
[[2 3]
 [8 9]]
---------------------
[[9 2 8 8 3 6 7]
 [7 8 5 2 5 3 9]]
---------------------

复制操作

  • 直接赋值,只是将数据的地址进行赋值,并没有重新开辟内存空间
  • view()函数,浅复制
  • copy()函数,深复制

数组的索引

  • argmax()求数组的最大值
data = np.sin(np.arange(20)).reshape(5,4)
print(data)
ind = data.argmax(axis=0)
print(ind)
data_max = data[ind,range(data.shape[1])]
print(data_max)
[[ 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]
[0.98935825 0.84147098 0.99060736 0.6569866 ]

数组的扩展

  • tile()可以扩展一个数组,第一个参数,传入一个数组,第二个传入一个行和列的元组
a = np.array([1,3,9])
b = np.tile(a,(2,2))
print(a)
print(b)
[1 3 9]
[[1 3 9 1 3 9]
 [1 3 9 1 3 9]]

排序

  • 通过sort方法可以对一个数组进行排序
  • 通过argsort方法,先获得索引,再利用索引排序
a = np.array([[4,3,5],[1,2,1]])
print(a)
print('------------')
b = np.sort(a,axis=1)
print(b)
print('------------')
c = np.sort(b,axis=0)
print(c)
print('------------')
d = np.array([6,8,3,5,1])
print(d)
print('------------')
e = np.argsort(d)
print(e)
print('------------')
f = d[e]
print(f)
[[4 3 5]
 [1 2 1]]
------------
[[3 4 5]
 [1 1 2]]
------------
[[1 1 2]
 [3 4 5]]
------------
[6 8 3 5 1]
------------
[4 2 3 0 1]
------------
[1 3 5 6 8]
标签: 数据分析Python
添加评论
评论列表
没有更多内容