这应该是免费教程中最完善的Python数据分析教程。没有之一！是时候解放双手了！

编程小码农
88 阅读14分钟

Numpy（未完结）

说明：通常所说的"数组"，"Numpy数组"，"ndarray"基本上都是指同一个东西，即ndarray对象。

Numpy常用函数以及用法

（1）创建ndarray数组

  1. 使用array函数

说明：他可以接收一切序列型的对象，然后产生一个新的含有传入数据的Numpy数组。除非用dtype自定义类型，否则他会根据你传入的数据类型自动帮你匹配合适的类型。
此类型规则为：如果有字符串，则优先字符串，如果没有字符串而有复数类型，则系统默认帮你判定为复数类型。然后依次为浮点数和整数。即优先级为"字符串>复数>浮点数>整数"。
代码如下：

import numpy as np
array = np.array(['Hello', 1+2j, 5.20, 5])
for i in array:
    print(i, ':', type(i))
print('===============================')
array = np.array([1+2j, 5.20, 5])
for i in array:
    print(i, ':', type(i))
print('===============================')
array = np.array([5.20, 5])
for i in array:
    print(i, ':', type(i))
print('===============================')
array = np.array([5])
for i in array:
    print(i, ':', type(i))

输出结果为：

Hello : <class 'numpy.str_'>
(1+2j) : <class 'numpy.str_'>
5.2 : <class 'numpy.str_'>
5 : <class 'numpy.str_'>
===============================
(1+2j) : <class 'numpy.complex128'>
(5.2+0j) : <class 'numpy.complex128'>
(5+0j) : <class 'numpy.complex128'>
===============================
5.2 : <class 'numpy.float64'>
5.0 : <class 'numpy.float64'>
===============================
5 : <class 'numpy.int32'>
  1. 使用ones和zeros函数

除此之外，还可以使用ones函数和zeros函数来创建一个全是1或者全是0的数组，我们只需要传递给他们一个需要创建的数组的形状即可。

代码示例如下：

import numpy as np
array = np.ones((3, 3))
print(array)
print('=================')
array = np.zeros((3, 3))
print(array)

输出结果：

[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
=================
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
  1. empty函数

函数说明：empty函数可以创建一个没有任何具体指的函数。我们在使用empty的时候只需要传入一个表示形状的元祖就可以了。值得注意的是，empty创建出来的数组初始值是不确定的随机值。
例如：

import numpy as np
array = np.empty((3, 3))
print(array)

输出结果如下（完全没有规律）：

[[7.01573217e-322 0.00000000e+000 0.00000000e+000]
 [0.00000000e+000 0.00000000e+000 1.14623230e-321]
 [1.24610926e-306 1.61271680e-312 0.00000000e+000]
  1. arange函数

函数说明：arange函数用法与range函数类似。不同的是arange生成的是ndarray对象，即numpy数组。

例如运行如下代码：

import numpy as np array1 = np.arange(10)print(array1, type(array1))

输出结果如下：

[0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'>
  1. 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)
  1. logspace函数

函数说明：返回在对数刻度上均匀间隔的数字。此函数尚未理解

  1. 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]]
  1. 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. 数组的对接与分割

  1. 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]]
  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]]
  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]])]
  1. 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. 整数数组索引

（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]]
  1. 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进行打乱，无返回值

未完待续！咱们下次见！对了，需要完整的视频教程或各种系列源码的点这里直接获取

avatar
文章
阅读
粉丝
相关推荐
外行程序员的GPT入门手册
5.2k阅读
 · 
30点赞
常用语言的线程模型（Java、go、C++、python3） | 京东云技术团队
710阅读
 · 
8点赞
提高Djang查询速度的9种方法
776阅读
 · 
5点赞
Python基础教程:强大的Pandas数据分析库
2.1k阅读
 · 
4点赞
Flask快速开发Web应用：入门到精通必备知识
1.7k阅读
 · 
1点赞