Numpy库详解(一)

Numpy库详解（一）

安装
在ubuntu中安装使用pip

pip install numpy 

安装验证
在UBUNTU终端下打开python3,输入以下代码：
以下实例均在python3中完成

from numpy import *
eye(4)

若输出以下对角举证，则安装成功

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

NumPy Ndarray 对象

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

ndarray 中的每个元素在内存中都有相同存储大小的区域。

ndarray 内部由以下内容组成：

一个指向数据（内存或内存映射文件中的一块数据）的指针。

数据类型或 dtype，描述在数组中的固定大小值的格子。

一个表示数组形状（shape）的元组，表示各维度大小的元组。

一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。

ndarray 的内部结构:

跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。

创建一个 ndarray 只需调用 NumPy 的 array 函数即可：

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

实例

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

输出

[1,2,3]

输出二维数组

import numpy as np
a=np.array([[2,3],[3,4]])
>>> print(a)
[[2 3]
 [3 4]]

实例3：最小维度

>>> a=np.array([1,2,3,4,5],ndmin=2)
>>> print(a)
[[1 2 3 4 5]]

实例4：dtype参数

>>> a=np.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]

Numpy数组属性

numpy数组的维度称为秩（rank），一维的称为1，二维的称为2，以此类推
在numpy中，每一个线性的维度称为一个轴(axis),也就是维度。比如说，二维数组相当于两个一维数组，其中第一个一位数组中每个元素又是一个一维数组，所以一维数组就是numpy中的轴（axis），第一个轴相当于是底层数组，第二个轴时底层数组里的数组。而轴的数量-秩，就是数组的维数。
很多时候可以声明axis，axis=0，表示沿着第另轴进行操作，即对每一列进行操作；axis=1，表示对每一行进行操作
numpy的数组中比较重要的ndarray对象属性有：

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n行m列
ndarray.size	数组元素的总个数，相当于.shape中的n*m的值
ndarray.dtype	ndarray对象的元素类型
ndarray.flags	ndarray元素的内存信息
ndarray.real	ndarray元素的实部
ndarray.imag	ndarray元素的虚部

ndarray.ndim 用于返回数组的维数，等于秩。
实例：

>>> import numpy as np
>>> a=np.arange(24)
>>> print(a)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
>>> print(a.ndim)
1
>>> b=a.reshape(2,4,3)
>>> a.reshape(2,4,3)
array([[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]],

       [[12, 13, 14],
        [15, 16, 17],
        [18, 19, 20],
        [21, 22, 23]]])
>>> print(b.ndim)
3

ndarray.shape表示数组的维度，返回一个元祖，这个元祖的长度就是维度的数目，即ndim的秩。比如，一个二维数组，其维度表示行数和列数。
实例

>>> import numpy as np
>>> a=np.array([[2,3,4],[3,4,5]])
>>> print(a.shape)
(2, 3)

调整数组的大小
实例：

>>> import numpy as np
>>> a=np.array([[2,3,4],[3,4,5]])
>>> print(a.shape)
(2, 3)
>>> a.shape=(3,2)
>>> print(a)
[[2 3]
 [4 3]
 [4 5]]
>>> print(a.shape)
(3, 2)
>>> b=a.reshape(2,3)
>>> print(b)
[[2 3 4]
 [3 4 5]]

numpy 创建数组

ndarray数组除了可以用底层ndarray构造器来创建外，也可以通过以下集中方法来创建
numpy.empty方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组

numpy.empty(shape,dtype=float,order='c')

参数说明

参数	描述
shape 数组形状
dtype	数据类型，可选
order	有C和F两个选项，分别代表行优先和列优先，在计算机内存中的存储元素的顺序

下面是一个创建空数组的元素的实例

>>> import numpy as np
>>> a=np.empty((3,4),dtype=int)
>>> print(a)
[[              0               1               1               0]
 [              0               0 139793554991216 139793554740592]
 [139793554769544 139793555226496 139793553981088             129]]

numpy.zeros
创建制定大小的数组，数组元素以0来填充

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

实例

>>> import numpy as np
>>> np.zeros(5)
array([0., 0., 0., 0., 0.])
>>> y=np.zeros((5,),dtype=np.int)
>>> print(y)
[0 0 0 0 0]
>>> np.zeros((2,2),dtype=np.int)
array([[0, 0],
       [0, 0]])

numpy.ones
创建指定形状的数组，数组元素以1来填充：

numpy.ones(shape,dtype=None,order='c')

>>> import numpy as np
>>> np.ones(5)
array([1., 1., 1., 1., 1.])
>>> np.ones((2,3),dtype=np.int)
array([[1, 1, 1],
       [1, 1, 1]])

Numpy从已有的数组创建数组
numpy.asarray 类似numpy.array，但numpy.asarray只有三个，比numpy.array少两个

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

实例
将列表转换为ndarray

>>> import numpy as np
>>> a=np.array([1,2,3])
>>> b=np.asarray(a)
>>> print(b)
[1 2 3]
>>> x=(1,2,3)
>>> print(np.asarray(x))
[1 2 3]

numpy.frombuffer用于实现动态数组。
numpy,frombuffer接受buffer输入参数，以流的形式读入转化成ndarray对象

numpy.frombuffer(buffer,dtype=float,dtypt=float,offset=0)
注意：buffer是字符串的时候，python3默认str时unicode类型，所以转成bytestring在原str前加上b。

>>> import numpy as np
>>> a=b'hello world'
>>> b=np.frombuffer(a,dtype='S1')
>>> print(b)
[b'h' b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'l' b'd']

numpy 从数值范围创建数组

numpy.arange
numpy包中使用arrange函数创建数字范围并返回ndarray对象，格式如下：

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

根据start与stop指定范围，step制定步长，生成一个ndarray。
参数说明

参数	描述
start	起始值，默认为0
stop	终止值（不包含终止值）
step	步长，默认为1
dtype	返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型

实例：
生成0到5的数组

>>> import numpy as np
>>> a=np.arange(6)
>>> print(a)
[0 1 2 3 4 5]

设置返回类型为float

>>> import numpy as np
>>> a=np.arange(6,dtype=float)
>>> print(a)
[0. 1. 2. 3. 4. 5.]

设置了初始值，终止值以及步长

>>> import numpy as np
>>> a=np.arange(10,20,2)
>>> print(a)
[10 12 14 16 18]

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

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

参数说明：

参数	描述
start	开始值
stop	序列的终止值，如果endpoint尾True，则值包含于数列中
num	要生成的等步长的样本数量，默认为50
endpoint	该值为true时，数列中包含stop的值，反之不包含
retstep	如果为True，生成的数组中会显示间距，反之则不显示
dtype	ndarray的数据类型

实例：

>>> import numpy as np
>>> a=np.linspace(5,10,5,endpoint=True,retstep=True)
>>> print(a)
(array([ 5.  ,  6.25,  7.5 ,  8.75, 10.  ]), 1.25)

>>> a=np.linspace(1,1,10,dtype=int)
>>> print(a)
[1 1 1 1 1 1 1 1 1 1]

>>> import numpy as np
>>> a=np.linspace(1,10,10,retstep=True)
>>> print(a)
(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
拓展
>>> b=np.linspace(1,10,10).reshape(10,1)
>>> print(b)
[[ 1.]
 [ 2.]
 [ 3.]
 [ 4.]
 [ 5.]
 [ 6.]
 [ 7.]
 [ 8.]
 [ 9.]
 [10.]]

numpy.logspace 函数用于创建一个等比数列，格式如下：

np.logspace(start,stop,num=50,endpoint=True,base=10.0,dtype=None)

base参数的意思是取对数的时候log的下标

参数	描述
start	序列的起始值为：base**start
stop	序列的终止值为：base**stop,如果endpoint为True,该值包含于序列中
num	要生成的等步长的样本数量，默认是50
base	对数log的底数
endpoint	该值为True则包含stop值，否则不包含
dtype	数据类型

实例：

>>> import numpy as np
>>> a=np.logspace(1.0,2.0,num=10,base=10)
>>> print(a)
[ 10.          12.91549665  16.68100537  21.5443469   27.82559402
  35.93813664  46.41588834  59.94842503  77.42636827 100.        ]

构造一个底数为2的数列

>>> import numpy as np 
>>> a=np.logspace(1,10,10,base=2)
>>> print(a)
[   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.]

numpy 切片和索引
ndarray对象的内容可以通过索引或切片来访问与修改，与python中list的切片操作一样
ndarray数组可以对0-n的下标进行索引，切片对象可以通过内置的slice函数，并设置start，stop以及step参数进行，从原数组中切出一个新数组

实例

>>> import numpy as np
>>> a=np.arange(8)
>>> b=slice(3,8,2)
>>> c=a[b]
>>> print(c)
[3 5 7]

以上实例中，我们首先通过arange()函数创建ndarray对象，然后分别设置起始值，终止值和步长的参数分别为3，8,2
我们也可以通过冒号分割切片参数start:stop:step来进行切片操作
实例：

>>> import numpy as np
>>> a=np.arange(10)
>>> b=a[2:8:3]
>>> print(b)
[2 5]

numpy高级索引

numpy比一般的python序列提供更多的索引方式，除了之前的用整数和切片索引外，数组可以有整数数组索引、布尔索引及花式索引。

整数数组索引

以下实例获取数组中(0,0),(1,1),(2,0)位置处的元素
实例：

>>> a=np.array([[1,2],[3,4],[5,6]])
>>> print('这是a')
这是a
>>> print(a)
[[1 2]
 [3 4]
 [5 6]]
>>> b=a[[0,1,2],[0,1,0]]
>>> print(b)
[1 4 5]

以下实例获取了4x3数组中的四个角的元素，行索引是[0,0]和[3,3],而列索引是[0,2]和[0,2]

 import numpy as np
 a=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
 print('这是a')
 print(a)
 print('\n')
 rows=np.array([[0,0],[3,3]])
 cols=np.array([[0,2],[0,2]])
 b=a[rows,cols]
 print('这个数组的四角元素为：')
 print(b)

输出结果为：

这是a
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]


这个数组的四角元素为：
[[ 1  3]
 [10 12]]

使用上例中的方法

>>> import numpy as np
>>> a=np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
>>> print(a)
[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
>>> b=a[[0,0,3,3],[0,2,0,2]]
>>> print(b)
[ 1  3 10 12]

布尔索引
我们可以通过一个布尔数组来索引目标数组
布尔索引通过布尔运算来获取指定条件的元素的数组
以下实例获取大于5的元素

>>> import numpy as np
>>> a=np.array([[2,3,4],[3,4,5],[6,7,8]])
>>> print(a)
[[2 3 4]
 [3 4 5]
 [6 7 8]]
>>> b=a[a>5]
>>> print(b)
[6 7 8]

以下是用了～（取补运算符）来过滤NaN

>>> import numpy as np
>>> a=np.array([np.nan,1,2,np.nan,3,4,5])
>>> b=a[~np.isnan(a)]
>>> print(b)
[1. 2. 3. 4. 5.]

numpy广播（broadcast）

广播（broadcast）是numpy对不同形状（shape）的数组进行数值运算的计算方式，对数组的算数晕眩通常在相应的元素上进行。
如果两个元素a和b的形状相同，即满足a.shape==b.shape,那么a*b的结果就是a与b相对应位相乘，这要求位数相同，且各维度的长度相同。
实例

>>> import numpy as np
>>> a=np.array([1,2,3])
>>> b=np.array([10,20,30])
>>> c=a*b
>>> print(c)
[10 40 90]

当运算中2个数组的形状不相同的时候，numpy自动触发广播机制
实例

>>> import numpy as np
>>> a=np.array([[1,2,3],[3,4,5],[5,6,7]])
>>> b=np.array([1,2,3])
>>> c=a+b
>>> print(c)
[[ 2  4  6]
 [ 4  6  8]
 [ 6  8 10]]

>>> import numpy as np
>>> a=np.array([[0,0,0],[10,20,30],[11,12,13]])
>>> b=np.array([1,2,3])
>>> bb=np.tile(b,(3,1))
>>> print(a+bb)
[[ 1  2  3]
 [11 22 33]
 [12 14 16]]

numpy数组操作
numpy数组中包含了一些函数用于处理数组，大概可以分为以下几类：

• 修改数组形状
• 翻转数组
• 修改数组维度
• 连接数组
• 分割数组
• 数组元素的添加与删除

修改数组形状

函数	描述
reshape	不改变数组的情况下修改形状
flat	数据元素迭代器
flatten	返回一份数组拷贝，对数组拷贝所做的修改不会影响原始数组
reval	返回展开数组

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(a)
[0 1 2 3 4 5 6 7]
>>> b=np.reshape(a,(4,2),order='A')
>>> print(b)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]

numpy.ndarray.flat是一个元素迭代器
实例

>>> import numpy as np
>>> a=np.arange(8).reshape(4,2)
>>> print(a)
[[0 1]
 [2 3]
 [4 5]
 [6 7]]
>>> for row in a:
...     print(row)
... 
[0 1]
[2 3]
[4 5]
[6 7]
>>> for element in a.flat:
...     print(element)
... 
0
1
2
3
4
5
6
7

numpy.ndarray.flatten
numpy.ndarray.flatten返回一份数组拷贝，对拷贝所做的修改不会影响原始数组

import numpy as np
a=np.arange(8).reshape(2,4)
print('原数组：')
print(a)
print('\n')
print('展开的数组')
b=a.flatten()
print(b)

输出结果为：

原数组：
[[0 1 2 3]
 [4 5 6 7]]


展开的数组
[0 1 2 3 4 5 6 7]

Numpy字符串函数
以下函数用于对dtype为numpy.string_或numpy.unicode_的数组执行向量化字符串操作。他们基于python内置库中的标准字符串函数。这些函数在字符窜数组类（numpy.char）中定义。

add()	对两个数组的逐个字符串元素进行连接
multipy()	返回按元素多重连接后的字符串
center()	居中字符串
capitialize()	将字符串第一个字母转换为大写
title（）	将字符串的每一个单词的每一个字母转换为大写
lower（）	将数组元素转换为小写
upper（）	将数组中的元素转换为大写
split（）	指定分隔符对字符窜进行分割，并返回数组列表
splitlines（）	返回元素中的行列表，以换行符分割
strip（）	移除元素开头或者结尾出的特定元素
join（）	通过指定分隔符来连接数组中的元素
replace()	使用新字符串代替字符串中的所有子字符串
decode（）	数组依次调用str.decode
encode()	数组依次调用str.encode

numpy.char.add()
numpy.char.add()函数依次对两个数组的元素进行字符串连接
实例

import numpy as np
print('连接两个字符串')
print(np.char.add(['连接'],['字符串']))

输出结果为：

连接两个字符串
['连接字符串']

numpy.char.multiply()
numpy.char.multiply()执行多重函数连接

>>> import numpy as np
>>> print(np.char.multiply('runoob',3))
runoobrunoobrunoob

numpy.char.center()
numpy.char.center()函数用于将字符串居中，并在指定字符串左边和右边进行填充
格式为：

numpy.char.center(str,width,fillchar)
str:字符串，width：长度，fillchar：填充字符

实例

>>> print(np.char.center('runoob',width=20,fillchar='*'))
*******runoob*******

numpy.char.capitalize()
numpy.char.capitalize()函数将字符串的第一个字幕转换为大写
实例

>>> import numpy as np
>>> print(np.char.capitalize('runoob'))
Runoob

numpy.char.title()
numpy.char.title()函数将字符串的每一个首字母转换为大写
实例

>>> import numpy as np
>>> print(np.char.title('hello world'))
Hello World

numpy.char.upper()
nummpy.char.upper()函数将字符串的元素全部转换为大写，他对每个元素调用str.upper()
实例

>>> import numpy as np
>>> print(np.char.upper('hello world'))
HELLO WORLD

numpy.char.lower()
numpy.char.lower()对字符窜中的每个元素进行小写，调用str.lower()
实例

>>> import numpy as np
>>> print(np.char.lower('HELLO WORLD'))
hello world

numpy.char.split()
numpy.char.split()函数通过制定分隔符对字符串进行分割,并返回数组。默认情况下分隔符为空格。
格式：

numpy.char.split(str,sep='')

实例

>>> import numpy as np
>>> print(np.char.split('hello world'))
['hello', 'world']
print(np.char.split('hello ! wold ', sep='!'))
['hello ', ' wold ']

numpy.char.splitlines()
numpy.char.splitlines()函数以换行符作为分隔符来分割字符串，并返回数组
实例

>>> import numpy as np
>>> print(np.char.splitlines('i \n love ruirui'))
['i ', ' love ruirui']

numpy.char.strip()
numpy.char.strip()函数用于移除开头或结尾处的特定字符
实例

>>> import numpy as np
>>> print(np.char.strip('ashok arundooda ','a' ))
shok arundooda 
>>> print(np.char.strip('ashok arundooda','a' ))
shok arundood

numpy.char.join()
numpy.char.join()函数通过自定分隔符来连接数组中的元素或字符串
实例

>>> import numpy as np
>>> print(np.char.join(':','hello world'))
h:e:l:l:o: :w:o:r:l:d
>>> print(np.char.join([':','|'],['hello','world']))
['h:e:l:l:o' 'w|o|r|l|d']

numpy.char.replace()
numpy.char.replace()函数使用新字符串替代子字符串中的所有字符
实例

>>> import numpy as np
>>> print(np.char.replace('hello world','ll','ii'))
heiio world

numpy.char.encode()
numpy.char.encode()函数对数组中的每一个元素调用str.encode函数，默认编码为utf-8，可以使用python库中的标准编解码器
实例：

>>> a=np.char.encode('hello','cp500')
>>> print(a)
b'\x88\x85\x93\x93\x96'
>>> b=np.char.decode(a,'cp500')
>>> print(b)
hello