NumPy

np.array

就是创建一个数组。比如：

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

输出结果就是：
$$\begin{gathered} [[12] \\ [34]] \end{gathered}$$
常见的还有两个参数

参数	意义
$dtype$	数据类型，可选参数，默认$np.float64$
$ndmin$	最小维度。比如一维的也给你整成二维的。

里面$ndmin$不大好理解，举个例子。

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

输出结果为：$[[1234]]$

NumPy中的各种数据类型

名称	描述
$bool\_$	布尔型数据类型（$True$ 或者 $False$）
$int\_$	默认的整数类型（类似于 $C$语言中的 $long$，$int32$ 或 $int64$）
$intc$	与 $C$ 的 $int$ 类型一样，一般是 $int32$ 或 $int64$
$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$ 位浮点数（实数部分和虚数部分）

np.zeros

就是产生一个全为$0$的数组。一般的格式如下：

zeros(shape, dtype=float, order=‘C’)

参数	意义
$shape$	形状
$dtype$	数据类型，可选参数，默认$np.float64$
$order$	可选参数，$c$代表与$c$语言类似，行优先；$F$代表列优先

举例来说：

import numpy as np
np.zeros((2,5), dtype = np.int))

输出结果为：
$$\begin{gathered} [[00000] \\ [00000]] \end{gathered}$$

np.unique

这个函数的意思就是去除数组里的重复元素，然后排序后输出。举例来说就是：

import numpy as np
a = np.array([1, 1, 3, 3, 2, 2])
b = np.unique(a)
print(b)

输出结果就是：$[123]$

值得注意的是：即使是多维数组，在执行这条之后也会变成一维数组。

np.arange

产生一个数列。函数格式如下：

import numpy as np
np.arange(start, stop, step, dtype)

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

例如：

x = np.arange(5)  
print (x)

输出为：$[01234]$

x = np.arange(10, 20, 2)  
print (x)

输出为：$[1012141618]$

np.linspace

这是一个产生等差数列的函数。一般的格式如下：

array = np.linspace(start, end, num = num_points)

也就是确定了等差数列的起点、终点以及产生多少个数据。如果我们这么输入：

import numpy as np
array = np.linspace(0, 10, num = 5)
print(array)

那么所产生的数组就会是：$[0,2.5,5,7.5,1]$

当然，还有一些其他的常用的可选参数。

endpoint

这个参数的取值是$bool$类型的，默认为$True$。如果设为$False$，那么所生成的等差数列就是不会包括$stop$的。比如：

import numpy as np
array = np.linspace(0, 10, num = 5, endpoint=False)
print(array)

那么所产生的数组就会是：$[0,2,4,6,8]$

简单理解一下，这个的意思就是让$num=6$，然后把最后一个数字去掉。

retstep

这个参数同样也是$bool$类型的，默认为$False$。如果设为$True$，那么就会在输出结果后面带上步长。比如：

import numpy as np
array = np.linspace(0, 10, num = 5, retstep=True)
print(array)

那么所产生的结果就会是：$(array([0.,2.5,5.,7.5,10.]),2.5)$

dtype

没啥好说的，就是很简单的设置数组的类型。

np.logspace

这是一个产生等比数列的函数。一般的格式如下：

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

$base$ 参数意思是取对数的时候 $log$ 的下标。

参数	描述
$start$	序列的起始值为：$bas{e}^{start}$
$stop$	序列的终止值为：$bas{e}^{stop}$。如果$endpoint$为$true$，该值包含于数列中
$num$	要生成的等步长的样本数量，默认为$50$
$endpoint$	该值为 $true$ 时，数列中中包含$stop$值，反之不包含，默认是$True$。
$base$	对数 $log$ 的底数。
$dtype$	$ndarray$ 的数据类型

np.where

这就是一个条件语句。一般来说有两种形式。

形式一：判断

判断是否符合条件要求，会返回索引。

import numpy as np 
x = np.arange(9.).reshape(3,  3)  
print ('我们的数组是：')
print (x)
print ( '大于 3 的元素的索引：')
y = np.where(x > 3)  
print (y)
print ('使用这些索引来获取满足条件的元素：')
print (x[y])

输出结果为：

我们的数组是：
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
大于 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
使用这些索引来获取满足条件的元素：
[4. 5. 6. 7. 8.]

两个数组就表示坐标，一个表示第几行，一个表示第几列。

形式二：修改

import numpy as np
a = np.array([[1, 2, 3], [4, 5, -1], [-2, 1, -3]])
b = np.where(a > 0, a, 0)
print(b)

输出结果为：
$$\begin{gathered} [[1,2,3], \\ [4,5,0], \\ [0,1,0]] \end{gathered}$$

np.c_ && np.r_

这两个的主要作用就是合并，而且这俩对于一维和二维数组的作用是不一样的。

np.c_

在对象是一维数组的时候，它会把横着的数组竖过来然后合并起来。具体来说就是像这样的：

数组A：$[1,2,3,4,5]$
数组B：$[6,7,8,9,10]$

在两个数组合并后所得到的数组就是：
$$\begin{gathered} [[1,6], \\ [2,7], \\ [3,8], \\ [4,9], \\ [5,10]] \end{gathered}$$

而当对象是二维数组时，例如：

数组A：
$$\begin{gathered} [[1,2,3], \\ [4,5,6]] \end{gathered}$$
数组B：
$$\begin{gathered} [[4,5,6], \\ [7,8,9]] \end{gathered}$$

那么两个数组合并之后就会得到：
$$\begin{gathered} [[1,2,3,4,5,6], \\ [4,5,6,7,8,9]] \end{gathered}$$

np.r_

在对象是一维数组的时候，就是会连成一个贼长的一维数组。比如：

数组A：$[1,2,3,4,5]$
数组B：$[6,7,8,9,10]$

在两个数组合并后所得到的数组就是：
$[1,2,3,4,5,6,7,8,9,10]$

而对象是二维数组的时候，就会是：

数组A：
$$\begin{gathered} [[1,2,3], \\ [4,5,6]] \end{gathered}$$
数组B：
$$\begin{gathered} [[4,5,6], \\ [7,8,9]] \end{gathered}$$

那么两个数组合并之后就会得到：
$$\begin{gathered} [[1,2,3], \\ [4,5,6], \\ [4,5,6], \\ [7,8,9]] \end{gathered}$$

冒号的使用

以二维数组为例。
$array[a:b,c:d]$
就是选中$array$数组的$a$到$b-1$行以及$c$到$d-1$列。

np.mean

是用来求平均值的。

import numpy as np
ids = np.array([1, 2, 3, 4])
print(np.mean(ids))

输出的结果就是$2.5$

如果是矩阵的话，可以加$axis$参数：

$axis=0$时，计算每一列的平均值
$axis=1$时，计算每一行的平均值

np.sum

求和。和上一个$np.mean$一模一样，参数都一样，实在是懒得写了。

就这样吧。