NumPy应用（二）

        numpy高效的处理数据，提供数组的支持， python 默认没有数组。 pandas 、 scipy 、

matplotlib 都依赖 numpy 。

1. pandas主要用于数据挖掘，探索，分析
2. maiplotlib用于作图，可视化
3. scipy进行数值计算，如：积分，傅里叶变换，微积分
4. statsmodels用于统计分析
5. Gensim用于文本挖掘
6. sklearn机器学习， keras深度学习

        Numpy是一个 Python 包，它代表 “Numeric Python”. 它是一个有多维数组对象和用于处理数组的集合组成的库。Numeric, 即 Numpy 的前身，是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005 年， Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 该开源项目有很多贡献者。

        Numpy的主要对象是同种元素的多维数组，这是一个所有的元素都是一种类型，通过一个正整数元素索引的元素表格，在Numpy 中维度（ dimensions ）叫做轴 (axes), 轴的数叫做秩（rank ） . Numpy 的数组类被称为 ndarray ，通常被称作数组。

       

1 、 array 基本信息以及生成各种常见 array 基本操作，生成 array ，得到对应的基本信息

1.1 查看

import numpy as np
array = np.array([[1,2,3],[2,3,4]])
print(array)
print(array.dtype) #查看每个元素的类型
print(array.ndim) #查看array的维度
print(array.shape) #查看形状
print(array.size) #所有元素的个数

Out:

[[1 2 3]
[2 3 4]]
int32
2
(2, 3)
6

        array的生成就是 np.array(list) ，本质上是把定义的 list 转换成 array ，因为 array 可以更加方便地计算和操作，比如矩阵的转置和相乘。

1.2 dtype

        

        不设置type，则默认为 int64, 如果设置为 int 类型而没有设置字节大小则还是默认为int64,如果元素本身为小数，则默认为 float64 。

        所以如果用int64 ，则如果元素都为整数则不需要设置默认即可，设置其他类型需要设置， float类似。

a = np.array([2, 23, 4], dtype=np.float32)
print(a)
[ 2. 23. 4.]
123

1.3 常见array格式生成

        

#生成shape为（2,3）全为0的array
b= np.zeros((2, 3), dtype=np.int)
print(b)
##生成shape为（2,3）全为1的array
c = np.ones((2,3),dtype=np.str)
print(c)
# 生成shape=(3, 4)的全为接近空的array
d = np.empty((3, 4))
print(d)
# 生成array 10到21 每隔3的一增加，for循环中主要使用
e = np.arange(10,21,3)
print(e)
# reshape能够重新定义矩阵的形状
f = np.arange(12).reshape((3,4))
print(f)
#等间隔产生6个数
g = np.linspace(1.0, 10.0, 6).reshape((3, 2))
123456789101112131415161718

Out

[[0 0 0]
[0 0 0]]
[['1' '1' '1']
['1' '1' '1']]
[[1.26043630e-311 1.26043661e-311 7.54894003e+252 2.95479883e+137]
[1.42800637e+248 2.64686750e+180 1.09936856e+248 6.99481925e+228]
[7.54894003e+252 7.67109635e+170 2.64686750e+180 5.63234836e-322]]
[10 13 16 19]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 1. 2.8]
[ 4.6 6.4]
[ 8.2 10. ]]
123456789101112131415

2、计算

2.1 加减乘除

import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arange(4)
c = a + b
print(c)
d = np.array([[1, 2],[3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
print(d*e)
print(d/e)
#维度不同下的计算
a = np.array([[1,2,3,4],[6,7,8,9]])
b = np.arange(1,5)
print(a+b)
print(a*b)
print(a/b)
1234567891011121314151617

Out:

[10 21 32 43]
[[ 1 6]
[15 28]]
[[1. 0.66666667]
[0.6 0.57142857]]
[[ 2 4 6 8]
[ 7 9 11 13]]
[[ 1 4 9 16]
[ 6 14 24 36]]
[[1. 1. 1. 1. ]
[6. 3.5 2.66666667 2.25 ]]
1234567891011121314151617

2.2 平方，三角函数，比较元素大小 , 矩阵

import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arange(4)
#平方
print(a**2)
#三角函数
print(np.sin(a))
#元素比较
print(b<3)
print(b == 3)
#矩阵计算
d = np.array([[1, 2],[3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
print(d.dot(e))
print(np.dot(d,e))
123456789101112131415

np.dot(d, e) 与 d.dot(e) 一样，都为 d 和 e 进行矩阵相乘

Out

[ 100 400 900 1600]
[-0.54402111 0.91294525 -0.98803162 0.74511316]
[ True True True False]
[False False False True]
[[11 17]
[23 37]]
[[11 17]
[23 37]]
12345678

3、随机数和max,min,sum

# 随机产生shape为（２，４）的一个array，每个元素都为0-1之间随机生成
f = np.random.random((2, 4))
print(f)
[[0.2651074 0.06022938 0.03103761 0.29572785]
[0.73063531 0.45682806 0.30643989 0.61639371]]
123456

        sum为总， min 为最小， max 为最大，如果不设置 axis 维度参数的话，则都为整个 array

的元素来说，但一般我们运用都只是算某个维度的 sum,max,min ，在二维数据中， axis=0 代

表行，第一个维度， axis=1 ，代表列为第二个维度，其实这么记并不是很好很有可能记错，

我一般都是这么记得： axis=0 为行，那意思就是每一行都要算呗？算完那不就是一列的每一

行算个数被， axis=1 类推，多维数据类推即可。

4、矩阵转置和排序，以及元素比较大小重置元素方法

        每一行进行重新大小排序当然也有axis 参数配置，根据 axis 参数说明来操作

numpy.clip(a, a_min, a_max, out=None)

a : 输入的数组

a_min: 限定的最小值 也可以是数组 , 如果为数组时 shape 必须和 a 一样

a_max: 限定的最大值 也可以是数组 ,shape 和 a 一样

out ：剪裁后的数组存入的数组

import numpy as np
# 随机产生shape为（２，４）的一个array，每个元素都为0-1之间随机生成
c = np.arange(14, 2, -1).reshape((3, 4))
print(c)
[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
#排序
print(np.sort(c))
"""
[[11 12 13 14]
[ 7 8 9 10]
[ 3 4 5 6]]
"""
#转置
print(np.transpose(c))
print(c.T)
"""
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
"""
#c矩阵中的元素小于５的等于５，大于９的等于９
print(np.clip(c, 5, 9))
"""
[[9 9 9 9]
[9 9 8 7]
[6 5 5 5]]
"""
1234567891011121314151617181920212223242526272829303132

5、平均值 中值 diff cumsum

cumsum ：每个元素变成当前元素＋前面所有元素的和

c = np.arange(14, 2, -1).reshape((3, 4))
print(np.cumsum(c))
[ 14 27 39 50 60 69 77 84 90 95 99 102]
1234

np.diff(a) # 当前元素减去前面元素的差

[[-1 -1 -1]
[-1 -1 -1]
[-1 -1 -1]]
123

6、索引

6.1 最大最小、非零索引

a = np.array([[2, 6, 0, 4],[4, 8, 9, 1],[10, 2, 3, 11]])
print(np.argmax(a))
print(np.argmax(a,axis=1))
print(np.argmax(a,axis=0))
11#值
[1 2 3] #索引
[2 1 1 2]
1234567

6.2 取行、取列、取值

a[:, 1:2] ： : 代表行所有也就是一列要的话，这一列的每一行都要， 1:2 对应的从索引为

１的列来算移植相当于取到索引为（ 2-1 ）的列， 2 为取的最高索引大一个。所以总体来讲

就是首先取每一行，之后在行里取索引１ -> １的列元素，所以为最终的结果列向量。

a[:, 1:3] ：按照上面的分析则每一行都要，列要索引为 1 和 (3-1) 的元素，那就是索引为 1

和 2 的所有元素，也就是第二列和第三列的元素。

a[1, 1:3] ：为 a[:, 1:3] 的索引为１的所有元素。

这里需要注意的是

a[:, 1] # 索引为１的列 , 生成为行向量，

a[:, 1:2] # 索引为１的列，生成为列向量

因为两种取值的思想不一样，最终造成的结果也不一样，一个是直接取，所以维度减少

了一个，另一个是在原本维度上截取，最终还是原来的维度。

import numpy as np
a = np.arange(3, 15).reshape((3, 4))
print(a)
print(a[1]) #索引为1的行，同下
print(a[:][1])
#取值 第三行第二列，如下两种表示
print(a[2,1])
print(a[2][1])
print(a[:, 1]) #索引为１的列,生成为行向量
print(a[:, 1:2]) #索引为１的列,生成为列向量
print(a[:, 1:3])
123456789101112131415

Out:

[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
[ 7 8 9 10]
[ 7 8 9 10]
12
12
[ 4 8 12]
[[ 4]
[ 8]
[12]]
[[ 4 5]
[ 8 9]
[12 13]]
123456789101112131415161718

6.3 迭代元素和降维

降维：

a.flatten() # 所有元素变成一维

import numpy as np
a = np.arange(3, 15).reshape((3, 4))# 数据都是下取上差一个取到
#迭代取所有行
for row in a:
print(row)
for column in a.T:
print(column)
print(a.flatten()) # 所有元素变成一维
print()
b = np.array([[1, 2, 3]])
#每个元素打印
for item in a.flat:
print(item)
12345678910111213141516171819

7、合并分割

np.vstack: 按垂直方向（行顺序）堆叠数组构成一个新的数组

np.hstack: 按水平方向（列顺序）堆叠数组构成一个新的数组

stack() 函数

函数原型为： stack(arrays, axis=0) ， arrays 可以传数组和列表。

import numpy as np
a = np.array([1, 1, 2])
b = np.array([2, 3, 4])
c = np.vstack((a, b))
print(c)
print(np.hstack((a,b)))
a = np.array([[1],[2],[3]])
b = np.array([[4],[5],[6]])
print(np.hstack((a,b)))
a=[[1,2,3],
[4,5,6]]
print("列表a如下：")
print(a)
print("增加一维，新维度的下标为0")
c=np.stack(a,axis=0)
print(c)
print("增加一维，新维度的下标为1")
c=np.stack(a,axis=1)
print(c)
12345678910111213141516171819202122232425

Out:

[[1 1 2]
[2 3 4]]
[1 1 2 2 3 4]
[[1 4]
[2 5]
[3 6]]
列表a如下：
[[1, 2, 3], [4, 5, 6]]
增加一维，新维度的下标为0
[[1 2 3]
[4 5 6]]
增加一维，新维度的下标为1
[[1 4]
[2 5]
[3 6]]