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.]])]

 

复制和视图