Numpy - nadrray创建

对于内容的引用说明：

数组的创建：http://www.zmonster.me/2016/02/25/creation-and-io-of-ndarray.html，感谢ZMonster's Blog原创内容。

1.ndarray数组的创建方法

1. 从Python中的列表、元组、列表元祖混合等类型创建ndarray数组： np.array(list,tuple)
2. 从字节流（raw bytes）中创建ndarray数组。
3. 从文件中读取特定格式中创建ndarray数组。
4. 来自现有数组创建数组。
5. 使用NumPy中函数创建ndarray数组：

【 注：在实际使用的时候多采用第一点、第四点和第五点来创建ndarray数组。实际上数组创建的方式还有很多，在此不一一列举】

2.常用函数方法总结

• arange、linspace与logspace

  1. arange函数类似python中的range函数，通过指定初始值、终值以及步长（默认步长为1）来创建数组；

  2. linspace函数通过指定初始值、终值以及元素个数来创建一维数组；

  3. logspace函数与linspace类似，只不过它创建的是一个等比数列，同样的也是一个一维数组；

• ones与zeros系列函数

  某些时候，我们在创建数组之前已经确定了数组的维度以及各维度的长度。这时我们就可以使用numpy内建的一些函数来创建ndarray。例如：函数ones创建一个全1的数组、函数zeros创建一个全0的数组、函数empty创建一个内容随机的数组，在默认情况下，用这些函数创建的数组的类型都是float64，若需要指定数据类型，只需要闲置dtype参数即可。

• fromstring与fromfunction

  fromstring函数从字符串中读取数据并创建数组；

  fromfunction函数由第一个参数作为计算每个数组元素的函数（函数对象或者lambda表达式均可），第二个参数为数组的形状。

3.创建数组

3.1从已有数据中创建

• 从 list, tuple 对象中创建:

import numpy as np

a= np.array([1, 2, 3, 4])
print('a is:', a)

b = np.array((1, 2, 3, 4))
print('b is:', b)

a is: [1 2 3 4]

b is: [1 2 3 4]

• 从文件中创建(关于文件操作使用pandas库):

  从文件中读取的方法有:fromfile,load, *loadtxt*。其中 fromfile 方法不建议使用，因为 fromfile 读取的文件要求是用 tofile 保存的，而 tofile 方法保存数据到文件时的具体行为是和具体平台有关的。

  load 方法读取 save 方法保存下来的二进制文件:

from tempfile import TemporaryFile
origin_array = np.array([1, 2, 3, 4])
np.save('/tmp/array', origin_array)
array_from_file = np.load('/tmp/array.npy')
print array_from_file

再来看一下 /tmp/array.txt 里面的内容:

cat /tmp/array.txt

1.000000000000000000e+00
2.000000000000000000e+00
3.000000000000000000e+00
4.000000000000000000e+00

• 从字符串中读取:

用fromstring方法可以从字符串中读取数据并转换为一维数组:

array = np.fromstring('1 2 3 4', dtype=float, sep=' ')
print(array)

[ 1.  2.  3.  4.]

如果是用tostring将一个多维向量转换为字符串，然后再用 fromstring 读取，也只能得到一个一维数组。另外如果是读用 tostring 转换成的字符串，建议使用 fromstring 的时候显式指定数组中元素的数据类型，不然就有可能发生下面这样的悲剧:

array = np.array([1, 2, 3, 4], dtype=int)
print(np.fromstring(array.tostring()))

[  4.94065646e-324   9.88131292e-324   1.48219694e-323   1.97626258e-323]

• fromiter 从可迭代对象中生成一维数组:

• 只能返回一维数组

• 必须显式指定数组中元素的数据类型

• 输入可以是所有可迭代对象，包括 ：list、tuple、string、unicode, generator，但需要注意的是，这里的 list 和 tuple 不能有嵌套。

# coding: utf-8
import numpy as np


def count_generator():
    for i in range(4):
        yield i

print('from list:', np.fromiter([1, 2, 3, 4], int))
print('from tuple:', np.fromiter((1, 2, 3, 4), int))
print('from string:', np.fromiter('1234', int))
print('from unicode:', np.fromiter(u'白日依山尽', 'U1'))
print('from generator:', np.fromiter(count_generator(), int))

#输出

from list: [1 2 3 4]
from tuple: [1 2 3 4]
from string: [1 2 3 4]
from unicode: ['白' '日' '依' '山' '尽']
from generator: [0 1 2 3]

3.2 创建特定形状的多维数组并进行填充

• ones：创建给定形状的多维数组并将数组中所有元素填充为 1:

print(np.ones((3, 4)))

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

• zeros：类似 ones ，但用 0 进行填充:

print(np.zeros((3, 4)))

[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]

• empty：类似 ones, 但不进行初始化，得到的多维数组中的元素值是不确定的。

print(np.empty((3, 4)))

[[  6.93164023e-310   1.66900197e-316   4.64956088e-317   4.00193173e-322]
 [  1.77481898e-316   6.93164023e-310   9.30845863e-039   2.42092166e-322]
 [  6.93164023e-310   6.93164023e-310   4.68423639e-320   0.00000000e+000]]

• full：类似 ones, 但需要自己手动指定需为多维数组填充的值。

print(np.full((3, 4), 17))

 [[ 17.  17.  17.  17.]
 [ 17.  17.  17.  17.]
 [ 17.  17.  17.  17.]]

3.3从 arange 创建多维数组

• arange：创建一个一维的数组，用法同 Python 内建方法range:

    `numpy.arange(start, stop, step, dtype)`
  

  构造器接受下列参数：

  | 序号 | 参数及描述 | | :--- | :--- | | 1. | start范围的起始值，默认为0 | | 2. | stop范围的终止值（不包含） | | 3. | step两个值的间隔，默认为1 | | 4. | dtype返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |

  下面的例子展示了如何使用该函数：

### 示例 1 {#示例-1}
import numpy as np
x = np.arange(5)
print(x)

[0 1 2 3 4]

### 示例 2 {#示例-2}
#设置了 dtype
x = np.arange(5, dtype =  float)
print(x)

[0.  1.  2.  3.  4.]

• linspace：给定一个区间，取其 N 等分点组成一个一维数组:

  numpy.linspace(start, stop, num, endpoint, retstep, dtype)

  此函数类似于arange()函数。 在此函数中，指定了范围之间的均匀间隔数量，而不是步长。 此函数的用法如下。

  构造器接受下列参数：

  | 序号 | 参数及描述 | | :--- | :--- | | 1. | start序列的起始值 | | 2. | stop序列的终止值，如果endpoint为true，该值包含于序列中 | | 3. | num要生成的等间隔样例数量，默认为50 | | 4. | endpoint序列中是否包含stop值，默认为ture | | 5. | retstep如果为true，返回样例，以及连续数字之间的步长 | | 6. | dtype输出ndarray的数据类型 |

  下面的例子展示了linspace函数的用法。

### 示例 1 {#示例-1}
import numpy as np
x = np.linspace(10,20,5)
print(x)

##输出如下：
# [10.   12.5   15.   17.5  20.]

### 示例 2 {#示例-2}
#将 endpoint 设为 false
import numpy as np
x = np.linspace(10,20, 5, endpoint = False)
print(x)

#输出如下：
#[10. 12. 14. 16. 18.]

### 示例 3 {#示例-3}
#输出 retstep 值
import numpy as np
x = np.linspace(1,2,5, retstep = True)
print(x)

#这里的 retstep 为 0.25
#输出如下：
# (array([ 1. , 1.25, 1.5 , 1.75, 2. ]), 0.25)

• logspace：给定一个对数尺度(log scale)区间，取其 N 等分点对应的线性尺度(linear scale)上的数值:

  numpy.logscale(start, stop, num, endpoint, base, dtype)

  此函数返回一个ndarray对象，其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂，通常为 10。

  logspace函数的输出由以下参数决定：

  | 序号 | 参数及描述 | | :--- | :--- | | 1. | start起始值是base ** start | | 2. | stop终止值是base ** stop | | 3. | num范围内的数值数量，默认为50 | | 4. | endpoint如果为true，终止值包含在输出数组当中 | | 5. | base对数空间的底数，默认为10 | | 6. | dtype输出数组的数据类型，如果没有提供，则取决于其它参数 |

  下面的例子展示了logspace函数的用法。

### 示例 1 {#示例-1}
import numpy as np
#默认底数是 10
a = np.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.    ]

### 示例 2 {#示例-2}
## 将对数空间的底数设置为 2
import numpy as np
a = np.logspace(1,10,num = 10, base = 2)
print(a)

#输出如下：
#[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]

3.4 numpy.array创建数组

它从任何暴露数组接口的对象，或从返回数组的任何方法创建一个ndarray。

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

上面的构造器接受以下参数：

| 序号 | 参数及描述 |
| :--- | :--- |
| 1. | `object`任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列。 |
| 2. | `dtype`数组的所需数据类型，可选。 |
| 3. | `copy`可选，默认为`true`，对象是否被复制。 |
| 4. | `orderC`（按行）、`F`（按列）或`A`（任意，默认）。 |
| 5. | `subok`默认情况下，返回的数组被强制为基类数组。 如果为`true`，则返回子类。 |
| 6. | `ndimin`指定返回数组的最小维数。 |

看看下面的例子来更好地理解。

#### 示例 1
import numpy as np
a = np.array([1,2,3])
print(a)

#输出如下：
#[1, 2, 3]

#### 示例 2

#多于一个维度
import numpy as np
a = np.array([[1,  2],  [3,  4]])
print(a)

# 输出如下：
#[[1, 2]
# [3, 4]]

#### 示例 3
#最小维度
import numpy as np
a = np.array([1, 2, 3,4,5], ndmin = 2)
print(a)
#输出如下：
#[[1, 2, 3, 4, 5]]

##### 示例 4
#dtype 参数
import numpy as np
# 后续会详细讲解dtype各种属性的含义
a = np.array([1, 2, 3], dtype = complex)
print(a)
#输出如下：
#[ 1.+0.j, 2.+0.j, 3.+0.j]

3.5 列表转换函数asarray

此函数类似于numpy.array，除了它有较少的参数。 这个例程对于将 Python 序列转换为ndarray非常有用。

numpy.asarray(a, dtype = None, order = None)

构造器接受下列参数：

| 序号 | 参数及描述 |
| :--- | :--- |
| 1. | `a`任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表 |
| 2. | `dtype`通常，输入数据的类型会应用到返回的`ndarray` |
| 3. | `order'C'`为按行的 C 风格数组，`'F'`为按列的 Fortran 风格数组 |

下面的例子展示了如何使用`asarray`函数：

### 示例 1 {#示例-1}
import numpy as np
x =  [1,2,3]
a = np.asarray(x)
print(a)
#输出如下：
#[1  2  3]

### 示例 2 {#示例-2}
#设置了 dtype
import numpy as np
x = [1,2,3]
a = np.asarray(x, dtype = float)
print(a)
#输出如下：
#[ 1. 2. 3.]

### 示例 3 {#示例-3}
#来自元组的 ndarray
import numpy as np
x =  (1,2,3)
a = np.asarray(x)
print(a)
#输出如下：
#[1  2  3]

### 示例 4 {#示例-4}
x =  [(1,2,3),(4,5)]
a = np.asarray(x)
print(a)
#输出如下：
#[(1, 2, 3) (4, 5)]

3.6使用 range 函数创建列表对象

### 示例 1 {#示例-1}
import numpy as np
list = range(5)
print(list)
#输出如下：range(0, 5),实质就是0,1,2,3,4
#[0, 1, 2, 3, 4]

3.7 使用迭代器创建 ndarray

### 示例 2 {#示例-2}
#从列表中获得迭代器
import numpy as np
list = range(5)
it = iter(list)
x = np.fromiter(it, dtype = float)
print(x)
#输出如下：
#[0. 1. 2. 3. 4.]

3.8 使用坐标向量创建 ndarray

• meshgrid：根据给定的坐标向量创建坐标矩阵

import numpy as np
print(np.meshgrid(np.arange(0, 6)))
#输出 [array([0, 1, 2, 3, 4, 5])]

x, y = np.meshgrid(np.arange(-1, 2), np.arange(0, 2))
print('x is:', x)

print('\ny is:', y) 

print('\npoints built by (x, y):')
print(np.rec.fromarrays([x, y]))

#输出：
x is: [[-1  0  1]
 [-1  0  1]]

y is: [[0 0 0]
 [1 1 1]]

points built by (x, y):
[[(-1, 0) ( 0, 0) ( 1, 0)]
 [(-1, 1) ( 0, 1) ( 1, 1)]]

在上面的例子中，所得到的是 X 轴上 [-1, 0, 1] 和 Y轴上 [0, 1] 构成的一个 3x2 的网格，共有 6 个点。返回的两个值中的 x 是这 6 个点 在 X 轴上的投影， y 则是这 6 个点在 y 轴上的投影。

meshgrid 方法的参数数量不受限，可以得到任意 N 维空间中的坐标矩阵。

了解 meshgrid 方法的功能后，可以来做一些有趣的事情，后续使用会在matplotlib库中涉及到。

• mgrid：mgrid 的功能与 meshgrid 类似，但有几点不同:

• [ ] mgrid 不是函数，而是一个类的对象

• [ ] mgrid 和 meshgrid 的使用方式不一样，meshgrid 需要传入一维数组作为对象，而 mgrid 则直接使用 '[]' 运算符

import numpy as np

np.meshgrid(np.arange(-1, 2), np.arange(-1, 2))
np.mgrid[-1:2, -1:2]

array([[[-1, -1, -1],
        [ 0,  0,  0],
        [ 1,  1,  1]],

       [[-1,  0,  1],
        [-1,  0,  1],
        [-1,  0,  1]]])

• [ ] 返回值的前两个顺序相反

import numpy as np

x, y = np.meshgrid(np.arange(-1, 1), np.arange(-1, 1))
xx, yy = np.mgrid[-1:1, -1:1]
print ((x - yy).sum(), (y - xx).sum())

x, y, z = np.meshgrid(np.arange(-1, 1), np.arange(-1, 1), np.arange(-1, 1))
xx, yy, zz = np.mgrid[-1:1, -1:1, -1:1]
print ((x - yy).sum(), (y - xx).sum(), (z - zz).sum())

x, y, z, w = np.meshgrid(np.arange(-1, 1), np.arange(-1, 1), np.arange(-1, 1), np.arange(-1, 1))
xx, yy, zz, ww = np.mgrid[-1:1, -1:1, -1:1, -1:1]
print ((x - yy).sum(), (y - xx).sum(), (z - zz).sum(), (w - ww).sum())

0 0
0 0 0
0 0 0 0

• ogrid：

  ogrid 与 mgrid 类似，也是类的对象而非函数，但和 mgrid 的不同之处在于，它返回的结果是稀疏的，既在每一个维度上是一个一维数组。

import numpy as np

x, y = np.mgrid[-1:2, 3:6]
print('x from mgrid:')
print(x)
print('y from mgrid:')
print(y)

x, y = np.ogrid[-1:2, 3:6]
print('x from ogrid:')
print(x)
print('y from ogrid:')
print(y)

x from mgrid:
[[-1 -1 -1]
 [ 0  0  0]
 [ 1  1  1]]
y from mgrid:
[[3 4 5]
 [3 4 5]
 [3 4 5]]
x from ogrid:
[[-1]
 [ 0]
 [ 1]]
y from ogrid:
[[3 4 5]]

• 3.9 fromfunction函数创建数组

fromfunction 的行为稍微有点不一样，它有三个参数:

1. function
2. shape
3. dtype(optional)

其中 function 的参数个数要和 shape 的长度一致，fromfunction 会对 shape 对应的多维数组中每个元素的坐标传给 function ，然后将返回值组合起来。

import numpy as np

def f(x, y):
 return (x, y)

def g(x, y):
 return x + y

x, y = np.fromfunction(f, (3, 3))
print('x generated by f is:\n', x)
print('y generated by f is:\n', y)
print('array generated by g is:\n', np.fromfunction(g, (3, 3)))

x generated by f is:
 [[ 0.  0.  0.]
 [ 1.  1.  1.]
 [ 2.  2.  2.]]
y generated by f is:
 [[ 0.  1.  2.]
 [ 0.  1.  2.]
 [ 0.  1.  2.]]
array generated by g is:
 [[ 0.  1.  2.]
 [ 1.  2.  3.]
 [ 2.  3.  4.]]