Python 之 NumPy 简介和创建数组

一、NumPy 简介

• NumPy（Numerical Python）是 Python 的一种开源的数值计算扩展。
• 这种工具可用来存储和处理大型矩阵，比 Python 自身的嵌套列表（nested list structure）结构要高效的多（该结构也可以用来表示矩阵（matrix）），支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
• 使用 NumPy 可以方便的使用数据、矩阵进行计算，包含线性代数、傅里叶变化、随机数生成等大量函数。

1. 为什么要使用 NumPy

• Numpy 是 Python 各种数据科学类库的基础库，比如：Scipy，Scikit-Learn、TensorFlow、pandas等。
• 对于同样的数值计算任务，使用 NumPy 比直接使用 Python 代码实现有如下优点:
• （1） 代码更简洁：NumPy 直接以数组、矩阵为粒度计算并且支撑大量的数学函数，而 python 需要用 for 循环从底层实现；
• （2） 性能更高效：NumPy 的数组存储效率和输入输出计算性能，比 Python 使用 List 或者嵌套 List 好很多。
• 这里有两点需要注意需要注意是，其一，Numpy 的数据存储和 Python 原生的 List 是不一样的。
• 其二，NumPy 的大部分代码都是 C 语言实现的，这是 Numpy 比纯 Python 代码高效的原因。

2. NumPy 数据类型

• NumPy 支持的数据类型比 Python 内置的类型要多很多，基本上可以和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。
• 下表列举了常用 NumPy 基本类型:

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

• NumPy 的数值类型实际上是 dtype 对象的实例，并对应唯一的字符，包括 np.bool_，np.int32，np.float32，等等。

3. NumPy 数组属性

• NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。
• 在 NumPy 中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。
• 比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。
• 很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。
• NumPy 的数组中比较重要 ndarray 对象属性有：

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息
ndarray.real	ndarray 元素的实部
ndarray.imag	ndarray 元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

4. NumPy 的 ndarray 对象

• NumPy 定义了一个 n 维数组对象，简称 ndarray 对象，它是一个一系列相同类型元素组成的数组集合。数组中的每个元素都占有大小相同的内存块。
• ndarray 对象采用了数组的索引机制，将数组中的每个元素映射到内存块上，并且按照一定的布局对内存块进行排列（行或列）。

二、numpy.array() 创建数组

1. 基础理论

• 基本的 ndarray 是使用 NumPy 中的数组函数创建的，如下所示：

numpy.array 

• 它从任何暴露数组接口的对象，或从返回数组的任何方法创建一个 ndarray。

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

• 上面的构造器接受以下参数：

序号	参数	描述
1	object	表示一个数组序列。
2	dtype	可选参数，通过它可以更改数组的数据类型。
3	copy	可选参数，当数据源是ndarray时表示数组能否被复制，默认是 True。
4	order	可选参数，以哪种内存布局创建数组，有 3 个可选值，分别是 C（行序列）、F（列序列）、A（默认）。
5	subok	可选参数，类型为bool值，默认 False。为 True，使用object的内部数据类型；False：使用object数组的数据类型。
6	ndmin	可选参数，用于指定数组的维度。

2. 基础操作演示

• 在代码编写之前，我们需要线引入 NumPy。

# 注意默认都会给numpy包设置别名为np
import numpy as np

• NumPy 引入完成后，实现 array 创建数组。
• 在 array() 函数当中，括号内可以是列表、元组、数组、迭代对象,生成器等。
• 其中，列表和元组的整体相同，但是列表属于可变序列，它的元素可以随时修改或删除，元组是不可变序列，其中元素不可修改，只能整体替换。
• （1） 列表：

np.array([1,2,3,4,5])
#array([1, 2, 3, 4, 5])

• （2） 元组：

np.array((1,2,3,4,5))
#array([1, 2, 3, 4, 5])

• （3） 数组：

a = np.array([1,2,3,4,5]) #创建一个数组
np.array(a)
#array([1, 2, 3, 4, 5])

• （4） 迭代对象：

np.array(range(10))
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

• （5） 生成器：

np.array([i**2 for i in range(10)])​
#array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])

• 当数组内的元素数据类型不相同时，那么数组内哪种数据类型存储的结果最大，就按哪种数据类型进行存储。
• 如下例子，在数组当中，包含整型，浮点型和字符串，其中字符串的数据类型存储结果最大，因此，数组内的所有元素均按字符串进行存储。

np.array([1,1.5,3,4.5,'5'])
#array(['1', '1.5', '3', '4.5', '5'], dtype='<U32')

• （1） 整型：

ar1 = np.array(range(10))   # 整型
ar1
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

• （2） 浮点型（浮点型的数据存储大于整型的数据存储，因此全部转换为浮点型）：

ar2 = np.array([1,2,3.14,4,5])   
ar2
#array([1.  , 2.  , 3.14, 4.  , 5.  ])

• （3） 二维数组（嵌套序列（列表，元组均可））：

ar3 = np.array([[1,2,3],('a','b','c')])   
ar3
#array([['1', '2', '3'],
#       ['a', 'b', 'c']], dtype='<U11')

• （4） 当二维数组嵌套序列数量不一致：

ar4 = np.array([[1,2,3],('a','b','c','d')])   
ar4
#array([list([1, 2, 3]), ('a', 'b', 'c', 'd')], dtype=object)

• 上述例子的秩是 1，可以通过 ar4.ndim 进行查看。

3. numpy.array() 参数详解

• （1） 设置 dtype 参数，默认自动识别。

a = np.array([1,2,3,4,5])
print(a)
# 设置数组元素类型
has_dtype_a = np.array([1,2,3,4,5],dtype='float')
has_dtype_a
#[1 2 3 4 5]
#array([1., 2., 3., 4., 5.])

• 如果将浮点型的数据，设置为整形，那么，数组内元素会自动舍弃尾数，转换为整型数据，具体输出如下所示。

np.array([1.1,2.5,3.8,4,5],dtype='int')
​#array([1, 2, 3, 4, 5])

• （2） 设置 copy 参数,默认为 True。
• 我们设置 a 数组，然后，通过 a 数组复制得出 b 数组，此时，a 数组和 b 数组的地址不相同，创建了新的对象。
• 那么，对 a 数组和 b 数组的任意修改都不会影响另一个数组的元素。

a = np.array([1,2,3,4,5])
b = np.array(a)
print('a:', id(a), '  b:', id(b))
print('以上看出a和b的内存地址')
b[0] = 10
print(a)
#a: 2066732212352   b: 2066732213152
#以上看出a和b的内存地址
#[1 2 3 4 5]

• 当我们修改 b 数组的元素时，a 数组不会发生变化。

b[0] = 10
print('a:', a,'  b:', b)
#a: [1 2 3 4 5]   b: [10  2  3  4  5]

• 当设置 copy 参数为 Fasle 时，不会创建副本，两个变量会指向相同的内容地址，没有创建新的对象。
• 此时，由于 a 数组和 b 数组指向的是相同的内存地址，因此当修改 b 数组的元素时，a 数组对应的元素会发生变化。

a = np.array([1,2,3,4,5])
b = np.array(a, copy=False)
print('a:', id(a), '  b:', id(b))
print('以上看出a和b的内存地址')
b[0] = 10
print('a:',a,'  b:',b)
#a: 2066732267520   b: 2066732267520
#以上看出a和b的内存地址
#a: [10  2  3  4  5]   b: [10  2  3  4  5]

• （3） ndmin 用于指定数组的维度。
• 将一维数组转换为二维数组。

a = np.array([1,2,3])
print(a)​
a = np.array([1,2,3], ndmin=2)
a​
#[1 2 3]
#array([[1, 2, 3]])

• （4） subok 参数，类型为 bool 值，默认 False。为 True 时，使用 object 的内部数据类型；False：使用 object 数组的数据类型。
• 首先，创建一个 a 矩阵，然后输出 a 矩阵的数据类型，便于后面的比较。
• 其次，通过 a 矩阵生成 at 和 af 两个数组，at 数组的 subok 参数设置为 True，at 数组的 subok 参数不设置，即默认为 False。
• 最后，输出 at 数组和 af 数组的数据类型，用于比较观察。

a = np.mat([1,2,3,4])
print(type(a))
​at = np.array(a,subok=True)
af = np.array(a) 
print('at,subok为True:',type(at))
print('af,subok为False:',type(af))
print(id(at),id(a))​
#<class 'numpy.matrix'>
#at,subok为True: <class 'numpy.matrix'>
#af,subok为False: <class 'numpy.ndarray'>
#2066738151720 2066738151608

• 书写代码时需要注意的内容：
• 先定义一个 a 数组。

a = np.array([2,4,3,1])

• 在定义 b 数组时，如果想复制 a 数组，有如下几种方案：
• （1） 使用 np.array()。
• （2） 使用数组的 copy() 方法。

b = np.array(a)
print('b = np.array(a)：',id(b),id(a))
​c = a.copy()
print('c = a.copy()：',id(c),id(a))
#b = np.array(a)： 2066731363744 2066731901216
#c = a.copy()： 2066732267520 2066731901216

• 注意不能直接使用 = 号复制，直接使用 = 号，会使 2 个变量指向相同的内存地址。

三、numpy.arange() 生成区间数组

• 根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

numpy.arange(start, stop, step, dtype)

• 其参数含义如下：

序号	参数	描述说明
1	start	起始值，默认为 0
2	stop	终止值（不包含）
3	step	步长，默认为 1
4	dtype	返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型。

• 如果只有一个参数，那么起始值就是 0，终止值就是那个参数，步长就是 1。
• 如果有两个参数，那么，第一个参数就是起始值，第二个参数就是终止值。

np.arange(10)
#array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

• 可以使用浮点型数值。

np.arange(3.1)
#array([0., 1., 2., 3.])

• 返回浮点型的，也可以指定类型。

x = np.arange(5, dtype =  float)  
x
#array([0., 1., 2., 3., 4.])

• 设置了起始值、终止值及步长：
• （1） 起始值是 10，终止值是 20，步长是 2。

np.arange(10,20,2)
​#array([10, 12, 14, 16, 18])

• （1） 起始值是 0，终止值是 20，步长是 3。

ar2 = np.arange(0,20,3)
print(ar2)
ar3 = np.arange(20,step=3) #指定传参
ar3
​#[ 0  3  6  9 12 15 18]
#array([ 0,  3,  6,  9, 12, 15, 18])

• 如果数组太大而无法打印，NumPy 会自动跳过数组的中心部分，并只打印边角。

np.arange(10000)
#array([   0,    1,    2, ..., 9997, 9998, 9999])

四、numpy.linspace() 创建等差数列

• 返回在间隔 [开始，停止] 上计算的 num 个均匀间隔的样本。数组是一个等差数列构成。

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

• 其参数含义如下：

序号	参数	描述说明
1	start	必填项，序列的起始值，
2	stop	必填项，序列的终止值，如果 endpoint 为 True，该值包含于数列中
3	num	要生成的等步长的样本数量，默认为50
4	endpoint	该值为 True 时，数列中包含 stop 值，反之不包含，默认是 True。
5	retstep	如果为 True 时，生成的数组中会显示间距，反之不显示。
6	dtype	ndarray 的数据类型

• 以下例子用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。

a = np.linspace(1,10,10)
a
#array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])

• 如果，我们将 endpoint 设置为 False，就不会包含 10，此时，默认步长是 50。

a = np.linspace(1,10,endpoint=False)
a
#array([1.  , 1.18, 1.36, 1.54, 1.72, 1.9 , 2.08, 2.26, 2.44, 2.62, 2.8 ,
#       2.98, 3.16, 3.34, 3.52, 3.7 , 3.88, 4.06, 4.24, 4.42, 4.6 , 4.78,
#       4.96, 5.14, 5.32, 5.5 , 5.68, 5.86, 6.04, 6.22, 6.4 , 6.58, 6.76,
#       6.94, 7.12, 7.3 , 7.48, 7.66, 7.84, 8.02, 8.2 , 8.38, 8.56, 8.74,
#       8.92, 9.1 , 9.28, 9.46, 9.64, 9.82])

• 以下实例用到三个参数，设置起始位置为 2.0，终点为 3.0，数列个数为 5。

ar1 = np.linspace(2.0, 3.0, num=5)
ar1
#array([2.  , 2.25, 2.5 , 2.75, 3.  ])

• 将参数 endpoint 设置为 False 时，不包含终止值，

ar1 = np.linspace(2.0, 3.0, num=5, endpoint=False)
ar1
#array([2. , 2.2, 2.4, 2.6, 2.8])

• 设置 retstep 显示计算后的步长。

ar1 = np.linspace(2.0,3.0,num=5, retstep=True)
print(ar1)
type(ar1)
#(array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25)
#tuple

• 将 endpoint 设置为 False，不包含终止值，再设置 retstep 显示计算后的步长。

ar1 = np.linspace(2.0,3.0,num=5,endpoint=False,retstep=True)
ar1
#(array([2. , 2.2, 2.4, 2.6, 2.8]), 0.2)

• 等差数列在线性回归经常作为样本集，例如：生成 x_data，值为 [0, 100] 之间 500 个等差数列数据集合作为样本特征，根据目标线性方程 $y=3\times x+2$，生成相应的标签集合 y_data。

x_data = np.linspace(0,100,500)
x_data

五、numpy.logspace() 创建等比数列

• 返回在间隔 [开始，停止] 上计算的 num 个均匀间隔的样本。数组是一个等比数列构成。

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

• 其参数含义如下：

序号	参数	描述说明
1	start	必填项，序列的起始值，
2	stop	必填项，序列的终止值，如果endpoint为true，该值包含于数列中
3	num	要生成的等步长的样本数量，默认为50
4	endpoint	该值为 true 时，数列中包含stop值，反之不包含，默认是True。
5	base	对数 log 的底数
6	dtype	ndarray 的数据类型

a = np.logspace(0,9,10,base=2)
a
#array([  1.,   2.,   4.,   8.,  16.,  32.,  64., 128., 256., 512.])

• 上述代码可以理解为 $2^0$ 到 $2^9$。
• np.logspace(A,B,C,base=D) 中的参数分别是如下含义：
• A：生成数组的起始值为 D 的 A 次方。
• B：生成数组的结束值为 D 的 B 次方。
• C：总共生成 C 个数。
• D：指数型数组的底数为 D，当省略 base=D 时，默认底数为 10。
• 我们先使用前 3 个参数，将 [1,5] 均匀分成 3 个数，得到 {1,3,5}，然后利用第 4 个参数 base=2（默认是 10）使用指数函数可以得到最终输出结果 {$2^1$，$2^3$，$2^5$}。

np.logspace(1,5,3,base=2)
#array([ 2.,  8., 32.])

• 取得 1 到 2 之间 10 个常用对数。

np.logspace(1.0,2.0,num=10)
#array([ 10.        ,  12.91549665,  16.68100537,  21.5443469 ,
#        27.82559402,  35.93813664,  46.41588834,  59.94842503,
#        77.42636827, 100.        ])

• 上述实际上是 $10^1$ 到 $10^2$。

六、numpy.zeros() 创建全零数列

• 创建指定大小的数组，数组元素以 0 来填充。

numpy.zeros(shape, dtype = float, order = 'C')

• 其参数含义如下：

序号	参数	描述说明
1	shape	数组形状
2	dtype	数据类型，可选

• 默认的数据类型是浮点数。

np.zeros(5)
#array([0., 0., 0., 0., 0.])

• 将数据类型设置为整型。

np.zeros((5,), dtype = 'int') 
array([0, 0, 0, 0, 0])

• 生成一个 2 行 2 列的全 0 数组。

np.zeros((2,2))
#array([[0., 0.],
#       [0., 0.]])

• 使用 zeros_like 可以返回具有与给定数组相同的形状和类型的零数组。

ar1 = np.array([[1,2,3],[4,5,6]])
np.zeros_like(ar1)
#array([[0, 0, 0],
#       [0, 0, 0]])

七、np.ones() 创建一数列

• 生成元素全部是 1 的数列。

ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print('ar5:',ar5)
print('ar6:',ar6)
print('ar7:',ar7)
#ar5: [1. 1. 1. 1. 1. 1. 1. 1. 1.]
#ar6: [[[1. 1. 1. 1.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]]
#
# [[1. 1. 1. 1.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]]]
#ar7: [1 1 1 1 1 1 1]

​