NumPy学习笔记

Numpy笔记
基础
1、NumPy的主要对象：同种元素的多维数组。
2、在NumPy中维度(dimensions)叫做轴(axes)，轴的个数叫做秩(rank)。
例：[[ 1., 0., 0.],
 [ 0., 1., 2.]]
秩：2，第一个维度（对应竖轴）：2，第二个维度：3
例：
import numpy
a=arange(15).reshape(3,5)
print(a)
print(a.shape) #维度，这个元组的长度是秩。(3, 5)
print(a.ndim) #轴的个数。2
print(a.size) #15
print(type(a)) #<class 'numpy.ndarray'>
创建数组
1、使用array函数从常规的Python列表和元组创造数组。数组类型由原序列中的元素类型推导而来。
例：
import numpy
a=array([2,3,4]) #参数是列表或元组，而不是一组数字
print(a.dtype)  #输出：int32
b=array([1.2,2.3,3.4])
print(b.dtype)  #输出：float64
2、二维三维数组
a=array([(2,3,4),[5,6,7]])
3、指定数据类型
a=array([(2,3,4),[5,6,7]],dtype=complex)
array([[ 2.+0.j,  3.+0.j,  4.+0.j],
       [ 5.+0.j,  6.+0.j,  7.+0.j]])
4、使用占位符创建数组（1）创建一个全是0的数组。默认创建的数组类型(dtype)都是float64
a=zeros((3,4))
a
Out[28]:
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
（2）创建一个全1的数组
a=ones((3,4,4),dtype=int16) #可以指定类型
a
Out[30]:
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],
        [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)
（3）创建一个内容随机并且依赖与内存状态的数组
empty((2,4))
Out[32]:
array([[  0.00000000e+000,   5.94855038e-321,   2.47032823e-323,
          1.47675400e-311],
       [  0.00000000e+000,   2.47032823e-323,   1.47675399e-311,
          0.00000000e+000]])
5、创建一个数列，arange函数，返回数组
arange(2,5)
Out[53]: array([2, 3, 4])
打印数组
1、嵌套列表：
最后的轴从左到右打印；次后的轴从顶向下打印；剩下的轴从顶向下打印，每个切片通过一个空行与下一个隔开。
2、一维数组被打印成行，二维数组成矩阵，三维数组成矩阵列表。
3、如果一个数组用来打印太大了，NumPy自动省略中间部分而只打印角落
print(np.arange(1000))
[  0   1   2 ..., 997 998 999]
4、强制打印整个数组，设置printoptions参数来更改打印选项
np.set_printoptions(threshold='nan')
from numpy import *
set_printoptions(threshold=1000)
print(arange(1000))
基本运算
1、数组的算术运算是按元素的。
2、NumPy中的乘法运算符*指示按元素计算
import numpy as np
b = np.array( [[2,0],[3,4]] )
a = np.array( [[1,1],[0,1]] )
print(a*b)
输出：
[[2 0]
 [0 4]]
3、矩阵乘法可以使用dot函数实现
print(np.dot(a,b))
输出：
[[5 4]
 [3 4]]
4、+=和*=被用来更改已存在数组而不创建一个新的数组
import numpy as np
a=np.ones((2,3),dtype=int)
b=np.random.random((2,3))
a*=3
print(a)
b+=a
print(b)
a+=b  #b不能转换成int类型！！！
5、类型不同时，向上转换
import numpy as np
a=np.ones(3,dtype=np.int32)
b=np.linspace(0,np.pi,3)#从0至pi的三个数
c=a+b
print(c) #输出：[ 1.          2.57079633  4.14159265]
print(c.dtype.name) #输出：float64
d=np.exp(c*1j)#返回e的c*1j次方
print(d)
#输出：[ 0.54030231+0.84147098j -0.84147098+0.54030231j -0.54030231-0.84147098j]
print(d.dtype.name) #输出：comp.lex128 复数类型
6、sum,max,min
from numpy import *
a=random.random((2,3))
print(a.sum())
print(a.min())
print(a.max())
7、指定axis参数，把运算应用到数组指定的轴上
from numpy import *
b=arange(12).reshape(3,4)
print(b)
输出：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
#指定axis参数,把运算应用到数组指定的轴上
print(b.sum(axis=0))
输出：
[12 15 18 21]  #横轴上的和
print(b.min(axis=1))
输出：
[0 4 8] #最小的一个竖轴
通用函数
NumPy提供常见的数学函数如sin,cos和exp。在NumPy中，这些叫作“通用函数”(ufunc)。在NumPy里这些函数作用按数组的元素运算，产生一个数组作为输出
from numpy import *
b=arange(3)
print(b)
输出：[0 1 2]
print(exp(b))
输出：[ 1.          2.71828183  7.3890561 ]
print(sqrt(b))
输出：[ 0.          1.          1.41421356]
c=array([2.,3.,-4.])
print(add(b,c))
输出：[ 2.  4. -2.]
索引，切片和迭代
1、一维数组可以被索引、切片和迭代，就像列表和其它Python序列。
from numpy import *
a=arange(10)**3
print(a)
输出：[  0   1   8  27  64 125 216 343 512 729]
#索引
print(a[2])
输出：8
#切片
print(a[2:5])
输出：[ 8 27 64]
a[:6:2]=400#在[0,6)，从0开始+2的位置=400
print(a)
输出：[400   1 400  27 400 125 216 343 512 729]
print(a[ : :-1])#倒序输出，不改变原数组
输出：[729 512 343 216 125 400  27 400   1 400]
#遍历
for i in a:
print(i**(1/3))
输出：
7.36806299728
1.0
7.36806299728
3.0
7.36806299728
5.0
6.0
7.0
8.0
9.0
2、多维数组的这些索引由一个逗号分割的元组给出。
from numpy import *
def f(x,y):
    return 10*x+y
#根据函数创建数组
b=fromfunction(f,(5,4),dtype=int)
print(b)
输出：
[[ 0  1  2  3]
 [10 11 12 13]
 [20 21 22 23]
 [30 31 32 33]
 [40 41 42 43]]
print(b[2,3])#类似于数组a[2][3]
输出：23
print(b[0:5,1])#从第一行至第四行，列为1
输出：[ 1 11 21 31 41]
print(b[:,1])#:即所有
输出：[ 1 11 21 31 41]
print(b[1:3,:])
输出：
[[10 11 12 13]
 [20 21 22 23]]
#当少于轴数的索引被提供时，确失的索引被认为是整个切片
print(b[-1])
输出：[40 41 42 43]
3、迭代多维数组是就第一个轴而言的。
？
如果一个人想对每个数组中元素进行运算，我们可以使用flat属性，该属性是数组元素的一个迭代器
from numpy import *
def f(x,y):
    return 10*x+y
#根据函数创建数组
b=fromfunction(f,(5,4),dtype=int)
for row in b:
    print(row)
for element in b.float:
print(element)
 
形状操作
更改数组的形状
from numpy import *
a=floor(10*random.random((3,4)))
print(a)
输出：
[[ 1.  1.  6.  4.]
 [ 8.  1.  3.  5.]
 [ 2.  2.  1.  5.]]
print(a.shape)
输出：
(3, 4)
b=a.ravel()#展平为一维数组，返回创建的一个数组
print(b)
输出：[ 1.  1.  6. ...,  2.  1.  5.]
a.shape=(6,2)#改变数组形状，改变本身
print(a)
输出：
[[ 1.  1.]
 [ 6.  4.]
 [ 8.  1.]
 [ 3.  5.]
 [ 2.  2.]
 [ 1.  5.]]
b=a.transpose()#转置矩阵，返回创建的一个数组
print(b)
输出：
[[ 1.  6.  8.  3.  2.  1.]
 [ 1.  4.  1.  5.  2.  5.]]
a.resize((2,6))#改变数组本身
print(a)
输出：
[[ 1.  1.  6.  4.  8.  1.]
 [ 3.  5.  2.  2.  1.  5.]]
b=a.reshape((3,4))#改变参数情况，并返回
print(b)
输出：
[[ 1.  1.  6.  4.]
 [ 8.  1.  3.  5.]
 [ 2.  2.  1.  5.]]
 
 
组合(stack)不同的数组
1、
？函数column_stack以列将一维数组合成二维数组，它等同与vstack对一维数组。
vstack()：合并产生新行,即延列合并
hstack()：合并产生新列，即延行合并
column_stack：合并产生新列，即延行合并
 
from numpy import *
a=floor(10*random.random((2,2)))
print(a)
输出：
[[ 9.  6.]
 [ 4.  7.]]
b=floor(10*random.random((2,2)))
print(b)
输出：
[[ 6.  5.]
 [ 5.  0.]]
print(vstack((a,b)))#合并产生新行,即延列合并
输出：
[[ 9.  6.]
 [ 4.  7.]
 [ 6.  5.]
 [ 5.  0.]]
print(hstack((a,b)))#合并产生新列，即延行合并
输出：
[[ 9.  6.  6.  5.]
 [ 4.  7.  5.  0.]]
print(column_stack((a,b)))#合并产生新列
输出：
[[ 9.  6.  6.  5.]
 [ 4.  7.  5.  0.]]
a=array([4.,2.])
print(a)
输出：
[ 4.  2.]
b=array([2.,8.])
print(b)
输出：
[ 2.  8.]
print(a[:,newaxis])#改变为二维数组
输出：
[[ 4.]
 [ 2.]]
print(column_stack((a[:,newaxis],b[:,newaxis])))
输出：
[[ 4.  2.]
 [ 2.  8.]]
print(vstack((a[:,newaxis],b[:,newaxis])))
输出：
[[ 4.]
 [ 2.]
 [ 2.]
 [ 8.]]
2、对那些维度比二维更高的数组，hstack沿着第二个轴组合，vstack沿着第一个轴组合,concatenate允许可选参数给出组合时沿着的轴。
3、在复杂情况下，r_[]和c_[]对创建沿着一个方向组合的数很有用，它们允许范围符号(“:”)from numpy import *r=r_[1:5,8,9]#按行创建数组print(r)输出：[1 2 3 4 8 9]将一个数组分割(split)成几个小数组hsplit()：沿着它的水平轴分割vsplit()：沿着纵向的轴分割array split：允许指定沿哪个轴分割from numpy import *a=floor(10*random.random((2,12)))print(a)输出：[[ 6.  5.  8. ...,  8.  5.  1.] [ 9.  5.  7. ...,  8.  2.  2.]]print(hsplit(a,3))#分成3个相同形状的数组输出：[array([[ 6.,  5.,  8.,  3.],       [ 9.,  5.,  7.,  2.]]), array([[ 2.,  7.,  4.,  1.],       [ 0.,  9.,  1.,  0.]]), array([[ 6.,  8.,  5.,  1.],       [ 8.,  8.,  2.,  2.]])]print(hsplit(a,(3,4)))#在下标为3和4的列分开输出：[array([[ 6.,  5.,  8.],       [ 9.,  5.,  7.]]), array([[ 3.],       [ 2.]]), array([[ 2.,  7.,  4., ...,  8.,  5.,  1.],       [ 0.,  9.,  1., ...,  8.,  2.,  2.]])] 复制和视图