01 numpy库(一)

时间 2019-12-12

标签 numpy 繁體版

原文原文链接

01-numpy

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

NumPy 是一个运行速度很是快的数学库，主要用于数组计算，包含：
    1. 一个强大的N维数组对象 ndarray
    2. 广播功能函数
    3. 整合 C/C++/Fortran 代码的工具
    4. 线性代数、傅里叶变换、随机数生成等功能

02-数据属性

NumPy的主要对象是同种元素的多维数组。它是一个元素表（一般是数字），都是相同的类型，由正整数元组索引。在NumPy维度中称为轴。

例如，3D空间中的点的坐标具备一个轴。该轴有3个元素，因此咱们说它的长度为3。
而[[ 1., 0., 0.], [ 0., 1., 2.]]则有两个轴，第一个轴的长度为2，第二个轴的长度为3。

Numpy数组类的名字叫作ndarray，常常简称为array。
要注意将numpy.array与标准Python库中的array.array区分开，后者只处理一维数组，而且功能简单。[1, 2, 1]

NumPy的数组类被调用ndarray。也被称为 array。
请注意，numpy.array这与标准Python库类不一样array.array，后者只处理一维数组并提供较少的功能。

ndarray对象的属性是：
· ndarray.ndim：数组的轴数(维度)
· ndarray.shape：数组的形状(大小)。这是一个整数元组。好比对于n行m列的矩阵，其shape形状就是(n,m)。而shape元组的长度则偏偏是上面的ndim值，也就是轴数。
· ndarray.size：数组中全部元素的个数。这刚好等于shape中元素的乘积n*m。
· ndarray.dtype：数组中元素的数据类型。除了标准的Python类型，Numpy还提供一些自有的类型。如 numpy.int32, numpy.int16, numpy.float64。
· ndarray.itemsize：数组中每一个元素的大小(以字节为单位)。好比float64类型有itemsize为8（=64/8），而complex32的itemsize为4（=32/8）。
· ndarray.data：包含数组实际元素的缓冲区。一般咱们不须要使用这个属性，由于咱们将使用索引工具访问数组中的元素。
· ndarray.flags: 数组对象的一些状态指示或标签

什么是数组的维度？
NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每个线性的数组称为是一个轴（axis），也就是维度（dimensions）。
好比说，二维数组至关因而两个一维数组，其中第一个一维数组中每一个元素又是一个一维数组。
因此一维数组就是 NumPy 中的轴（axis），第一个轴至关因而底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

怎么能看出数组的轴数？
简单来说：就是看数组 嵌套了几层中括号 []。

建立一个 ndarray 只需调用 NumPy 的 array 函数便可：数组

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

# 案例
>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<type 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<type 'numpy.ndarray'>

03-数据类型

numpy 支持的数据类型比 Python 内置的类型要多不少，基本上能够和 C 语言的数据类型对应上，其中部分类型对应为 Python 内置的类型。下表列举了经常使用 NumPy 基本类型。安全

名称                 描述
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 位浮点数（实数部分和虚数部分）

数据类型对象(dtype)函数

数据类型对象是用来描述与数组对应的内存区域如何使用
· 数据的类型（整数，浮点数或者 Python 对象）
· 数据的大小（例如， 整数使用多少个字节存储）
· 数据的字节顺序（小端法或大端法）
· 在结构化类型的状况下，字段的名称、每一个字段的数据类型和每一个字段所取的内存块的部分
· 若是数据类型是子数组，它的形状和数据类型

numpy.dtype(object, align, copy)
· object - 要转换为的数据类型对象
· align - 若是为 true，填充字段使其相似 C 的结构体。
· copy - 复制 dtype 对象 ，若是为 false，则是对内置数据类型对象的引用

04-建立数组

ndarray 数组除了可使用底层 ndarray 构造器来建立外，也能够经过如下几种方式来建立。工具

使用array方法，并提供标准的Python列表或者元组做为参数。此时，数组的类型将根据序列中元素的类型推导出来。ui

>>> import numpy as np
>>> a = np.array([2,3,4])
>>> a
array([2, 3, 4])
>>> a.dtype
dtype('int64')
>>> b = np.array([1.2, 3.5, 5.1])
>>> b.dtype
dtype('float64')

常见的错误是直接将多个数值做为参数传递，正确的作法是将他们以列表或元组的方式传递，以下：spa

>>> a = np.array(1,2,3,4)    # 错误
>>> a = np.array([1,2,3,4])  # 正确

array函数会自动将二维或三维序列转换为对应的二维或三维数组。code

>>> b = np.array([(1.5,2,3), (4,5,6)])
>>> b
array([[ 1.5,  2. ,  3. ],
       [ 4. ,  5. ,  6. ]])

也能够在建立的时候，能够显式地指定数据的类型：对象

>>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
>>> c
array([[ 1.+0.j,  2.+0.j],
       [ 3.+0.j,  4.+0.j]])

一般，数组的元素最初是未知的，但其大小是已知的。所以，NumPy提供了几个函数来建立具备初始占位符内容的数组。blog

函数zero建立一个都是0的数组，函数one建立一个都是1的数组，函数empty建立一个初始内容是0或者垃圾值的数组，这取决于内存当时的状态。默认状况下，建立的数组的数据类型为float64。索引

>>> np.zeros( (3,4) )
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> np.ones( (2,3,4), dtype=np.int16 )                # 一样能够指定类型
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int16)
>>> np.empty( (2,3) )                                 # 根据当前内存状态的不一样，可能会返回未初始化的垃圾数值，不安全。
array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
       [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

>>> np.full((3,4), 2.22) # 建立一个所有由2.22组成的数组
array([[2.22, 2.22, 2.22, 2.22],
       [2.22, 2.22, 2.22, 2.22],
       [2.22, 2.22, 2.22, 2.22]])

为了建立数字序列，NumPy提供了一个相似于range返回数组而不是列表的函数 arange 。

>>> np.arange( 10, 30, 5 )
array([10, 15, 20, 25])
>>> np.arange( 0, 2, 0.3 )        # 能够接受浮点类型的参数，好比这里的步长
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

numpy.arange(start, stop, step, dtype)
· start：范围的起始值，默认为0
· stop： 范围的终止值（不包含）
· step： 两个值的间隔，默认为1
· dtype： 返回ndarray的数据类型，若是没有提供，则会使用输入数据的类型。

当arange函数使用浮点步长的时候，精度肯能出现问题。这种状况下，咱们通常使用linspace函数，它的第三个参数指定在区间内均匀生成几个数，至于步长，系统会自动计算。

>>> from numpy import pi  # 导入圆周率
>>> np.linspace( 0, 2, 9 )                 # 从0到2之间的9个数
array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
>>> x = np.linspace( 0, 2*pi, 100 )        # 从0到2Π之间，生成100个数
>>> f = np.sin(x)

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

· start： 序列的起始值
· stop： 序列的终止值，若是endpoint为True，则终止值包含于序列中
· num： 要生成的等间隔样例数量，默认为50
· endpoint： 序列中是否包含stop值，默认为Ture
· retstep： 若是为True，返回样例以及连续数字之间的步长
· dtype： 输出ndarray的数据类型