[TOC]
NumPy
numpy 是python语言的一个扩展程序库, 支持大量的维度数组与矩阵运算, 此外也针对数组提供大量的数学函数库.
numpy是一个运行速度非常快的数学库, 主要用于数组计算, 包含:
一个强大的N维数组对象ndarry
广播功能函数
整合C/C++/Fortran代码的工具
线性代数, 傅里叶变换, 随机数生成等功能
numpy应用
numpy与scipy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。
SciPy 是一个开源的 Python 算法库和数学工具包。
SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。
numpy 安装
使用已经集成了这些模块的开发工具如Anaconda, Enthought Canopy, Python(x,y), WinPython, Pyzo
-
使用pip来安装
python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose--user 选项可以设置只安装在当前的用户下, 而不是写入到系统目录
linux下安装
ubuntu&debian
sudo apt-get install python-numpy python-scipy python-matplotlib ipython ipython-notebook python-pandas python-sympy python-nose
centos& Fedora
sudo dnf install numpy scipy python-matplotlib ipython python-pandas sympy python-nose atlas-devel
mac:
python -m pip install numpy scipy matplotlib
安装验证
>>> from nummpy import *
>>> eye(4)
array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 1., 0.],
[ 0., 0., 0., 1.]])
eye(4)生成对角矩阵
numpy Ndarray 对象
NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
ndarray 对象是用于存放同类型元素的多维数组。
ndarray 中的每个元素在内存中都有相同存储大小的区域。
ndarray 内部由以下内容组成：
1.一个指向数据(内存或内存映射文件中的一块数据)的指针
2.数据类型或dtype, 描述在数组中的固定大小值的格子
3.一个表示数组形状(shape)的元组, 表示各维度大小的元组
4.一个跨度元组(stride), 其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数.
ndarray内部结构:
内部结构
跨度可以是负数, 这样会使数组在内存中向后移动, 切片中obj[::-1]或obj[:,::-1]就是如此.
创建一个ndarray只需要调用Numpy的array函数即可:
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型, 可选 |
| copy | 对象是否需要复制, 可选 |
| order | 创建数组的样式, C为行方向, F为列方向, A为任意方向(默认) |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指生成数的最小维度 |
实例
import numpy
a = numpy.array([1,2,3])
print (a)
输出:
[1 2 3]
实例2:
# 多于一个维度, 两个数组
import numpy
a = numpy.array([[1,2,3], [4,5]])
print (a)
[[1, 2, 3] [4, 5]]
[Finished in 0.1s]
实例3:
# 最小维度
import numpy
a = numpy.array([1,2,3,4,5],ndmin = 2)
print (a)
输出:
[[1 2 3 4 5]]
[Finished in 0.1s]
实例4:
# dtype 参数
import numpy
a = numpy.array([1,2,3,4,5], dtype = complex)
print (a)
输出:
[ 1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]
[Finished in 0.1s]
ndarray对象由计算机内存的连续一维部分组成, 并结合索引模式, 将每个元素映射到内存块中的一个位置. 内存块一行顺序(C样式)或列顺序(FORTRAN或Matlab风格, 即F样式)来保存元素
numpy数据类型
numpy支持的数据类型比python内置的类型要多很多, 基本上可以和C语言的数据类型对应上, 其中部分类型对应为Python内置的类型.
常用基本类型:
| 名称 | 描述 |
|---|---|
| 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 , 等等
数据类型对象(dtype)
数据类型对象是用来描述与数组对应的内存区域如何使用, 这依赖如下几个方面:
- 数据类型(整数, 浮点数或者python对象)
- 数据的大小(列如, 整数使用多少个字节存储)
- 数据的字节顺序(小端法或大端法)
- 在结构化类型的情况下, 字段的名称, 每个字段的数据类型和每个字段所取的内存块的部分
- 如果数据 类型是子数组, 他的形状和数据类型
字节顺序是通过对数据类型预先设定"<"或">"来决定的. "<"意味着小端法(最小值存储在最小的地址, 即低位组放在最前面). ">"意味着大端法(最重要的字节存储在最小的地址, 即高位组放在最前面).
dtype对象是使用以下语法构造的:
numpy.dtype(object, align, copy)
object: 要转换为的数据类型对象
align: 如果为true, 填充字段使其类似C的结构体
copy: 复制dtype对象, 如果为false, 则是对内置数据类型对象的引用
实例
import numpy
# 使用标量类型
a = numpy.dtype(numpy.int32)
print (a)
输出:
int32
[Finished in 0.1s]
实例2:
# int8, int16, int32, int64 四种数据类型可以使用字符串 'i1', 'i2','i4','i8' 代替
import numpy
a = numpy.dtype('i4')
print (a)
输出:
int32
[Finished in 0.1s]
实例3:
import numpy
# 字节顺序标注
a = numpy.dtype('结构化数据类型的使用, 类型字段和对应的实际类型将被创建.
实例4:
import numpy
a = numpy.dtype([('age', numpy.int8)])
print (a)
[('age', 'i1')]
[Finished in 0.1s]
实例5:
import numpy
# 数据类型应用到ndarray对象
dt = numpy.dtype([('age', numpy.int8)])
a = numpy.array([(10,),(20,),(30,)], dtype = dt)
print (a)
[(10,) (20,) (30,)]
[Finished in 0.1s]
实例6:
# 类型字段名可以用于存取实际的age列
import numpy
dt = numpy.dtype([('age', numpy.int8)])
a = numpy.array([(10,),(20,),(30,)], dtype = dt)
print (a['age'])
[10 20 30]
[Finished in 0.1s]
下面的示例定义一个结构化数据类型 student，包含字符串字段 name，整数字段 age，及浮点字段 marks，并将这个 dtype 应用到 ndarray 对象
实例7:
import numpy
student = numpy.dtype([('name','S20'),('age','i1'),('marks','f4')])
print (student)
[('name', 'S20'), ('age', 'i1'), ('marks', '实例8:
import numpy
student = numpy.dtype([('name','S20'),('age','i1'),('marks','f4')])
a = numpy.array([('abc', 21,50),('xyz', 18, 75)], dtype = student)
print (a)
[(b'abc', 21, 50.) (b'xyz', 18, 75.)]
[Finished in 0.1s]
dtype相当于提前定义的一张数据表里面各个字段的 名字 数据类型, numpy.array()按照提前定义的字段, 依次填入进去. 注意python2和3的区别.
每个内建类型都已一个唯一定义它的字符代码如下:
| 字符 | 对应类型 |
|---|---|
| b | 布尔型 |
| i | (有符号) 整型 |
| u | 无符号整型 integer |
| f | 浮点型 |
| c | 复数浮点型 |
| m | timedelta（时间间隔） |
| M | datetime（日期时间） |
| O | (Python) 对象 |
| S, a | (byte-)字符串 |
| U | Unicode |
| V | 原始数据 (void) |
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 | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |
ndarray.ndim
返回数组的维数等于秩
import numpy
a = numpy.arange(24)
print (a.ndim) # a现只有一个维度
# 现在调整其大小
b = a.reshape(2,4,3) # b现在拥有3个维度
print (b.ndim)
1
3
ndarray.shape
ndarray.shape 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。
ndarray.shape 也可以用于调整数组大小。
实例:
import numpy
a = numpy.array([[1,2,3],[4,5,6]])
print (a.shape) # 二行三列
(2, 3)
[Finished in 0.1s]
调整大小:
import numpy
a = numpy.array([[1,2,3],[4,5,6]])
a.shape = (3,2) # 三行二列
print (a)
[[1 2]
[3 4]
[5 6]]
[Finished in 0.1s]
numpy也提供了reshape函数来调整数组大小.
import numpy
a = numpy.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print (b)
[[1 2]
[3 4]
[5 6]]
[Finished in 0.3s]
ndarray.itemsize
ndarray.itemsize 以字节的形式返回数组中每一个元素的大小。
例如，一个元素类型为 float64 的数组 itemsiz 属性值为 8(float64 占用 64 个 bits，每个字节长度为 8，所以 64/8，占用 8 个字节），又如，一个元素类型为 complex32 的数组 item 属性为 4（32/8）。
实例:
import numpy
# 数组的dtype为int8(一个字节)
a = numpy.array([1,99,2,3,4,5], dtype = numpy.int8)
print (a.itemsize)
# 数组的dtype现在为float64(8个字节)
b = numpy.array([1,2,3,4,5], dtype = numpy.float64)
print (b.itemsize)
1
8
ndarray.flags
ndarray.flags 返回ndarray对象的内存信息, 包含以下属性.
| 属性 | 描述 |
|---|---|
| C_CONTIGUOUS (C) | 数据是在一个单一的C风格的连续段中 |
| F_CONTIGUOUS (F) | 数据是在一个单一的Fortran风格的连续段中 |
| OWNDATA (O) | 数组拥有它所使用的内存或从另一个对象中借用它 |
| WRITEABLE (W) | 数据区域可以被写入，将该值设置为 False，则数据为只读 |
| ALIGNED (A) | 数据和所有元素都适当地对齐到硬件上 |
| UPDATEIFCOPY (U) | 这个数组是其它数组的一个副本，当这个数组被释放时，原数组的内容将被更新 |
import numpy
a = numpy.array([1,2,33])
print (a.flags)
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
[Finished in 0.1s]
numpy创建数组
ndarray数组除了可以使用底层ndarray构造器来创建外, 也可以通过以下几种方式来创建.
numpy.empty
numpy.empty 方法用来创建一个指定形状(shape), 数据类型(dtype)且未初始化的数组:
numpy.empty(shape, dtype = float, order = 'C')
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
import numpy
a = numpy.empty([3,2], dtype = int)
print (a)
[[ 140605049899912 140605049899912]
[ 140605009638320 140605009626224]
[7205759936368964608 72483105062780931]]
[Finished in 0.1s]
数组元素为随机值, 因为他们还未初始化
numpy.zeros
创建指定大小的数组, 数组元素以0 来填充.
numpy.zeros(shape, dtype = float, order = 'C')
参数说明:
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组 |
import numpy
# 默认为浮点数
a = numpy.zeros(5)
print (a)
# 设置类型为整数
b = numpy.zeros((5,),dtype = numpy.int)
print (b)
# 自定义类型
c = numpy.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])
print (c)
[ 0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[(0, 0) (0, 0)]
[(0, 0) (0, 0)]]
[Finished in 0.1s]
numpy.ones
创建指定形状的数组, 数组元素以1来填充:
numpy.ones(shape, dtype = None, order = 'C')
参数解释:
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组 |
实例:
import numpy
# 默认为浮点数
a = numpy.ones(5)
print (a)
# 自定义类型
b = numpy.ones([3,3], dtype = [('x', int),('y', float)])
print (b)
[ 1. 1. 1. 1. 1.]
[[(1, 1.) (1, 1.) (1, 1.)]
[(1, 1.) (1, 1.) (1, 1.)]
[(1, 1.) (1, 1.) (1, 1.)]]
[Finished in 0.1s]
从已有数组创建数组
numpy.asarray
numpy.asarray 类似 numpy.array, 但 numpy.asarray 参数有三个, 比numpy.array少两个
numpy.asarray(a, dtype = None, order = None)
参数说明:
| 参数 | 描述 |
|---|---|
| a | 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 |
| dtype | 数据类型，可选 |
| order | 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
实例:
列表装换为ndarray:
import numpy
x = [1,2,3]
a = numpy.asarray(x)
print (a)
[1 2 3]
[Finished in 0.1s]
元组转换为ndarray:
import numpy
x = (1,2,3)
a = numpy.asarray(x)
print (a)
[1 2 3]
元组列表转换为ndarray:
import numpy
x = [(1,2,3),(4,5)]
a = numpy.asarray(x)
print (a)
[(1, 2, 3) (4, 5)]
[Finished in 0.1s]
加上dtype参数:
import numpy
x = [1,2,3,4,5]
a = numpy.asarray(x, dtype = float)
print (a)
[ 1. 2. 3. 4. 5.]
[Finished in 0.1s]
numpy.frombuffer
numpy.frombuffer 用于实现动态数组, numpy.frombuffer接受buffer输入参数, 以流的形式读入转化成ndarray对象.
numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
注: buffer是字符串的时候, python3 默认str是unicode类型, 所以要转换成bytestring在原str前加上b
参数说明:
| 参数 | 描述 |
|---|---|
| buffer | 可以是任意对象，会以流的形式读入。 |
| dtype | 返回数组的数据类型，可选 |
| count | 读取的数据数量，默认为-1，读取所有数据。 |
| offset | 读取的起始位置，默认为0。 |
python3:
import numpy
s = b'hello word'
a = numpy.frombuffer(s, dtype = 'S1')
print (a)
[b'h' b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'd']
[Finished in 0.1s]
python2:
import numpy
s = 'hello word'
a = numpy.frombuffer(s, dtype = 'S1')
print (a)
pig@deep:~/Desktop/note/python/numpy$ python test.py
['h' 'e' 'l' 'l' 'o' ' ' 'w' 'o' 'r' 'd']
numpy.fromiter
numpy.fromiter 方法从可迭代对象中建立ndarray 对象, 返回一维数组
numpy.fromiter(iterable, dtype, count = -1)
| 参数 | 描述 |
|---|---|
| iterable | 可迭代对象 |
| dtype | 返回数组的数据类型 |
| count | 读取的数据数量，默认为-1，读取所有数据 |
import numpy
# 使用range函数创建列表对象
list = range(5)
it = iter(list)
# 使用迭代器创建 ndarray
a = numpy.fromiter(it, dtype = float)
print (a)
[ 0. 1. 2. 3. 4.]
[Finished in 0.1s]
numpy从数值范围创建数组
numpy.arange
numpy 包中的使用arange函数创建数值范围并返回ndarray对象, 函数格式如下:
numpy.arange(start, stop, step, dtype)
根据start与stop指定的范围以及step设定的步长, 生成一个ndarray
参数说明:
| 参数 | 描述 |
|---|---|
start |
起始值，默认为0 |
stop |
终止值（不包含） |
step |
步长，默认为1 |
dtype |
返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
实例:
生成0-5的数组
import numpy
a = numpy.arange(5, dtype = float)
print (a)
[ 0. 1. 2. 3. 4.]
[Finished in 0.1s]
设置起始值, 终止值及步长:
import numpy
a = numpy.arange(10,20,2, dtype = float)
print (a)
[ 10. 12. 14. 16. 18.]
[Finished in 0.1s]
numpy.linspace
numpy.linspace函数用于创建一个一维数组, 数组是一个等差数列构成的, 格式如下:
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
参数说明:
| 参数 | 描述 |
|---|---|
start |
序列的起始值 |
stop |
序列的终止值，如果endpoint为true，该值包含于数列中 |
num |
要生成的等步长的样本数量，默认为50 |
endpoint |
该值为 true 时，数列中中包含stop值，反之不包含，默认是True。 |
retstep |
如果为 True 时，生成的数组中会显示间距，反之不显示。 |
dtype |
ndarray 的数据类型 |
实例:
设置起始点为1, 终止点为10, 数列个数为10
import numpy
a = numpy.linspace(1,10,10, dtype = float)
print (a)
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[Finished in 0.1s]
设置元素为1的等差数列:
import numpy
a = numpy.linspace(1,1,10, dtype = float)
print (a)
[ 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
[Finished in 0.1s]
将endpoint设为false, 不包含终止值;
import numpy
a = numpy.linspace(10,20,5,endpoint = False, dtype = float)
print (a)
[ 10. 12. 14. 16. 18.]
[Finished in 0.1s]
如果将endpoint 设为true, 则会包含20.
以下实例设置间距:
import numpy
a = numpy.linspace(1,10,10,retstep = True)
print (a)
# 拓展列子
b = numpy.linspace(1,10,10).reshape([10,1])
print (b)
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
[[ 1.]
[ 2.]
[ 3.]
[ 4.]
[ 5.]
[ 6.]
[ 7.]
[ 8.]
[ 9.]
[ 10.]]
[Finished in 0.1s]
numpy.logspace
numpy.logspace函数用于创建一个等比数列格式如下:
numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base参数意思是取对数的时候log的下标
| 参数 | 描述 |
|---|---|
start |
序列的起始值为：base ** start |
stop |
序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
num |
要生成的等步长的样本数量，默认为50 |
endpoint |
该值为 true 时，数列中中包含stop值，反之不包含，默认是True。 |
base |
对数 log 的底数。 |
dtype |
ndarray 的数据类型 |
import numpy
# 默认底数是10
a = numpy.logspace(1.0, 2.0, num=10)
print (a)
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
[Finished in 0.1s]
import numpy
# 底数是2
a = numpy.logspace(0, 9,10, base=2)
print (a)
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
[Finished in 0.1s]
numpy切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。
ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
>>> import numpy
>>> a = numpy.arange(10)
>>> s = slice(2,7,2) # 从索引2 开始索引到7停止, 间隔为2
>>> print (a[s])
[2 4 6]
通过arange()函数创建ndarray对象, 然后, 分别设置起始, 终止和步长的参数为2, 7 和2.
也可以通过冒号分割切片参数start:stop:step来进行切片操作:
>>> import numpy
>>> a = numpy.arange(10)
>>> b = a[2:7:2]
>>> print (b)
[2 4 6]
>>>
索引和list中的索引差不多 单个参数[2] , [2:]索引开始后面的所有项都将提取,如果[2:7] 则提取两个索引之间的项(不包括停止索引)
多维数组同样适用上述索引提取方法:
>>> import numpy
>>> a = numpy.array([[1,2,3],[4,5,6],[7,8,9]])
>>> print (a)
[[1 2 3]
[4 5 6]
[7 8 9]]
>>> print (a[1:])
[[4 5 6]
[7 8 9]]
>>>
切片还可以包括省略号...来使选择元组的长度与数组的维度相同, 如果在行位置使用省略号, 他将返回包含行中元素的ndarray
>>> import numpy
>>> a = numpy.array([[1,2,3],[4,5,6],[7,8,9]])
>>> print (a[...,1]) # 第二列元素
[2 5 8]
>>> print (a[1,...]) # 第二行元素
[4 5 6]
>>> print (a[...,1:]) # 第二例及剩下的所有元素
[[2 3]
[5 6]
[8 9]]
>>>
numpy 高级索引
NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。
整数数组索引
以下实例获取数组中(0,0)，(1,1)和(2,0)位置处的元素。
import numpy
x = numpy.array([[1,2],[3,4],[5,6]])
y = x[[0,1,2], [0,1,0]]
print (y)
[1 4 5]
[Finished in 0.1s]
区别:
import numpy
x = numpy.array([[1,2],[3,4],[5,6]])
y = x[[0,1], [0,1]]
print (y)
print (x)
[1 4]
[[1 2]
[3 4]
[5 6]]
[Finished in 0.1s]
获取4x3数组中的四个角元素, 行索引为[0,0]和[3,3] 而列索引为[0,2]和[0,2]
import numpy
x = numpy.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print ('数组:')
print (x)
print ('\n')
rows = numpy.array([[0,0],[3,3]])
cols = numpy.array([[0,2],[0,2]])
y = x[rows, cols]
print ('角上的四个元素:')
print (y)
坐标为00 02 30 32
数组:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
角上的四个元素:
[[ 0 2]
[ 9 11]]
[Finished in 0.1s]
返回结果是包含每个角元素的ndarray对象
可以借助切片: 或...与索引数组组合
import numpy
a = numpy.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 (a)
print (b)
print (c)
print (d)
[[1 2 3]
[4 5 6]
[7 8 9]]
[[5 6]
[8 9]]
[[5 6]
[8 9]]
[[2 3]
[5 6]
[8 9]]
[Finished in 0.1s]
要获取元素 的行索引集合, 列索引集合来获取元素, 如果是获取某个区域的元素, 则使用:
布尔索引
我们可以通过一个布尔数组来索引目标数组。
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
以下实例获取大于 5 的元素：
import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print ('我们的数组是：')
print (x)
print ('\n')
# 现在我们会打印出大于 5 的元素
print ('大于 5 的元素是：')
print (x[x > 5])
我们的数组是：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
大于 5 的元素是：
[ 6 7 8 9 10 11]
[Finished in 0.3s]
以下使用~(取补运算符) 来过滤NaN
import numpy
a = numpy.array([numpy.nan, 1, 2, numpy.nan, 3, 4, 5])
print (a[~numpy.isnan(a)])
[ 1. 2. 3. 4. 5.]
[Finished in 0.1s]
从数组中过滤掉非复数元素:
import numpy
a = numpy.array([1, 2+6j,5,3.5])
print (a[numpy.iscomplex(a)])
[ 2.+6.j]
[Finished in 0.1s]
花式索引
花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素；如果目标是二维数组，那么就是对应下标的行。
花式索引跟切片不一样，它总是将数据复制到新数组中。
-
传入顺序索引数组
import numpy a = numpy.arange(32) x = a.reshape((8,4)) print (a) print (x) print (x[[4,2,1,7]]) [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31] [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15] [16 17 18 19] [20 21 22 23] [24 25 26 27] [28 29 30 31]] [[16 17 18 19] [ 8 9 10 11] [ 4 5 6 7] [28 29 30 31]] [Finished in 0.1s] 传入倒叙索引数组
import numpy
a = numpy.arange(32)
x = a.reshape((8,4))
print (a)
print (x)
print (x[[-4,-2,-1,-7]])
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
25 26 27 28 29 30 31]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
[Finished in 0.1s]
- 传入多个索引数组(要使用np.ix_)
import numpy
a = numpy.arange(32)
x = a.reshape((8,4))
print (x)
print (x[numpy.ix_([1,5,7,2],[0,3,1,2])])
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]
[16 17 18 19]
[20 21 22 23]
[24 25 26 27]
[28 29 30 31]]
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
[Finished in 0.1s]
行索引配合列索引
numpy广播(broadcast)
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
[1,2,3,4] * [10,20,30,40]
import numpy
a = numpy.array([1,2,3,4])
b = numpy.array([10,20,30,40])
c = a * b
print (c)
[ 10 40 90 160]
[Finished in 0.1s]
当运算中的两个数组形状不同时, numpy将自动触发广播机制.:
import numpy
a = numpy.array([[0,0,0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = numpy.array([1,2,3])
print (a + b)
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
[Finished in 0.1s]
广播的规则:
- 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
- 输出数组的形状是输入数组形状的各个维度上的最大值。
- 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
- 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：
- 数组拥有相同形状。
- 当前维度的值相等。
- 当前维度的值有一个是 1。
若条件不满足，抛出 "ValueError: frames are not aligned" 异常。
tile()函数就是将原矩阵横向, 纵向的复制.
tile(mat, (1,4)) 复制为原来的四倍
numpy 迭代数组
NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
迭代器最基本的任务的可以完成对数组元素的访问。
接下来我们使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代。
import numpy as np
a = np.arange(6).reshape(2,3)
print ('原数组:')
print (a)
print ('\n')
for x in np.nditer(a):
print (x, end=', ')
print ('\n')
原数组:
[[0 1 2]
[3 4 5]]
0, 1, 2, 3, 4, 5,
[Finished in 0.1s]
以上实例不是使用标准 C 或者 Fortran 顺序，选择的顺序是和数组内存布局一致的，这样做是为了提升访问的效率，默认是行序优先（row-major order，或者说是 C-order）。
这反映了默认情况下只需访问每个元素，而无需考虑其特定顺序。我们可以通过迭代上述数组的转置来看到这一点，并与以 C 顺序访问数组转置的 copy 方式做对比，如下实例：
import numpy as np
a = np.arange(6).reshape(2,3)
for x in np.nditer(a.T):
print (x, end=', ')
print ('\n')
for x in np.nditer(a.T.copy(order='C')):
print (x, end=', ')
print ('\n')
0, 1, 2, 3, 4, 5,
0, 3, 1, 4, 2, 5,
[Finished in 0.1s]
从上述例子可以看出，a 和 a.T 的遍历顺序是一样的，也就是他们在内存中的存储顺序也是一样的，但是 a.T.copy(order = 'C') 的遍历结果是不同的，那是因为它和前两种的存储方式是不一样的，默认是按行访问。
控制便来顺序
-
for x in np.nditer(a, order="F"):Fortran order, 列优先 -
for x in np.nditer(a.T, order='C'): C order , 行优先
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print ('原数组:')
print (a)
print ('\n')
print ('转置:')
b = a.T
print (b)
print ('\n')
print ('C排序:')
c = b.copy(order='C')
print (c)
for x in np.nditer(c):
print (x, end=", ")
print ('\n')
print ('-----F-------')
c = b.copy(order='F')
print (c)
for x in np.nditer(c):
print (x, end=', ')
原数组:
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
转置:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
C排序:
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55,
-----F-------
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, [Finished in 0.1s]
b=a.T表示数组的转置, 默认情况下nditer是以行来读取的, 当然也可以直接以列来读取, 使用nditer指定order以什么方式读取如下:
import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print (str('原').center(15,'*'))
print (a)
print ('\n')
print (str('C').center(15,'*'))
for x in np.nditer(a, order = 'C'):
print (x, end = ', ')
print ('\n')
print ('F'.center(15, '*'))
for x in np.nditer(a, order = 'F'):
print (x, end = ', ')
*******原*******
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
*******C*******
0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55,
*******F*******
0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, [Finished in 0.1s]
修改数组中元素的值
nditer 对象有另一个可选参数op_flags 默认情况下, nditer将视待迭代遍历的数组为只读对象(read-only), 为了在遍历数组的同时, 实现对数组元素值得修改, 必须指定read-write 或者 write-only 的模式.
import numpy
a = numpy.arange(0,60,5)
a = a.reshape(3,4)
print ('原始数组'.center(15,'*'))
print (a)
print ('\n')
for x in numpy.nditer(a, op_flags=['readwrite']):
x[...]=2*x
print ('修改后'.center(15,'*'))
print (a)
******原始数组*****
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
******修改后******
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
[Finished in 0.1s]
使用外部循环:
nditer 类的构造器拥有flags参数, 他可以接受下列值:
| 参数 | 描述 |
|---|---|
c_index |
可以跟踪 C 顺序的索引 |
f_index |
可以跟踪 Fortran 顺序的索引 |
multi-index |
每次迭代可以跟踪一种索引类型 |
external_loop |
给出的值是具有多个值的一维数组，而不是零维数组 |
import numpy
a = numpy.arange(0,60,5)
a = a.reshape(3,4)
print ('原始数组'.center(20,'*'))
print (a)
print ('\n')
print ('修改后的数组:'.center(20,'*'))
for x in numpy.nditer(a, flags = ['external_loop'], order = 'F'):
print (x, end=", ")
********原始数组********
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
******修改后的数组:*******
[ 0 20 40], [ 5 25 45], [10 30 50], [15 35 55], [Finished in 0.1s]
广播迭代
如果两个数组是可广播的, nditer组合对象能够同时迭代他们, 假设数组a的维度为3x4, 数组b的维度为1x4 则使用以下迭代器(数组b被广播到a的大小)
import numpy
a = numpy.arange(0,60,5)
a = a.reshape(3,4)
print ('第一个数组'.center(20, "*"))
print (a)
print ('\n')
print ('第二个数组'.center(20, "*"))
b = numpy.array([1,2,3,4],dtype = int)
print (b)
print ('\n')
print ('修改之后的数组'.center(20, "*"))
for x,y in numpy.nditer([a,b]):
print ('%d:%d' % (x, y), end=', ')
*******第一个数组********
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
*******第二个数组********
[1 2 3 4]
******修改之后的数组*******
0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4, [Finished in 0.1s]
数组操作
处理数组大概分为以下几类:
- 修改数组形状
- 翻转数组
- 修改数组 维度
- 连接数组
- 分割数组
- 数组元素的添加与删除
修改数组形状
| 函数 | 描述 |
|---|---|
reshape |
不改变数据的条件下修改形状 |
flat |
数组元素迭代器 |
flatten |
返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 |
ravel |
返回展开数组 |
numpy.reshape
numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order='C')
-
arr：要修改形状的数组 -
newshape：整数或者整数数组，新的形状应当兼容原有形状 - order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。
import numpy as np
a = np.arange(8)
print ('原始数组：')
print (a)
print ('\n')
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.flat
numpy.ndarray.flat 是一个数组元素迭代器, 实例:
import numpy
a = numpy.arange(9).reshape(3,3)
print ('原数组'.center(20,'*'))
for row in a:
print (row)
# 对数组中每个元素都进行处理, 可以使用flat属性, 该属性是一个数组元素迭代器.
print ('迭代后的数组'.center(20, '*'))
for element in a.flat:
print (element)
********原数组*********
[0 1 2]
[3 4 5]
[6 7 8]
*******迭代后的数组*******
0
1
2
3
4
5
6
7
8
[Finished in 0.3s]
numpy.ndarray.flatten
numpy.ndarray.flatten 返回一份数组拷贝, 对拷贝所做的修改不会影响原始数组, 格式:
ndarray.flatten(order='C')
order'C'--按行, 'F'-- 按列, 'A' -- 按原顺序, 'K' -- 元素在内存中的出现顺序.
import numpy
a = numpy.arange(8).reshape(2,4)
print('原'.center(20, '*'))
print (a)
print ('\n')
print ('展开数组:'.center(20, '*'))
print (a.flatten())
print ('\n')
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]
[Finished in 0.1s]
numpy.ravel
numpy.ravel ()展平的数组元素, 顺序通常是"C风格", 返回数组视图(view, 有点类似C/C++引用reference的意味), 修改会影响原始数组,
numpy.ravel(a, order = 'C')
实例:
import numpy
a = numpy.arange(8).reshape(2,4)
print('原'.center(20, '*'))
print (a)
print ('\n')
print ('调用ravel函数之后'.center(20, '*'))
print (a.ravel())
print ('\n')
print ('F顺序调用ravel函数的数组')
print (a.ravel(order = 'F'))
*********原**********
[[0 1 2 3]
[4 5 6 7]]
****调用ravel函数之后*****
[0 1 2 3 4 5 6 7]
F顺序调用ravel函数的数组
[0 4 1 5 2 6 3 7]
[Finished in 0.1s]
翻转数组
| 函数 | 描述 |
|---|---|
transpose |
对换数组的维度 |
ndarray.T |
和 self.transpose() 相同 |
rollaxis |
向后滚动指定的轴 |
swapaxes |
对换数组的两个轴 |
numpy.transpose
numpy.transpose 函数用于对换数组的维度
numpy.transpose(arr, axes)
arr要操作的数组
axes整数列表, 对应维度, 通常所有维度都会对换
import numpy
a = numpy.arange(12).reshape(3,4)
print('原'.center(20, '*'))
print (a)
print ('\n')
print ('对换数组'.center(20, '*'))
print (numpy.transpose(a))
print ('\n')
*********原**********
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
********对换数组********
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
[Finished in 0.2s]
numpy.ndarray.T 类似numpy.transpose:
import numpy
a = numpy.arange(12).reshape(3,4)
print('原'.center(20, '*'))
print (a)
print ('\n')
print ('转置数组'.center(20, '*'))
print (a.T)
print ('\n')
*********原**********
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
********转置数组********
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
[Finished in 0.1s]
numpy.rollaxis
numpy.rollaxis函数向后滚动特定的轴到一个特定位置, 格式如下:
numpy.rollaxis(arr, axis, start)
arr数组
axis 向后滚动的轴, 其他轴的相对位置不会改变
start 默认为0, 表示完整的滚动, 回滚到特定的位置
import numpy
a = numpy.arange(8).reshape(2,2,2)
print('原'.center(20, '*'))
print (a)
print ('\n')
# 将轴2滚动到轴0(宽度到深度)
print ('调用rollaxis函数'.center(20, '*'))
print (numpy.rollaxis(a,2))
# 将轴0 滚动到轴1位置, (宽度到高度)
print ('\n')
print ('调用rollaxis函数')
print (numpy.rollaxis(a,2,1))
*********原**********
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
****调用rollaxis函数****
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
调用rollaxis函数
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
[Finished in 0.1s]
numpy.swapaxes
numpy.swapaxes 函数用于交换数组的两个轴, 格式如下:
numpy.swapaxes(arr, sxis1, axis2)
arr 数组
axis1 对应第一个轴的整数
axis2 对应第二个轴的整数
import numpy
a = numpy.arange(8).reshape(2,2,2)
print('原'.center(20, '*'))
print (a)
print ('\n')
# 现在交换轴0(深度方向)到轴2(宽度方向)
print ('调用swapaxes函数后的数组'.center(20, '*'))
print (numpy.swapaxes(a, 2, 0))
*********原**********
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
**调用swapaxes函数后的数组**
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
[Finished in 0.1s]
修改数组维度
| 维度 | 描述 |
|---|---|
broadcast |
产生模仿广播的对象 |
broadcast_to |
将数组广播到新形状 |
expand_dims |
扩展数组的形状 |
squeeze |
从数组的形状中删除一维条目 |
numpy.broadcast
numpy.broadcast 用于模仿广播的对象, 它返回一个对象, 该对象封装了将一个数组广播到另一个数组的结果, 该函数使用两个数组作为输入参数, 如下实例:
import numpy as np
x = np.array([[1], [2], [3]])
y = np.array([4, 5, 6])
# 对 y 广播 x
b = np.broadcast(x,y)
# 它拥有 iterator 属性，基于自身组件的迭代器元组
print (b)
print ('对 y 广播 x：')
r,c = b.iters
# Python3.x 为 next(context) ，Python2.x 为 context.next()
print (next(r), next(c))
print (next(r), next(c))
print ('\n')
# shape 属性返回广播对象的形状
print ('广播对象的形状：')
print (b.shape)
print ('\n')
# 手动使用 broadcast 将 x 与 y 相加
b = np.broadcast(x,y)
c = np.empty(b.shape)
print ('手动使用 broadcast 将 x 与 y 相加：')
print (c.shape)
print ('\n')
c.flat = [u + v for (u,v) in b]
print ('调用 flat 函数：')
print (c)
print ('\n')
# 获得了和 NumPy 内建的广播支持相同的结果
print ('x 与 y 的和：')
print (x + y)
对 y 广播 x：
1 4
1 5
广播对象的形状：
(3, 3)
手动使用 broadcast 将 x 与 y 相加：
(3, 3)
调用 flat 函数：
[[ 5. 6. 7.]
[ 6. 7. 8.]
[ 7. 8. 9.]]
x 与 y 的和：
[[5 6 7]
[6 7 8]
[7 8 9]]
[Finished in 0.1s]
numpy.broadcast_to
numpy.broadcast_to 函数将数组广播到新形状, 他在原始数组上返回只读视图, 它通常不连续, 如果新形状不符合numpy的广播规则, 该函数可能会抛出ValueError
numpy.broadcast_to(array, shape, subok)
import numpy
a = numpy.arange(4).reshape(1,4)
print ('原数组:')
print (a)
print ('\n')
print ('调用broadcast_to函数之后')
print (numpy.broadcast_to(a,(2,4)))
原数组:
[[0 1 2 3]]
调用broadcast_to函数之后
[[0 1 2 3]
[0 1 2 3]]
[Finished in 0.1s]
numpy.expand_dims
numpy.expand_dims 函数通过指定位置插入新的轴来扩展数组形状, 函数格式:
numpy.expand_dims(arr, axis)
arr 输入的数组
axis 新轴插入的位置, 0 表示行, 1 表示列
import numpy
x = numpy.array(([1,2],[3,4]))
print ('数组x')
print (x)
print ('\n')
y = numpy.expand_dims(x, axis = 0)
print ('数组y')
print (y)
print ('\n')
print ('数组x和y的形状')
print (x.shape, y.shape)
print ('\n')
# 在轴1 位置插入轴
y = numpy.expand_dims(x, axis = 1)
print ('在位置1 插入轴之后的数组')
print (y)
print ('\n')
print ('x.ndim y.ndim')
print (x.ndim, y.ndim)
print ('\n')
print ('x.shape, y.shape')
print (x.shape, y.shape)
数组x
[[1 2]
[3 4]]
数组y
[[[1 2]
[3 4]]]
数组x和y的形状
(2, 2) (1, 2, 2)
在位置1 插入轴之后的数组
[[[1 2]]
[[3 4]]]
x.ndim y.ndim
2 3
x.shape, y.shape
(2, 2) (2, 1, 2)
[Finished in 0.1s]
numpy.squeeze
numpy.squeeze 从给定数组的形状中删除一维的条目,
numpy.squeeze(arr, axis)
arr输入数组
axis 整数或整数元组, 用于选择形状中的一维条目的子集
import numpy
x = numpy.arange(9).reshape(1,3,3)
print ('数组x')
print (x)
print ('\n')
y = numpy.squeeze(x)
print ('数组y')
print (y)
print ('\n')
print ('x.shape, y.shape')
print (x.shape, y.shape)
数组x
[[[0 1 2]
[3 4 5]
[6 7 8]]]
数组y
[[0 1 2]
[3 4 5]
[6 7 8]]
x.shape, y.shape
(1, 3, 3) (3, 3)
[Finished in 0.1s]
连接数组
| 函数 | 描述 |
|---|---|
concatenate |
连接沿现有轴的数组序列 |
stack |
沿着新的轴加入一系列数组。 |
hstack |
水平堆叠序列中的数组（列方向） |
vstack |
竖直堆叠序列中的数组（行方向） |
concatenate
用于沿着指定轴连接相同形状的两个或多个数组
numpy.concatenate((a1,a2, ...),axis)
a1,a2,a3,... 相同类型的数组
axis 沿着它连接数组的轴, 默认为0
import numpy
a = numpy.array([[1,2],[3,4]])
print ('第一个数组')
print (a)
print ('\n')
b = numpy.array([[5,6],[7,8]])
print ('第二个数组')
print (b)
print ('\n')
# 两个数组的维度相同
print ('沿轴0连接两个数组:')
print (numpy.concatenate((a,b)))
print ('\n')
print ('沿着轴1连接两个数组')
print (numpy.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]]
[Finished in 0.1s]
numpy.stack
用于沿新轴连接数组序列
numpy.stack(arrays, axis)
arrays相同形状的数组序列
axis 返回数组中的轴, 输入数组沿着它来堆叠
import numpy
a = numpy.array([[1,2],[3,4]])
print ('第一个数组')
print (a)
print ('\n')
b = numpy.array([[5,6],[7,8]])
print ('第二个数组')
print (b)
print ('\n')
print ('沿着0堆叠两个数组')
print (numpy.stack((a,b),0))
print ('\n')
print ('沿着列堆叠两个数组')
print (numpy.stack((a,b),1))
第一个数组
[[1 2]
[3 4]]
第二个数组
[[5 6]
[7 8]]
沿着0堆叠两个数组
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
沿着列堆叠两个数组
[[[1 2]
[5 6]]
[[3 4]
[7 8]]]
[Finished in 0.1s]
numpy.hstack
是numpy.stack的变体， 通过水平堆叠来生成数组
import numpy
a = numpy.array([[1,2],[3,4]])
print ('第一个数组')
print (a)
print ('\n')
b = numpy.array([[5,6],[7,8]])
print ('第二个数组')
print (b)
print ('\n')
print ('水平堆叠')
c = numpy.hstack((a,b))
print (c)
第一个数组
[[1 2]
[3 4]]
第二个数组
[[5 6]
[7 8]]
水平堆叠
[[1 2 5 6]
[3 4 7 8]]
[Finished in 0.1s]
numpy.vstack
通过垂直堆叠来生成数组
import numpy
a = numpy.array([[1,2],[3,4]])
print ('第一个数组')
print (a)
print ('\n')
b = numpy.array([[5,6],[7,8]])
print ('第二个数组')
print (b)
print ('\n')
print ('垂直堆叠')
print (numpy.vstack((a,b)))
第一个数组
[[1 2]
[3 4]]
第二个数组
[[5 6]
[7 8]]
垂直堆叠
[[1 2]
[3 4]
[5 6]
[7 8]]
[Finished in 0.1s]
分割数组
| 函数 | 数组及操作 |
|---|---|
split |
将一个数组分割为多个子数组 |
hsplit |
将一个数组水平分割为多个子数组（按列） |
vsplit |
将一个数组垂直分割为多个子数组（按行） |
numpy.split
沿特定的轴将数组分割为子数组
numpy.split(ary, indices_or_sections, axis)
ary 被分割的数组
indices_or_se_ctinos 如果是一个整数就用该数平均切分，如果是一个数组，为沿轴切分的位置(左开右闭)
沿哪个维度切割 ０，１
import numpy
a = numpy.arange(9)
print ('第一个数组')
print (a)
print ('\n')
print ('将数组分为三个大小相等的子数组')
b = numpy.split(a, 3)
print (b)
print ('\n')
print ('将数组在一维数组中表明的位置分割')
b = numpy.split(a,[4,7])
print (b)
第一个数组
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
将数组在一维数组中表明的位置分割
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
[Finished in 0.1s]
numpy.hsplit
用于水平分割数组， 通过指定要返回的相同形状的数组数量来拆分原数组
import numpy
harr = numpy.floor(10 * numpy.random.random((2,6)))
print ('原数组')
print (harr)
print ('拆分后')
print (numpy.hsplit(harr,3))
原数组
[[ 6. 3. 8. 0. 4. 8.]
[ 6. 6. 7. 0. 3. 1.]]
拆分后
[array([[ 6., 3.],
[ 6., 6.]]), array([[ 8., 0.],
[ 7., 0.]]), array([[ 4., 8.],
[ 3., 1.]])]
[Finished in 0.3s]
numpy.vsplit
沿垂直轴分割, 分割方式和hsplit相同
import numpy
a = numpy.arange(16).reshape(4,4)
print ('第一个数组:')
print (a)
print ('\n')
print ('竖直分割')
b = numpy.vsplit(a,2)
print (b)
第一个数组:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
竖直分割
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
[Finished in 0.1s]
数组元素的添加与删除
| 函数 | 元素及描述 |
|---|---|
resize |
返回指定形状的新数组 |
append |
将值添加到数组末尾 |
insert |
沿指定轴将值插入到指定下标之前 |
delete |
删掉某个轴的子数组，并返回删除后的新数组 |
unique |
查找数组内的唯一元素 |
numpy.resize
返回指定大小的新数组, 如果新数组大小大于原始大小, 则包含原数组中的元素副本
numpy.resize(arr, shape)
arr 要修改大小的数组
shape 返回数组的新形状
import numpy
a = numpy.array([[1,2,3],[4,5,6]])
print ('第一个数组')
print (a)
print ('\n')
print ('第一个数组形状')
print (a.shape)
print ('\n')
b = numpy.resize(a,(3,2))
print ('第二个数组')
print (b)
print ('第二个数组形状')
print (b.shape)
print ('\n')
# 注意a的第一行b中重复出现, 因为尺寸变大了
print ('修改后的第二个数组大小')
print (numpy.resize(a,(3,3)))
第一个数组
[[1 2 3]
[4 5 6]]
第一个数组形状
(2, 3)
第二个数组
[[1 2]
[3 4]
[5 6]]
第二个数组形状
(3, 2)
修改后的第二个数组大小
[[1 2 3]
[4 5 6]
[1 2 3]]
[Finished in 0.1s]
numpy.append
函数在数组末尾添加值, 追加操作会分配整个数组, 并把原来的数组复制到新数组里, 此外, 输入数组的维度必须匹配否则将生成ValueError
append函数返回的始终是一个一维数组
numpy.append(arr, values, axis=None)
-
arr：输入数组 -
values：要向arr添加的值，需要和arr形状相同（除了要添加的轴） -
axis：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。
import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print ('第一个数组')
print (a)
print ('\n')
print ('向数组添加元素')
print (np.append(a, [7,8,9]))
print ('\n')
print ('沿轴0添加元素')
print (np.append(a, [[7,8,9]], axis = 0))
print ('\n')
print ('沿轴1添加元素')
print (np.append(a, [[5,5,5],[7,8,9]], axis = 1))
第一个数组
[[1 2 3]
[4 5 6]]
向数组添加元素
[1 2 3 4 5 6 7 8 9]
沿轴0添加元素
[[1 2 3]
[4 5 6]
[7 8 9]]
沿轴1添加元素
[[1 2 3 5 5 5]
[4 5 6 7 8 9]]
[Finished in 0.1s]
numpy.insert
在给定索引之前, 沿给定轴在输入数组中插入值, 如果值的类型转换为要插入, 则它与输入数组不同, 插入没有原地的, 函数会返回一个新数组, 此外未提供轴, 则输入数组被展开.
numpy.insert(arr, obj, values, axis)
arr 输入数组
obj在其 之前插入值的索引
values要插入的值
axis 沿着它插入的轴, 如果未提供, 则输入数组会被展开
import numpy as np
a = np.array([[1,2], [3,4], [5,6]])
print ('第一个数组')
print (a)
print ('\n')
print ('未传递axis参数, 在插入之前输入数组会被展开')
print (np.insert(a,3,[11,22]))
print ('\n')
print ('传递axis参数, 会广播值数组来配输入数组')
print ('沿轴0广播')
print (np.insert(a, 1, [11], axis = 0))
print ('\n')
print ('沿轴1广播')
print (np.insert(a,1,11,axis = 1))
第一个数组
[[1 2]
[3 4]
[5 6]]
未传递axis参数, 在插入之前输入数组会被展开
[ 1 2 3 11 22 4 5 6]
传递axis参数, 会广播值数组来配输入数组
沿轴0广播
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]
沿轴1广播
[[ 1 11 2]
[ 3 11 4]
[ 5 11 6]]
numpy.delete
返回从输入数组中删除指定子数组的新数组, 与insert函数一样, 如果未提供轴参数, 输入数组将展开
numpy.delete(arr, obj, axis)
arr 输入数组
obj 可以被切片, 整数或者整数数组, 表明要从输入数组删除的子数组
axis 沿着它删除给定子数组的轴, 如果未提供, 则输入数组会被展开
import numpy as np
a = np.arange(12).reshape(3,4)
print (a)
print ('\n')
print ('未传递axis参数, 在插入之前输入数组会被展开')
print (np.delete(a,5))
print ('删除第二列')
print (np.delete(a,1,axis = 1))
print ('\n')
print ('包含从数组中删除的替代值的切片')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
未传递axis参数, 在插入之前输入数组会被展开
[ 0 1 2 3 4 6 7 8 9 10 11]
删除第二列
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]
包含从数组中删除的替代值的切片
[ 2 4 6 8 10]
numpy.unique
用于去除数组中的重复元素
numpy.unique(arr, return_index, return_inverse, return_counts)
arr 输入数组, 如果不是一维数组则会展开
return_index 如果为true, 返回新列表元素在旧列表中的位置(下表), 并以列表形式存储
return_inverse如果为true, 返回旧列表元素在新列表中的位置(下标), 并以列表形式存储
return_counts如果为true, 返回去重数组中的元素在原数组中出现次数
import numpy as np
a = np.array([5,2,6,2,7,5,6,8,2,9])
print ('第一个数组')
print (a)
print ('\n')
print ('第一个数组的去重值')
u = np.unique(a)
print (u)
print ('\n')
print ('去重数组的索引数组')
u, indices = np.unique(a, return_index = True)
print (indices)
print ('\n')
print ('我们可以看到每个和原数组下表对应的数值')
print (a)
print ('\n')
print ('去重数组的下标')
u, indices = np.unique(a, return_inverse = True)
print (u)
print ('\n')
print ('下标为')
print (indices)
print ('\n')
print ('使用下标重构原数组')
print (u[indices])
print ('\n')
print ('返回去重元素的重复数量')
u, indices = np.unique(a, return_counts = True)
print (u)
print (indices)
第一个数组
[5 2 6 2 7 5 6 8 2 9]
第一个数组的去重值
[2 5 6 7 8 9]
去重数组的索引数组
[1 0 2 4 7 9]
我们可以看到每个和原数组下表对应的数值
[5 2 6 2 7 5 6 8 2 9]
去重数组的下标
[2 5 6 7 8 9]
下标为
[1 0 2 0 3 1 2 4 0 5]
使用下标重构原数组
[5 2 6 2 7 5 6 8 2 9]
返回去重元素的重复数量
[2 5 6 7 8 9]
[3 2 2 1 1 1]
numpy 位运算
NumPy "bitwise_" 开头的函数是位运算函数。
NumPy 位运算包括以下几个函数：
| 函数 | 描述 |
|---|---|
bitwise_and |
对数组元素执行位与操作 |
bitwise_or |
对数组元素执行位或操作 |
invert |
按位取反 |
left_shift |
向左移动二进制表示的位 |
right_shift |
向右移动二进制表示的位 |
注：也可以使用 "&"、 "~"、 "|" 和 "^" 等操作符进行计算。
import numpy as np
print ('13和17二进制形式')
a,b = 13, 17
print (bin(a), bin(b))
print ('\n')
print ('13和17的位与')
print (np.bitwise_and(13,17))
13和17二进制形式
0b1101 0b10001
13和17的位与
1
以上实例可以用下表来说明：
| 1 | 1 | 0 | 1 | ||
|---|---|---|---|---|---|
| AND | |||||
| 1 | 0 | 0 | 0 | 1 | |
| 运算结果 | 0 | 0 | 0 | 0 | 1 |
位与操作运算规律如下：
| A | B | AND |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
bitwise_or
对数组中整数的二进制形式执行位或运算
import numpy as np
a, b = 13, 17
print ('13和17的二进制形式')
print (bin(a), bin(b))
print ('13和17的位或')
print (np.bitwise_or(13,17))
13和17的二进制形式
0b1101 0b10001
13和17的位或
29
以上实例可以用下表来说明：
| 1 | 1 | 0 | 1 | ||
|---|---|---|---|---|---|
| OR | |||||
| 1 | 0 | 0 | 0 | 1 | |
| 运算结果 | 1 | 1 | 1 | 0 | 1 |
位或操作运算规律如下：
| A | B | OR |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
invert
函数对数组中整数进行取反运算, 0变为1, 1变为0
对于有符号的整数, 取该二进制的补码然后+1 二进制数, 最高位为0表示整数, 最高位为1 表示负数
看看 ~1 的计算步骤：
将1(这里叫：原码)转二进制 ＝ 00000001
按位取反 ＝ 11111110
发现符号位(即最高位)为1(表示负数)，将除符号位之外的其他数字取反 ＝ 10000001
末位加1取其补码 ＝ 10000010
转换回十进制 ＝ -2
-
表达式 二进制值（2 的补数） 十进制值 5 00000000 00000000 00000000 0000010 5 ~5 11111111 11111111 11111111 11111010 -6
import numpy as np
print ('13的位反转,其中ndarra的dtype是uint8')
print (np.invert(np.array([13], dtype = np.uint8)))
print ('\n')
# 比较13和242的二进制数表示, 我们发现了位的反转
print ('13的二进制表示:')
print (np.binary_repr(13, width = 8))
print ('\n')
print ('242的二进制表示')
print (np.binary_repr(242, width = 8))
13的位反转,其中ndarra的dtype是uint8
[242]
13的二进制表示:
00001101
242的二进制表示
11110010
left_shift
将数组元素的二进制形式向左移动到指定位置, 右侧附加相等数量的0
import numpy as np
print ('将10向左移动两位')
print (np.left_shift(10,2))
print ('\n')
print ('10的二进制表示')
print (np.binary_repr(10, width = 8))
print ('40的二进制表示')
print (np.binary_repr(40, width = 8))
# '00001010'中的两位移动到左边, 并在右边添加了两个0
将10向左移动两位
40
10的二进制表示
00001010
40的二进制表示
00101000
right_shift
函数将数组元素的二进制形式向右移动到指定的位置, 左侧附加相等数量的0
import numpy as np
print ('将40右移两位')
print (np.right_shift(40,2))
print ('\n')
print ('40的二进制表示')
print (np.binary_repr(40, width = 8))
print ('\n')
print ('10的二进制表示')
print (np.binary_repr(10, width = 8))
# '00001010'中的两位移动到了右边, 并在左边添加了两个0
将40右移两位
10
40的二进制表示
00101000
10的二进制表示
00001010
numpy字符串函数
以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。
这些函数在字符数组类（numpy.char）中定义。
| 函数 | 描述 |
|---|---|
add() |
对两个数组的逐个字符串元素进行连接 |
| multiply() | 返回按元素多重连接后的字符串 |
center() |
居中字符串 |
capitalize() |
将字符串第一个字母转换为大写 |
title() |
将字符串的每个单词的第一个字母转换为大写 |
lower() |
数组元素转换为小写 |
upper() |
数组元素转换为大写 |
split() |
指定分隔符对字符串进行分割，并返回数组列表 |
splitlines() |
返回元素中的行列表，以换行符分割 |
strip() |
移除元素开头或者结尾处的特定字符 |
join() |
通过指定分隔符来连接数组中的元素 |
replace() |
使用新字符串替换字符串中的所有子字符串 |
decode() |
数组元素依次调用str.decode |
encode() |
数组元素依次调用str.encode |
numpy.char.add()
依次对两个数组的元素进行字符串连接
import numpy as np
print ('连接两个字符串')
print (np.char.add(['hello'],['word']))
print ('连接示列')
print (np.char.add(['hello', 'hi'],['word','world']))
连接两个字符串
['helloword']
连接示列
['helloword' 'hiworld']
numpy.char.multiply()
执行多重连接
import numpy as np
print (np.char.multiply('python', 5))
pythonpythonpythonpythonpython
numpy.char.center()
函数用于将字符串居中, 并使用指定字符在左侧和右侧进行填充
np.char.center(str, width, fillchar)
str: 字符串, width:长度, fillchar: 填充字符
import numpy as np
print (np.char.center('python', 20, fillchar = '*'))
*******python*******
numpy.char.capitalize()
将字符串的第一个字母装换为大写
>>> import numpy as np
>>> print (np.char.capitalize('python')
... )
Python
numpy.char.title()
字符串的每个单词的第一个字母转换为大写
>>> import numpy as np
>>> print (np.char.title('i love python'))
I Love Python
numpy.char.lower()
对数组的每个元素转换为小写, 对每个元素调用str.lower
>>> print (np.char.lower(['HELLO','PYTHON'])) # 操作数组
['hello' 'python']
>>> print (np.char.lower('PYTHON')) # 操作字符串
python
numpy.char.upper()
将数组每个元素转换成大写, 同char.lower()
numpy.char.split()
通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。
>>> print (np.char.split('i love python')) # 默认分割符为空格
['i', 'love', 'python']
>>> print (np.char.split('pigdaqiang.top', sep = '.')) # 指定分隔符为 .
['pigdaqiang', 'top']
numpy.char.splitlines()
以换行符作为分隔符, 并返回数组
>>> print (np.char.splitlines('i\r\nlove python'))
['i', 'love python']
>>> print (np.char.splitlines('i\rlove python'))
['i', 'love python']
注意区别linux下和win下换行符的区别 \r \n \r\n
numpy.char.strip()
用于移除开头或结尾处的特定字符
>>> print (np.char.strip('hhello', 'h')) # 移除字符串头尾的h字符
ello
>>>
>>> print (np.char.strip(['hello','hi','high'],'h')) # 移除数组元素头尾的a字符
['ello' 'i' 'ig']
>>>
numpy.char.join()
通过指定分割符来连接数组中的元素或字符串
>>> print (np.char.join(':','hello'))
h:e:l:l:o
>>> print (np.char.join([':','*'],['hello','python']))
['h:e:l:l:o' 'p*y*t*h*o*n']
>>>
numpy.char.replace()
使用新字符串代替字符串中的所有子字符串
>>> print (np.char.replace('i love python',' ','*'))
i*love*python
>>>
numpy.char.encode()
函数对数组中的每个元素调用str.encode函数, 默认编码是utf-8, 可以使用标准python库中的编解码器
>>> print (np.char.encode('hello','cp500'))
b'\x88\x85\x93\x93\x96'
>>>
numpy.char.decode()
函数对编码的元素进行str.encode()解码
>>> a = np.char.encode('hello', 'cp500')
>>> print (a, np.char.decode(a, 'cp500'))
b'\x88\x85\x93\x93\x96' hello
>>>
numpy数学函数
NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。
三角函数
NumPy 提供了标准的三角函数：sin()、cos()、tan()。
import numpy as np
a = np.array([0,20,45,60,90])
print ('不同角度的正弦值')
# 通过乘pi/180转化为弧度
print (np.sin(a*np.pi/180))
print ('\n')
print ('数组中角度的余玄值')
print (np.cos(a*np.pi/180))
print ('\n')
print ('数组中角度的正切值')
print (np.tan(a*np.pi/180))
不同角度的正弦值
[ 0. 0.34202014 0.70710678 0.8660254 1. ]
数组中角度的余玄值
[ 1.00000000e+00 9.39692621e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
数组中角度的正切值
[ 0.00000000e+00 3.63970234e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。
这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度。
import numpy as np
a = np.array([0,30,45,60,90])
print ('含有正弦值的数组：')
sin = np.sin(a*np.pi/180)
print (sin)
print ('\n')
print ('计算角度的反正弦，返回值以弧度为单位：')
inv = np.arcsin(sin)
print (inv)
print ('\n')
print ('通过转化为角度制来检查结果：')
print (np.degrees(inv))
print ('\n')
print ('arccos 和 arctan 函数行为类似：')
cos = np.cos(a*np.pi/180)
print (cos)
print ('\n')
print ('反余弦：')
inv = np.arccos(cos)
print (inv)
print ('\n')
print ('角度制单位：')
print (np.degrees(inv))
print ('\n')
print ('tan 函数：')
tan = np.tan(a*np.pi/180)
print (tan)
print ('\n')
print ('反正切：')
inv = np.arctan(tan)
print (inv)
print ('\n')
print ('角度制单位：')
print (np.degrees(inv))
含有正弦值的数组：
[0. 0.5 0.70710678 0.8660254 1. ]
计算角度的反正弦，返回值以弧度为单位：
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
通过转化为角度制来检查结果：
[ 0. 30. 45. 60. 90.]
arccos 和 arctan 函数行为类似：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
反余弦：
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制单位：
[ 0. 30. 45. 60. 90.]
tan 函数：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
反正切：
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
角度制单位：
[ 0. 30. 45. 60. 90.]
舍入函数
函数返回指定数字的四舍五入值
numpy.around(a, decimals)
a 数组
decimals 舍入的小数位数, 默认值为0, 如果为负数, 整数将四舍五入到小数点的左侧
import numpy as np
a = np.array([1.0, 5.55, 123, 0.567, 25.532])
print ('原数组')
print (a)
print ('\n')
print ('舍入后')
print (np.around(a))
print (np.around(a, decimals = 1))
print (np.around(a, decimals = -1))
原数组
[ 1. 5.55 123. 0.567 25.532]
舍入后
[ 1. 6. 123. 1. 26.]
[ 1. 5.6 123. 0.6 25.5]
[ 0. 10. 120. 0. 30.]
numpy.floor()
返回小于或者等于指定表达式的最大整数, 向下取整
import numpy as np
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print ('提供的数组')
print (a)
print ('\n')
print ('修改后的数组')
print (np.floor(a))
提供的数组
[ -1.7 1.5 -0.2 0.6 10. ]
修改后的数组
[ -2. 1. -1. 0. 10.]
numpy.ceil()
返回大于或者等于指定表达式的最小整数, 即向上取整. 用法同floor
numpy算术函数
算术函数包含简单的加减乘除:add(), substract(), multiply(), divide()
数组必须具有相同形状或符合数组广播 规则
import numpy as np
a = np.arange(9, dtype = np.float_).reshape(3,3)
print ('第一个数组')
print (a)
print ('\n')
print ('第二个数组')
b = np.array([10,10,10])
print (b)
print ('\n')
print ('两个数组相加')
print (np.add(a,b))
print ('\n')
print ('两个数组相减')
print (np.subtract(a,b))
print ('\n')
print ('两个数组相乘')
print (np.multiply(a,b))
print ('\n')
print ('两个数组 相除:')
print (np.divide(a,b))
第一个数组
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
第二个数组
[10 10 10]
两个数组相加
[[ 10. 11. 12.]
[ 13. 14. 15.]
[ 16. 17. 18.]]
两个数组相减
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
两个数组相乘
[[ 0. 10. 20.]
[ 30. 40. 50.]
[ 60. 70. 80.]]
两个数组 相除:
[[ 0. 0.1 0.2]
[ 0.3 0.4 0.5]
[ 0.6 0.7 0.8]]
numpy.reciprocal()
返回参数逐元素的倒数, 1/4倒数4/1
import numpy as np
a = np.array([0.25, 1.33, 1, 100])
print (a)
print ('倒数')
print (np.reciprocal(a))
[ 0.25 1.33 1. 100. ]
倒数
[ 4. 0.7518797 1. 0.01 ]
numpy.power()
函数将第一个输入数组中的元素作为底数, 计算它与第二个输入数组中相应元素的幂
import numpy as np
a = np.array([10,100,1000])
print ('数组')
print (a)
print ('\n')
print ('调用power')
print (np.power(a,2))
print ('\n')
print ('第二个数组')
b = np.array([1,2,3])
print (b)
print ('再次调用power函数')
print (np.power(a,b))
数组
[ 10 100 1000]
调用power
[ 100 10000 1000000]
第二个数组
[1 2 3]
再次调用power函数
[ 10 10000 1000000000]
numpy.mod()
计算输入数组中相应元素的相除后的余数, numpy.remainder()也产生相同的结果
import numpy as np
a = np.array([10,20,30])
b = np.array([3,5,7])
print ('调用mod')
print (np.mod(a,b))
print ('调用remainder')
print (np.remainder(a,b))
调用mod
[1 0 2]
调用remainder
[1 0 2]
参考教程:菜鸟教程
个人博客
numpy学习(二)