学习笔记——Numpy基本操作（一）

为了方便学习，我把本文介绍的一些函数先列举下
数组属性
ndarray.ndim
ndarray.shape

创建数组
numpy.empty、numpy.zeros、numpy.ones初始化
数值范围创建数组
切片

数组操作
numpy.reshape
ndarray.flatten
numpy.concatenate
numpy.hstack
numpy.vstack

Numpy 介绍

NumPy(Numerical Python) 是 Python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy的前身 Numeric 最早是由 Jim Hugunin 与其它协作者共同开发，2005年，Travis Oliphant 在 Numeric中结合了另一个同性质的程序库 Numarray 的特色，并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。
包括：

• 一个强大的 N 维数组对象 ndarray
• 广播功能函数
• 整合 C/C++/Fortran 代码的工具
• 线性代数、傅里叶变换、随机数生成等功能

---

基本运算

Ndarray 数据结构

NumPy 最重要的一个特点是其 N 维数组对象 ndarray（张量 Tensor 部分略去，请有兴趣自行研究），它是一系列同类型数据的集合，以 0下标为开始进行集合中元素的索引。ndarray对象是用于存放同类型元素的多维数组。ndarray中的每个元素在内存中都有相同存储大小的区域。

numpy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数
据类型对应上，其中部分类型对应为 Python 内置的类型。

---

属性

NumPy 的数组中比较重要 ndarray 对象属性有：

---

数组的轴（重点）

axis = 0 代表列方向
axis = 1 代表水平方向
axis = 0 代表往里面的方向

---

基本操作详解

NumPy 数组属性

1、ndarray.ndim 用于返回数组的维数，等于秩

import numpy as np 
 
a = np.arange(24)  
print ('a的维数：',a.ndim)             # a 现只有一个维度
# 现在调整其大小
b = a.reshape(2,4,3)  # b 现在拥有三个维度
print ('b的维数：',b.ndim)

---------------------------
执行结果：
a的维数： 1
b的维数： 3

---

2、ndarray.shape 也可以用于调整数组大小

import numpy as np  
 
a = np.array([[1,2,3],[4,5,6]])  
print (a.shape)

---------------------------
执行结果：
(2, 3)

import numpy as np 
 
a = np.array([[1,2,3],[4,5,6]]) 
b = a.reshape(3,2)  
print (b)

----------------------------
执行结果：
[[1 2]
 [3 4]
 [5 6]]

---

NumPy 创建数组

1、numpy.empty、numpy.zeros、numpy.ones初始化

import numpy as np 
x = np.empty([3,2], dtype = int) 
print (x)

-----------------------
执行结果：
[[1 2]
 [3 4]
 [5 6]]

import numpy as np
 
# 默认为浮点数
x = np.zeros(5) 
print(x)
print('') 
# 设置类型为整数
y = np.zeros((5,), dtype = np.int) 
print(y)
print('') 
# 自定义类型
z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
print(z)

------------------------
执行结果：
[0. 0. 0. 0. 0.]

[0 0 0 0 0]

[[(0, 0) (0, 0)]
 [(0, 0) (0, 0)]]

import numpy as np
 
# 默认为浮点数
x = np.ones(5) 
print(x)
 
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)

--------------------
执行结果：
[1. 1. 1. 1. 1.]
[[1 1]
 [1 1]]

---

2、NumPy 从数值范围创建数组

import numpy as np
 
x = np.arange(5)  
print (x)

-----------------
执行结果：
[0 1 2 3 4]

import numpy as np
 
# 设置了 dtype
x = np.arange(5, dtype =  float)  
print (x)

-------------------
执行结果：
[0. 1. 2. 3. 4.]

import numpy as np
a = np.linspace(1,10,10)
print(a)

-------------------
执行结果：
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

---

3、切片

import numpy as np
 
a = np.arange(10)
print(a[2:])

--------------------
执行结果：
[2 3 4 5 6 7 8 9]

import numpy as np
 
a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
print(a[2:5])

--------------------
执行结果：
[2 3 4]

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]], dtype=float)
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])

------------------
执行结果：
[[1. 2. 3.]
 [3. 4. 5.]
 [4. 5. 6.]]
从数组索引 a[1:] 处开始切割
[[3. 4. 5.]
 [4. 5. 6.]]

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素

---------------
执行结果：
[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

import numpy as np
 
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)

-----------------
执行结果：
[[5 6]
 [8 9]]
[[5 6]
 [8 9]]
[[2 3]
 [5 6]
 [8 9]]

---

NumPy 广播(Broadcast)

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

import numpy as np 
 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print (c)

-----------------
执行结果：
[ 10  40  90 160]

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
print(a + b)

------------------
执行结果：
[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

---

Numpy 数组操作

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order='C')

import numpy as np
 
a = np.arange(8)
print ('原始数组：')
print (a)
print ('')
b = a.reshape(4,2)
print ('修改后的数组：')
print (b)

-------------------
执行结果：
原始数组：
[0 1 2 3 4 5 6 7]

修改后的数组：
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order='C')，order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

import numpy as np
 
a = np.arange(8).reshape(2,4)
 
print ('原数组：')
print (a)
print ('')
# 默认按行
 
print ('展开的数组：')
print (a.flatten())
print ('')
 
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

-------------------
执行结果：
原数组：
[[0 1 2 3]
 [4 5 6 7]]

展开的数组：
[0 1 2 3 4 5 6 7]

以 F 风格顺序展开的数组：
[0 4 1 5 2 6 3 7]

import numpy as np
 
a = np.arange(12).reshape(3,4)
 
print ('原数组：')
print (a)
print ('')
 
print ('转置数组：')
print (a.T)

------------------
执行结果：
原数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

转置数组：
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

连接数组

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('')
# 两个数组的维度相同
 
print ('沿轴 0 连接两个数组：')
print (np.concatenate((a,b)))
print ('')
 
print ('沿轴 1 连接两个数组：')
print (np.concatenate((a,b),axis = 1))

----------------
执行结果：
第一个数组：
[[1 2]
 [3 4]]

第二个数组：
[[5 6]
 [7 8]]

沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]

numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('')
 
print ('水平堆叠：')
c = np.hstack((a,b))
print (c)
print ('')

--------------------------
执行结果;
第一个数组：
[[1 2]
 [3 4]]

第二个数组：
[[5 6]
 [7 8]]

水平堆叠：
[[1 2 5 6]
 [3 4 7 8]]

numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。

import numpy as np
 
a = np.array([[1,2],[3,4]])
 
print ('第一个数组：')
print (a)
print ('')
b = np.array([[5,6],[7,8]])
 
print ('第二个数组：')
print (b)
print ('')
 
print ('竖直堆叠：')
c = np.vstack((a,b))
print (c)

----------------------
执行结果：
第一个数组：
[[1 2]
 [3 4]]

第二个数组：
[[5 6]
 [7 8]]

竖直堆叠：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]