- linspace函数
函数说明：此函数与arange函数有些相似。调用方法为 np.linspace(start= ,stop= ,num= ,endpoint= ,retstep= ,dtype= ,axis= )
参数说明：
-
start是数组起始数字
-
stop是数组结束数字
-
num（可选）控制结果中共有多少个元素
-
endpoint（可选）决定了中止值（stop）是否包含在内。若值为True，则包含stop，否则不包含。如果不写默认是True
-
retstep（可选）默认是False，如果指定为True，则结果会返回步长以及序列数组，从而产生一个元组作为输出
-
dtype（可选）为生成的数组的类型，可以自定义数据类型，不写则按那个规则 字符串>复数>浮点数>整数
-
axis（可选）默认是0 。很多函数都会有这个参数，这是个轴的意思。具体定义如下图：
运行如下代码：
import numpy as np
array1 = np.linspace(1,10,10)
print(array1)
print('='*30)
array2 = np.linspace(start = 1, stop = 10, num = 10, endpoint=True, dtype=int, retstep=True)
print(array2)
输出结果如下：
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
==============================
(array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 1.0)
- logspace函数
函数说明：返回在对数刻度上均匀间隔的数字。此函数尚未理解
- full函数
函数说明：返回给定形状，给定值的数组。
运行代码：
import numpy as np
array = np.full(shape=(3, 3), fill_value=10, dtype=int)
print(array)
输出结果如下：
[[10 10 10]
[10 10 10]
[10 10 10]]
- repeat函数
函数说明：建立每个元素重复N次的数组。
运行代码：
import numpy as np
array = np.repeat(a=[1, 1, 2, 3], repeats=3, axis=0) # a的每个元素重复三次
print(array)
运行结果如下：
[1 1 1 1 1 1 2 2 2 3 3 3]
另外还有一些数组创建函数如下表所示：
函数 |
说明 |
array |
将输入数据（列表，元组，数组或者其他的序列类型）转换为ndarray。要么推断出dtype，要么在创建时即指定dtype。默认直接复制输入数据 |
asarray |
将输入转换为ndarray，如果输入本身就是一个ndarray就不进行复制 |
arange |
类似于内置的range，但返回的是一个ndarray而不是列表 |
ones、ones_like |
ones是根据指定的dtype和形状创建一个全1数组，ones_like是根据给定的数组的形状创建一个全1数组 |
zeros、zeros_like |
与上类似，只不过是全0数组 |
empty、empty_like |
与上类似，只不过数据是随机的 |
eye、identity |
创建一个N * N的单位矩阵，对角线元素为1，其余为0 |
full、full_like |
创建一个给定形状，给定值的数组 |
（2）操作数组
1. 数组属性的获取
调用方法 |
作用 |
.ndim |
返回数组的维数 |
.shape |
返回数组的形状 |
.size |
返回数组元素个数 |
.dtype |
返回数组元素类型 |
.itemsize |
返回数组元素字节大小 |
2. 数组属性的操作
调用方法 |
作用 |
.reshape |
改变数组形状 |
.all |
数组元素都是0返回True，否则返回False |
.any |
数组元素有非0值返回True，否则返回False |
.copy |
复制数组副本（并不是引用） |
.astype |
改变数组元素数据类型 |
3. 数组的对接与分割
- vstack()函数
函数说明：vstack()函数可以实现数组的垂直对接。
运行代码：
import numpy as np
array1 = np.zeros((2, 3), dtype=int)
array2 = np.ones((4, 3), dtype=int)
print(array1)
print('=' * 20)
print(array2)
print('=' * 20)
print(np.vstack((array1, array2)))
运行结果如下：
[[0 0 0]
[0 0 0]]
====================
[[1 1 1]
[1 1 1]
[1 1 1]
[1 1 1]]
====================
[[0 0 0]
[0 0 0]
[1 1 1]
[1 1 1]
[1 1 1]
[1 1 1]]
- hstack()
函数说明：hstack()函数可以实现数组元素的水平对接。
运行代码：
import numpy as np
array1 = np.zeros((2, 6), dtype=int)
array2 = np.ones((2, 1), dtype=int)
print(array1)
print('=' * 20)
print(array2)
print('=' * 20)
print(np.hstack((array1, array2)))
运行结果如下：
[[0 0 0 0 0 0]
[0 0 0 0 0 0]]
====================
[[1]
[1]]
====================
[[0 0 0 0 0 0 1]
[0 0 0 0 0 0 1]]
- vsplit()
函数说明：vsplit(array, N)函数可以实现数组的垂直分割（就是分割的垂直，以水平方向分割垂直），array为需要分割的数组，N为分割数。
代码示例如下：
import numpy as np
array1 = np.array(([1, 2, 3], [4, 5, 6], [7, 8, 9]), dtype=int)
print(array1)
print('=' * 30)
print(np.vsplit(array1, 3))
运行结果如下：
[[1 2 3]
[4 5 6] [7 8 9]]==============================[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]
- hsplit()
函数说明：hsplit(array, N)函数可以实现数组元素的水平分割（相当于以垂直方向分割水平，实现水平分割），array为要分割的数组，N为分割的份数。
代码示例如下：
import numpy as np
array1 = np.array(([1, 2, 3], [4, 5, 6], [7, 8, 9]), dtype=int)
print(array1)
print('=' * 30)
print(np.hsplit(array1, 3))
运行结果如下：
[[1 2 3]
[4 5 6]
[7 8 9]]
==============================
[array([[1],
[4],
[7]]), array([[2],
[5],
[8]]), array([[3],
[6],
[9]])]
（3）多维数组的索引与切片（主要区别与一维数组不同的用法）
1. 索引省略用法
说明：当能确定维度时，索引方法和普通数组一样，如array[1], array[1, 2], array[1, 2, 3]。当确定不了维度时，可以通过下标右边…省略号或直接省略下标数，来读取数组。
示例：
import numpy as np
array = np.arange(1, 13).reshape((2, 2, 3))
print(array)
print('=' * 30)
print(array[1])
print('=' * 30)
print(array[1, ])
print('=' * 30)
print(array[1, ...])
print('=' * 30)
print(array[1, ..., 2]) # 此时不能用 array[1, 2]，会报错为: IndexErrorindex 2 is out of bounds for axis 1 with size 2
运行结果如下：
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
==============================
[[ 7 8 9]
[10 11 12]]
==============================
[[ 7 8 9]
[10 11 12]]
==============================
[[ 7 8 9]
[10 11 12]]
==============================
[ 9 12]
2. 二维数组切片
说明：默认的切片方式，如[0:2:1]获得第1行到第2行元素，这种切的是行，操作方式与一维数组相同，如果要切片二维数组的行和列，则
操作方式为：数组名[行切片, 列切片]
格式为：array[start:stop:step, start:stop:step]
如：array[:, 2]就是截取所有行，第三列的子数组。array[:, :]就是获取所有行所有列。
示例：
import numpy as np
array = np.arange(1, 13).reshape((3, 4))
print(array)
print('=' * 30)
# 获取从第1行到第2行步长为1的所有行，再从这些行中获得第2列到第4列步长为2的所有元素
print(array[0:2:1,1:4:2])
运行结果如下：
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
==============================
[[2 4]
[6 8]]
3. 三维数组切片
说明：操作方式与二维数组相类型，无非就是多了一维而已。
操作方式为：数组名[页切片, 行切片, 列切片]
格式为：array[start:stop:step, start:stop:step, start:stop:step]
示例：
import numpy as np
array = np.arange(1, 13).reshape((2, 2, 3))
print(array)
print('=' * 30)
# 获取第2页的第2行的从第2列到第3列步长为1的所有元素
print(array[1, 1, 1:3:1])
运行结果如下：
[[[ 1 2 3]
[ 4 5 6]]
[[ 7 8 9]
[10 11 12]]]
==============================
[11 12]
4. 花式索引
- 整数数组索引
（1）一维数组的整数数组索引
说明：利用整数数组的所有元素的下标值进行索引，又叫数组索引。
示例：
import numpy as np
names = np.array(['zhaoer', 'zhangsan', 'lisi', 'wangwu', 'maliu', 'tangqi'])
index = np.array([1, 2, 4, 5])
print(*names)
print('=' * 60)
print(*names[index])
运行结果如下：
zhaoer zhangsan lisi wangwu maliu tangqi
============================================================
zhangsan lisi maliu tangqi
（2）二维数组的数组索引
说明：对二维数组输出时如果只索引一个一维数组，则只操作行，如果索引为两个一维数组，则第一个一维数组指定结果的x坐标，第二个一维数组指定结果的y坐标。
示例如下：
import numpy as np
# 以下是利用一个整数数组进行索引
names = np.array([['tom', 1], ['jack', 2], ['lucy', 3], ['blackCat', 4], ['win', 5], ['father', 6]])
index = np.array([1, 2, 4, 5])
print(*names)
print('=' * 60)
print(*names[index])
print('=' * 60)
# 以下用两个一维整数数组进行索引
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
index1 = np.array([[0, 1, 2]]) # 注意：这是其实是一个二维数组的第一维
index2 = np.array([0, 1, 2])
print(array)
print('=' * 60)
print(array[index1, index2])
运行结果如下：
['tom' '1'] ['jack' '2'] ['lucy' '3'] ['blackCat' '4'] ['win' '5'] ['father' '6']
============================================================
['jack' '2'] ['lucy' '3'] ['win' '5'] ['father' '6']
============================================================
[[1 2 3]
[4 5 6]
[7 8 9]]
============================================================
[[1 5 9]]
- bool数组索引
说明：准备一个bool数组，用该数组索引其他数组时，只会输出True位置对应的元素。一维或者多维数组都适用。
示例：
import numpy as np
array = np.arange(1, 10).reshape((3, 3))
index = np.array([[True, False, True], [True, False, False], [False, False, True]])
print(array)
print('=' * 20)
print(array[index])
运行结果如下：
[[1 2 3]
[4 5 6]
[7 8 9]]
====================
[1 3 4 9]
（4）基本数学计算
1. 普通计算
说明：计算的对象可以是两个数组，也可以是一个数组一个数字，所有运算对于复数也同样适用。如下表：
运算方式 |
符号 |
函数 |
数组加法 |
+ |
add |
数组减法 |
- |
subtract |
数组乘法 |
* |
multiply |
数组除法 |
/ |
divide |
数组求余 |
% |
mod |
数组求幂 |
** |
power |
数组整除 |
// |
floor_divide |
示例：
import numpy as np
array1 = np.arange(1, 10).reshape((3, 3))
array2 = np.array([10, 10, 10])
print('第一个数组：')
print(array1)
print('第二个数组：')
print(array2)
print('=' * 30)
print('数组加法：')
print(np.add(array1, array2))
print('=' * 30)
print('数组减法：')
print(np.subtract(array1, array2))
print('=' * 30)
print('数组乘法：')
print(np.multiply(array1, 2))
print('=' * 30)
print('数组除法：')
print(np.divide(array1, 10))
print('=' * 30)
print('数组求余：')
print(np.mod(array1, array2))
print('=' * 30)
print('数组求幂：')
print(np.power(array1, 3))
print('=' * 30)
print('数组整除：')
print(np.floor_divide(array1, 2))
运行结果如下：
第一个数组：
[[1 2 3]
[4 5 6]
[7 8 9]]
第二个数组：
[10 10 10]
==============================
数组加法：
[[11 12 13]
[14 15 16]
[17 18 19]]
==============================
数组减法：
[[-9 -8 -7]
[-6 -5 -4]
[-3 -2 -1]]
==============================
数组乘法：
[[ 2 4 6]
[ 8 10 12]
[14 16 18]]
==============================
数组除法：
[[0.1 0.2 0.3]
[0.4 0.5 0.6]
[0.7 0.8 0.9]]
==============================
数组求余：
[[1 2 3]
[4 5 6]
[7 8 9]]
==============================
数组求幂：
[[ 1 8 27]
[ 64 125 216]
[343 512 729]]
==============================
数组整除：
[[0 1 1]
[2 2 3]
[3 4 4]]
2. 比较运算
说明：可以数组与数组比较，也可以数组和单个数字标量进行比较，结果是与第一个数组形状相同的数组，满足条件的位置为True，不满足的为False，如下表：
运算方式 |
符号 |
等于比较 |
== |
不等于比较 |
!= |
大于比较 |
> |
小于比较 |
< |
大于等于 |
>= |
小于等于 |
<= |
示例（此示例仅展示等于比较运算，其他运算方式相似）：
import numpy as np
array1 = np.arange(1, 10).reshape((3, 3))
array2 = np.array([1, 1, 1])
print(array1 == array2)
print('=' * 30)
print(array1 == 1)
结果：
[[ True False False]
[False False False]
[False False False]]
==============================
[[ True False False]
[False False False]
[False False False]]
3. 数组位运算
说明：运算对象可以是数组与数组，也可以是数组和单个数字标量，结果是与第一个数组形状相同的数组，满足条件的位置为True，不满足的为False，如下表：
运算方式 |
符号 |
与 |
& |
或 |
\ |
非 |
~ |
左移 |
<< |
右移 |
>> |
示例（次示例仅展示与运算，其他运算方式类似）：
import numpy as np
array1 = np.arange(1, 10).reshape((3, 3))
array2 = np.array([[True, False, True], [True, False, True], [True, False, True]])
print(array1 & array2)
print('=' * 30)
print(array1 & 10)
运算结果如下：
[[1 0 1]
[0 0 0]
[1 0 1]]
==============================
[[0 2 2]
[0 0 2]
[2 8 8]]
（5）数组通用函数
说明：这里的函数和数学概念中的函数是一一对应的
1. 三角函数 反三角函数
说明：
- numpy中自带圆周率，用numpy.pi就可以使用
- 传递给函数的数是以弧度计算，对于角度可以用array * numpy.pi / 180 转换为弧度
- 调用反三角函数时可以用numpy.degrees()函数将结果中的弧度转换为角度
函数如下表：
功能 |
函数 |
正弦 |
sin |
余弦 |
cos |
正切 |
tan |
反正弦 |
arcsin |
反余弦 |
arccos |
反正切 |
arctan |
以正弦为示例，其他类似：
import numpy as np
array = np.array([0, 30, 45, 60, 90])
sin = np.sin(array * np.pi / 180)
print('正弦计算结果为：')
print(sin)
print('=' * 60)
print('对结果执行反正弦并转换为角度：')
print(np.degrees(np.arcsin(sin)))
运行结果如下：
正弦计算结果为：
[0. 0.5 0.70710678 0.8660254 1. ]
============================================================
对结果执行反正弦并转换为角度：
[ 0. 30. 45. 60. 90.]
2. 舍入函数
函数：numpy.around(array, decimals)
函数说明：
- 其中array为数组，decimals为要保留的小数位数，默认值为0，如果为负数，则将整数四舍五入保留到小数点左侧位置
- 结果是科学计数法的形式，如1.23e + 2就是1.23*10^2
示例如下：
import numpy as np
array = np.array([12, 12.123456, 12345.12])
print('将decimals默认：')
print(np.around(array))
print('保留到小数点后一位：')
print(np.around(array, 1))
print('保留到小数点左一位：')
print(np.around(array, -1))
运行结果：
将decimals默认：
[1.2000e+01 1.2000e+01 1.2345e+04]
保留到小数点后一位：
[1.20000e+01 1.21000e+01 1.23451e+04]
保留到小数点左一位：
[1.000e+01 1.000e+01 1.235e+04]
3. 取整函数
说明：
- numpy.ceil(array)是返回大于或者等于指定表达式的最小整数，即向上取整。
- numpy.floor(array)是返回小于或等于指定表达式的最大整数，即向下取整。
- 参数中array是数组名或者单个数字标量。
示例：
import numpy as np
array = np.array([1.23, 4.5, 6.789])
print('向上取整：')
print(np.ceil(array))
print('向下取整：')
print(np.floor(array))
print('对于单个数字标量：')
print(np.floor(1.23))
print(np.ceil(1.23))
运行结果如下：
向上取整：
[2. 5. 7.]
向下取整：
[1. 4. 6. ]
对于单个数字标量：
1.0
2.0
4. 以e为底的指数函数和对数函数
说明：
- numpy.exp(array)是以e为底，以array为指数的结果。
- numpy.log(array)是以e为底，以array为真数的结果。
- numpy.log2(array)是以2为底，以array为真数的结果。
- numpy.log10(array)是以10为底，以array为真数的结果。
- 其中array既可以是数组，也可以是单个数字标量。
5. 随机函数
说明：常用随机函数如下表
函数 |
参数 |
解释 |
numpy.random.rand(shape) |
shape用于指定生成数组的形状 |
函数产生[0, )范围内的浮点随机数，生成一个数组 |
numpy.random.randn(shape) |
shape用于指定生成数组的形状 |
函数产生标准正态分布随机数，生成一个数组 |
numpy.random.randint(low=None, high=None, size=None, dtype=None) |
随机数范围[low, high)，size是随机数的个数，dtype是随机数类型 |
生成的type类型的size个范围内的随机数，返回一个数组 |
|
|
|
numpy.random.normal(loc=None, scale=None, size=None) |
|
产生正态分布随机数 |
numpy.random.uniform(low=None, high=None, size=None) |
|
产生均匀分布随机数 |
numpy.random.poisson(lam=None, size=None) |
|
产生泊松分布随机数 |
|
|
|
numpy.random.permutation(array) |
array可以是数组，也可以是单独数字标量 |
当array为数组时，打乱数组中的所有数，当array为数字标量时，返回[0, array)范围内的数的乱序组成的数组 |
numpy.random.shuffle(array) |
array为数组 |
与上述区别是直接对array进行打乱，无返回值 |
未完待续！咱们下次见！对了，需要完整的视频教程或各种系列源码的点这里直接获取
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有