Numpy基础(一)

什么是Numpy?

Numpy是Python开源的科学计算工具包,是高级的数值编程工具

  • 强大的N维数组对象:ndarray
  • 可以对数组结构数据进行运算(不用遍历循环)
  • 有随机数、线性代数、傅里叶变换等功能

    如何安装?

    安装anaconda科学计算环境
    咸鱼也是从新手一步一坑踩过来,深知新手配置环境的不易,所以这里推荐使用anaconda,里面集成了许多常用的库,并且在配置环境时更容易上手。

下载地址:https://www.anaconda.com/download/

具体安装步骤,这里不再赘述,不懂的朋友可以在交流群中讨论,也可以参考下面的博文:

https://cuiqingcai.com/5059.html

安装Numpy

方法一:安装anaconda后,numpy是可以直接使用的,无需二次安装。

方法二:没有安装anaconda可以使用pip install numpy安装。

安装jupyter notebooks(推荐使用)

方法一:安装anaconda后,jupyter notebooks是可以直接使用的,无需二次安装。

方法二:没有安装anaconda可以使用pip install jupyter安装。

Numpy基础数据结构

导入

推荐使用from numpy import np

不建议使用from numpy import *, 因为numpy中包含了大量与Python内建函数重名的函数。

生成ndarray

可以使用array生成数组
举个栗子:

1
2
3
4
5
6
7
import numpy as np
ar = np.array([[1,2,3,4],[1,2,3,4]])
print(ar, type(ar))

>>>
[[1 2 3 4]
[1 2 3 4]] <class 'numpy.ndarray'>

除了np.array之外还有其他函数可以创建新数组,这里列出常用的几个:

1
2
3
4
5
6
7
8
arange # python range的数组版
asarray # 将输入转换为ndarray
ones # 根据给定的形状和类型生成全1的数组
ones_like # 根据给定的数组生成形状一样的全1的数组
zeros # 根据给定的形状和类型生成全0的数组
zeros_like # 根据给定的数组生成形状一样的全1的数组
eye # 生成一个N*N的特征矩阵(对角线为1,其余为0)
linspance # 返回在间隔[开始,停止]上计算的num个均匀间隔的样本

这里以zeros,zeros_like以及linspance分别举例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
arr = np.zeros((3,5))
print(arr)

>>>
[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]

s = np.array([list(range(10)),list(range(10,20))])
print(s)
print(np.zeros_like(s))

>>>
[[ 0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]]
[[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]]

print(np.linspace(10,20,num = 21)) #在10,21之间生成
print(np.linspace(10,20,num = 21, endpoint = False)) #endpoint默认为True,为False时不包含左边的值
print(np.linspace(10,20,num = 21, retstep = True))# restep显示步长

>>>
[10. 10.5 11. 11.5 12. 12.5 13. 13.5 14. 14.5 15. 15.5 16. 16.5
17. 17.5 18. 18.5 19. 19.5 20. ]
[10. 10.47619048 10.95238095 11.42857143 11.9047619 12.38095238
12.85714286 13.33333333 13.80952381 14.28571429 14.76190476 15.23809524
15.71428571 16.19047619 16.66666667 17.14285714 17.61904762 18.0952381
18.57142857 19.04761905 19.52380952]
(array([10. , 10.5, 11. , 11.5, 12. , 12.5, 13. , 13.5, 14. , 14.5, 15. ,
15.5, 16. , 16.5, 17. , 17.5, 18. , 18.5, 19. , 19.5, 20. ]), 0.5)

这里除了常用的几个生成数组的函数外,列举一些常用的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import numpy as np
ar = np.array([[1,2,3,4],[1,2,3,4]])
print(ar, type(ar))
print(ar.ndim)#返回数组的维度的个数
print(ar.shape)#数组的维度,返回几行几列
print(ar.size)#数组元素的个数
print(ar.dtype)#元素的类型
print(ar.itemsize)#数组中元素的大小

>>>
[[1 2 3 4]
[1 2 3 4]] <class 'numpy.ndarray'>
2
(2, 4)
8
int64
8

Numpy通用函数

数组形状变换(.T/.reshape()/.resize())

.T是转置函数,转置函数对一维数组无影响

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# .T
import numpy as np
ar1 = np.arange(10)
ar2 = np.zeros((2,5))
print(ar1.T)
print(ar2.T)#转置函数

>>>
[0 1 2 3 4 5 6 7 8 9]
[[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]]

.reshape(),直接更改数组的形状,但更改前后数组元素个数必须相同

1
2
3
4
5
6
7
8
9
ar1 = np.arange(10)
print(ar1.reshape(2,5))
print(np.reshape(np.arange(16),(2,8)))

>>>
[[0 1 2 3 4]
[5 6 7 8 9]]
[[ 0 1 2 3 4 5 6 7]
[ 8 9 10 11 12 13 14 15]]

.resize()

1
2
3
4
5
6
7
8
9
10
print(np.resize(np.arange(16),(3,5)))  # resize当后面的数组元素个数小于前面生成的数量时,按照顺序迭代
print(np.resize(np.arange(12),(3,5))) # resize当后面的数组元素个数大于前面的生成的数量,则随机填充

>>>
[[ 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 0 1 2]]

数组的复制

和python中的深浅拷贝类似:

数组的类型转化

.astype()可以将数组中元素的类型进行转化,在numpy中元素类型有以下几种(太多了就不都写了):

1
2
3
4
5
6
7
8
9
int8, uint8 #有符号和无符号的8整位整数
int16, uint16 #有符号和无符号的16整位整数
int32, uint32 #有符号和无符号的32整位整数
int64, uint64 #有符号和无符号的64整位整数
float16 #半精度
float32 #单精度
float64 #双精度
bool #布尔
.....

举个类型转换的栗子:

1
2
3
4
5
6
ar1 = np.arange(10,dtype=float)
ar2 = ar1.astype(np.int64)
print(ar1,ar2)

>>>
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.] [0 1 2 3 4 5 6 7 8 9]

数组的堆叠

数组的堆叠有hstack(),vstack()以及stack(),下面分别举例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
a = np.arange(10)
b = np.arange(10,20)
print(ar1,ar2)
# 横向链接
print(np.hstack((a,b)))
# 竖向链接
a = np.array([[1],[2],[3]])
b = np.array([['a'],['b'],['c']])
print(np.vstack((a,b)))
# 任意堆叠
a = np.arange(10)
b = np.arange(10,20)
print(np.stack((a,b),axis=1)) # 竖向堆叠
print(np.stack((a,b))) # 横向堆叠

>>>>
[0 1 2 3 4 5 6 7 8 9] [10 11 12 13 14 15 16 17 18 19]
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
[['1']
['2']
['3']
['a']
['b']
['c']]
[[ 0 10]
[ 1 11]
[ 2 12]
[ 3 13]
[ 4 14]
[ 5 15]
[ 6 16]
[ 7 17]
[ 8 18]
[ 9 19]]
[[ 0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]]

数组拆分

数组拆分同样分为横向拆分和竖向拆分。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 数组拆分
ar = np.arange(16).reshape(4,4)
print(ar)
print(np.hsplit(ar,2)) #纵向拆分
print(np.vsplit(ar,2)) #横向拆分

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

常用计算函数

这里的计算函数与Python中的计算函数用法相同,这里不再过多论述。

1
2
3
4
5
6
7
#计算函数
np.mean() #求平均值
np.max() #最大值
np.min() #最小值
np.gtd() #标准差
np.var() #方差
np.sum() # 其中参数axis=0按列求和axis=1按行求和

巩固练习

  1. 生成一个一维数组、二维数组,并且查看其shape
  2. 生成一个一维数组,起始值为5,终点值为15,样本数为10个
  3. 创建一个20个元素的数组,分别改变成两个形状:(4,5),(5,6)
  4. 创建一个(4,4)的数组,把其元素类型改为字符型
  5. 创建一个二维数组ar,起始值为0,终点值为15,运用数组的运算方法得到结果:result = ar * 10 +100,并求出result的均值及求和
煌金 wechat
扫描关注公众号,回复「1024」获取为你准备的特别推送~
  • 本文作者: 煌金 | 微信公众号【咸鱼学Python】
  • 本文链接: http://www.xianyucoder.cn/2018/10/01/numpy1/
  • 版权声明: 本博客所有文章除特别声明外,均采用 许可协议。转载请注明出处!
  • 并保留本声明和上方二维码。感谢您的阅读和支持!