Py中的多维数组ndarray学习【转载】

转自：http://blog.sciencenet.cn/home.php?mod=space&uid=3031432&do=blog&id=1064033

1. NumPy中的N维数组ndarray基本介绍

- NumPy中基本的数据结构

- 所有元素是同一种类型

- 别名array（数组）

- 节省内存，提高CPU计算时间

- 有丰富的函数

注：NumPy的思维模式是面向数组。

2.ndarray数组属性

- 下标从0开始。

- 一个ndarray数组中的所有元素的类型必须相同。

- 轴（axis）：每一个线性的数组称为是一个轴，也就是维度（dimensions）。比如，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组，所以一维数组就是ndarray中的轴，第一个轴（也就是第0轴）相当于是底层数组，第二个轴（也就是第1轴）是底层数组里的数组。

很多时候可以声明axis。axis=0，表示沿着第0轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

- 秩（rank）：维数，一维数组的秩为1，二维数组的秩为2，以此类推。即轴的个数。

- 基本属性

ndarray1.ndim - 秩

ndarray1.shape - 维度 # 是一个元组，表示数组在每个维度上的大小。比如，一个二维数组，其维度表示“行数”和“列数”。该元组的长度即为秩。

ndarray1.size - 元素总个数 # 等于shape属性中元组元素的乘积。

ndarray1.dtype - 元素类型

ndarray1.itemsize - 元素字节大小 # 即元素所占内存空间大小，例如，元素类型为float64的数组的itemsiz属性值为8(=64/8)，元素类型为complex32的数组的itemsize属性为4(=32/8)。

ndarray1.data - 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

例如：以下5x5的数组，可以看成由5个一维数组构成，每个一维数组包含5个元素；第一维被称为第0轴（列），第二维被称为第1轴（行）；秩为2，维度为（5，5），元素总个数为25。

3.如何创建ndarray

3.1从已有数据-——从list、tuple

array() - 创建多维数组。

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

object — list或tuple对象。强制参数。

dtype — 数据类型。可选参数。

copy — 默认为True，对象被复制。可选参数。

order — 数组按一定的顺序排列。C - 按行；F - 按列；A - 如果输入为F则按列排列，否则按行排列；K - 保留按行和列排列。默认值为K。可选参数。

subok — 默认为False，返回的数组被强制为基类数组。如果为True，则返回子类。可选参数。

ndmin — 最小维数。可选参数。

注：array函数的参数必须是由方括号括起来的列表，而不能使用多个数值作为参数调用array。

>>> import numpy as np
>>> arr1=np.array([[1,2,3],[4.1,5.1,6.1]])
>>> arr1
array([[1. , 2. , 3. ],
       [4.1, 5.1, 6.1]])
>>> arr2=np.array([(1,2,3),(4.1,5.1,6.1)])
>>> arr2
array([[1. , 2. , 3. ],
       [4.1, 5.1, 6.1]])

//上述代码中1是由元祖创建，2是由列表创建。

3.2从字符串中读取 - fromstring()

fromstring() - 从字符串中读取数据，并将其转换为一维数组。

np.fromstring(string, dtype=float, count=-1, sep='')

string — 包含数据的字符串。强制参数。

dtype — 数据类型，默认为浮点型。可选参数。

count — 从左到右读取数据的个数。默认为-1，表示读取所有数据。可选参数。

sep — 分隔符。若不指定分隔符，或指定为空，则字符串包含的数据被解译为二进制数据，否则为带有小数的ASCII文本。可选参数。

>>> arr1=np.fromstring('1,2,3,4',dtype=int,sep=',')
>>> arr1
array([1, 2, 3, 4])
>>> arr2=np.fromstring('1 2 3 4',dtype=int,sep=' ')
>>> arr2
array([1, 2, 3, 4])

3.3从可迭代对象中读取 - fromiter()

fromiter() - 从可迭代对象中读取数据，并将其转换为一维数组。

np.fromiter(iterable, dtype, count=-1)

iterable — 可迭代对象。不能有嵌套。强制参数。

dtype — 数据类型。强制参数。

count — 表示从可迭代对象中读取的项目数。默认为-1，表示读取所有数据。可选参数。

>>> it=(x*x for x in range(5))
>>> it
<generator object <genexpr> at 0x000001B85AB17BA0>

>>> x*x for x in range(5)
SyntaxError: invalid syntax
>>> np.fromiter(it,float)
array([ 0.,  1.,  4.,  9., 16.])
>>> np.fromiter('',int)
array([1, 2, 3, 4])
>>> np.fromiter('1,2,3,4',int)#这样对于int是不可迭代的
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    np.fromiter('1,2,3,4',int)
ValueError: invalid literal for int() with base 10: ','

>>> np.fromiter((1,2,3,4),float)
array([1., 2., 3., 4.])

3.4以函数式创建 - fromfunction()

fromfunction() - 在每个坐标轴上执行函数表达式，用得到的数据创建数组。

np.fromfunction(function, shape, dtype)

function — 可调用的函数。必选参数。

shape — 要创建的数组的维度。其长度与函数参数的个数一致。必选参数。

dtype — 数据类型，默认为浮点型。可选参数。

//这里的x y，我是真的不太理解。为什么就得到这个了？

>>> np.fromfunction(f,(3,3))
(array([[0., 0., 0.],
       [1., 1., 1.],
       [2., 2., 2.]]), array([[0., 1., 2.],
       [0., 1., 2.],
       [0., 1., 2.]]))

3.5创建全1数组—— ones(), ones_like()

ones() - 创建给定形状的ndarray，并将数组中所有元素填充为1。

np.ones(shape, dtype=None, order='C')

shape — 维度。强制参数。

dtype — 数据类型。默认为np.float64。可选参数。

order — 数组按一定的顺序排列。C - 按行；F - 按列。默认值为C。可选参数。

ones_like() -  创建与参数数组形状和类型相同的ndarray，并将数组中所有元素填充为1。

np.ones_like(a, dtype=None, order='K', subok=True)

a — 给定的数组。其维度和数据类型决定着要创建的数组的属性。强制参数。

dtype — 数据类型。默认的“None”意为“a.dtype”。可选参数。

order — 数组按一定的顺序排列。C - 按行；F - 按列；A - 如果输入为F则按列排列，否则按行排列；K - 保留按行和列排列。默认值为K。可选参数。

subok — 默认为True，返回的数组被强制为子类数组。如果为False，则返回基类数组。可选参数。

>>> x=np.ones((5))
>>> x.ndim
1
>>> x.shape
(5,)
>>> np.ones((5,2),int)#参数shape
array([[1, 1],
       [1, 1],
       [1, 1],
       [1, 1],
       [1, 1]])
>>> a=np.array([[1,2,3],[4,5,6]])
>>> np.ones_like(a)
array([[1, 1, 1],
       [1, 1, 1]])
>>> np.ones((5,))#这两个都是创建一维的数组
array([1., 1., 1., 1., 1.])
>>> np.ones((5))#这两个都是创建一维的数组
array([1., 1., 1., 1., 1.])

3.6创建‘全0’数组 - zeros(), zeros_like()

zeros() - 创建给定形状的ndarray，并将数组中所有元素填充为0。

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

shape — 维度。强制参数。

dtype — 数据类型。默认为np.float64。可选参数。

order — 数组按一定的顺序排列。C - 按行；F - 按列。默认值为C。可选参数。

zeros_like() -  创建与参数数组形状和类型相同的ndarray，并将数组中所有元素填充为0。

np.zeros_like(a, dtype=None, order='K', subok=True)

a — 给定的数组。其维度和数据类型决定着要创建的数组的属性。强制参数。

dtype — 数据类型。默认的“None”意为“a.dtype”。可选参数。

order — 数组按一定的顺序排列。C - 按行；F - 按列；A - 如果输入为F则按列排列，否则按行排列；K - 保留按行和列排列。默认值为K。可选参数。

subok — 默认为True，返回的数组被强制为子类数组。如果为False，则返回基类数组。可选参数。

>>> np.zeros((5,2))
array([[0., 0.],
       [0., 0.],
       [0., 0.],
       [0., 0.],
       [0., 0.]])
>>> np.zeros_like(a)
array([[0, 0, 0],
       [0, 0, 0]])
#与创建全1数组相似

3.7创建空数组 - empty(), empty_like()

empty() - 返回一个没有初始化内存的数组，该数组是空的。

np.empty(shape, dtype=float, order='C')

shape — 维度。强制参数。

dtype — 数据类型。默认为np.float64。可选参数。

order — 数组按一定的顺序排列。C - 按行；F - 按列。默认值为C。可选参数。

empty_like() - 返回一个与给定数组的维度和数据类型相同的新数组。

np.empty_like(a, dtype=None, order='K', subok=True)

a — 给定的数组。其维度和数据类型决定着要创建的数组的属性。强制参数。

dtype — 数据类型。默认的“None”意为“a.dtype”。可选参数。

order — 数组按一定的顺序排列。C - 按行；F - 按列；A - 如果输入为F则按列排列，否则按行排列；K - 保留按行和列排列。默认值为K。可选参数。

subok — 默认为True，返回的数组被强制为子类数组。如果为False，则返回基类数组。可选参数。

>>> np.zeros((5,2))#创建0数组
array([[0., 0.],
       [0., 0.],
       [0., 0.],
       [0., 0.],
       [0., 0.]])
>>> np.zeros_like(a)
array([[0, 0, 0],
       [0, 0, 0]])
>>> np.full((2,3),4)#用数据填充
array([[4, 4, 4],
       [4, 4, 4]])
>>> np.full_like(a,2)
array([[2, 2, 2],
       [2, 2, 2]])
>>> np.empty((2,2))
array([[6.01347002e-154, 4.02456140e-066],
       [5.56435215e+141, 4.48505083e-308]])
>>> np.empty((2,2),int)#创建空数组，不会申请空间
array([[0, 0],
       [0, 0]])
>>> np.eye((2,3))#eye创建对角矩阵，它与其他的参数是不一样的，参数分别是 行，列。
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    np.eye((2,3))
  File "C:\Users\85937\AppData\Local\Programs\Python\Python36\lib\site-packages\numpy\lib\twodim_base.py", line 186, in eye
    m = zeros((N, M), dtype=dtype, order=order)
TypeError: 'tuple' object cannot be interpreted as an integer
>>> np.eye((2，3)

SyntaxError: invalid character in identifier
>>> np.eye(2,3)

array([[1., 0., 0.],
       [0., 1., 0.]])
>>> np.identity(3)#创建单位矩阵，只有一个整型，创建的是方阵。

array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
>>> 

4.改变数组形状

reshape() - 改变数组的形状。通过reshape生成的新数组和原始数组共用一个内存，也就是说，若更改其中数组的元素，另一个数组也将发生改变。

reshape(a, newshape, order='C')

ndarray1.reshape(newshape)

>>> a.reshape(3,2)#即当前数组的reshape函数

array([[1, 2],
       [3, 4],
       [5, 6]])
>>> a.reshape(3,2,order='F')#参数改为F，按列。不太明白这个是如何搞的

array([[1, 5],
       [4, 3],
       [2, 6]])
>>> a

array([[1, 2, 3],
       [4, 5, 6]])
>>> b=a.reshape(3,2)

>>> b

array([[1, 2],
       [3, 4],
       [5, 6]])
>>> b[2,1]=0#修改变形之后的b中的元素值，同样会改变a,两者共用的是一个存储空间

>>> a

array([[1, 2, 3],
       [4, 5, 0]])
>>> b

array([[1, 2],
       [3, 4],
       [5, 0]])
>>> np.reshape(a,2,3)

array([[1, 2, 3],
       [4, 5, 0]])
>>> b=np.reshape(a,(2,3))

>>> b

array([[1, 2, 3],
       [4, 5, 0]])
>>> b=np.reshape(a,(3,2))

>>> b

array([[1, 2],
       [3, 4],
       [5, 0]])
>>> b[2,1]=6#np.reshape效果也是一样的。

>>> b

array([[1, 2],
       [3, 4],
       [5, 6]])
>>> a

array([[1, 2, 3],
       [4, 5, 6]])

5创建等差数列数组

arange() - 创建一个一维的等差数列数组，与Python中的range()函数类似。区别在于，np.arange()返回的是一个numpy数组，而Python中的range()函数返回的是一个列表。

np.arange(start, stop, step步长, dtype=None)//这里的stop是取不到的

linspace() - 创建一个一维数组，在给定的区间上num等分。

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

stop — 区间终止值（是否取得到，需要设定参数endpoint）。强制参数。

>>> np.arange(3)

array([0, 1, 2])#取不到3
>>> range(3)

range(0, 3)#是一个list
>>> np.arange(1,5,2)

>>> np.arange(1,3.1,2)

array([1., 3.])
>>> np.linspace(1,5,2)

array([1., 5.])
>>> np.linspace(1,5,5)

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

6.数据切片与索引

一维数组

二维数组

//以切片方式索引，与 索引。

以数组索引：

第6行中的意思是A的[0,1]和[2,3]元素是什么?

第8行的意思是B中的[0,0]和[1,1]元素是什么?

也就是说前后两个数组长度一样，是两两对应的。

布尔型索引

神奇的布尔索引。

>>> B=np.arange(10).reshape(2,5)

>>> B

array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
>>> for row in B.T:
       print(row)

[0 5]
[1 6]
[2 7]
[3 8]
[4 9]
>>> for col in B.T:
       print(col)

[0 5]
[1 6]
[2 7]
[3 8]
[4 9]
>>> B.T

array([[0, 5],
       [1, 6],
       [2, 7],
       [3, 8],
       [4, 9]])

//这里对B的转置中，遍历行和遍历列都是一样的结果。

列出B中的元素：

转化为一维数组之后打印。B并未改变

最值索引

in5行中，参数1表示按行，in7中有0，表示按列索引。

注意返回的不是最值，而是最值的索引即下标。

7.ndarray的运算

加减乘除、点乘、乘方、整余数

以上的运算，在np中有相应的函数。

点乘就是矩阵乘法。