numpy库

Numpy简介： NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩阵(matrix))。

1：首次使用numpy之前要导包 import numpy as np ,如果没有下载过numpy库，可以在Linux里面通过pip install numpy来下载

2：使用numpy创建矩阵

1.使用np.array()由Python list创建

注意：numpy默认为ndarray的所有元素的类型是相同的

如果传进来的列表中包含不同的类型，则统一为同一类型，优先级：str>float>int

创建一维和二维的数组

>>> n1=np.array([3,1,4,5])

>>> n1

array([3, 1, 4, 5])#一维数组

>>> n2=np.array([[2,3,4,5],[3,5,6,7]])

>>> n2

array([[2, 3, 4, 5],

[3, 5, 6, 7]])

>>> #二维数组

n3=np.array(list('arr'))

>>> n3

array(['a', 'r', 'r'], dtype='|S1')

>>> n4=np.array([1,2.2,'xsxs'])

>>> n4

array(['1', '2.2', 'xsxs'], dtype='|S32')

>>> #int 和float转换为str

>>> np.ones(shape = (10,8),dtype= int)

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

>>> #十行八列的int数组元素值默认为one

np.zeros([4,4])

array([[0., 0., 0., 0.],

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

[0., 0., 0., 0.]])

#默认值为零

np.full((10,10),38)

array([[38, 38, 38, 38, 38, 38, 38, 38, 38, 38],

[38, 38, 38, 38, 38, 38, 38, 38, 38, 38],

[38, 38, 38, 38, 38, 38, 38, 38, 38, 38]])#10行10列值全为38，可以自己确定维数和值

np.eye(10)

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

[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],

[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],

[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],

[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],

[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],

[0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],

[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],

[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],

[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])

>>> #对角线全为1，一元十次方程。满秩

np.arange(0,100,3)

array([ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48,

51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87, 90, 93, 96, 99])

#0到100之间（左闭右开）以3为步伐

np.random.randint(0,150,size=5)

array([ 24, 114, 59, 100, 95])

>>> #产生5个0 到150的随机数

>>> np.random.randn(100)

array([ 3.35082829, -0.37115819, 0.80247094, -1.28873909, -1.28431603,

-1.11815 , 0.24174321, 0.45111328, -0.32903064, 1.0352493 ,

-0.15316301, -0.02536642, -0.56862227, 1.56465411, -1.75109142,

-0.55242377, 1.89999097, 1.73651904, 0.33510086, 0.50426053,

-0.34272666, 0.71946504, -0.50232083, -0.56263717, -0.71712574,

-1.43096495, -2.85686146, -0.63869171, -0.81096476, -0.94847399,

-0.48270003, 0.16613386, 0.83962232, -0.85022942, 0.024456 ,

1.99225315, 1.65694911, 0.58285013, -2.29496632, -0.43906447,

-2.02485793, -0.08674546, -1.07672492, -1.06972989, -0.6505497 ,

-0.6135854 , 0.79960243, 1.15791107, -0.54701886, 1.05666947,

0.14621877, -1.40813635, -0.24591542, 0.19967941, -1.14801003,

1.8489588 , -0.22480596, 1.47150873, -0.29566871, -0.54097336,

0.96397258, 1.17292773, -2.37660387, -2.4426527 , 1.14440024,

-1.02428763, 0.78537092, 1.41937026, 1.1723089 , 0.16764803,

0.14764773, -1.63680993, 0.1469394 , 0.16930859, 0.61316282,

-0.20633852, 0.90005043, -0.87075294, 1.34448905, 0.70262954,

2.05775907, -1.24639371, 1.37833912, 1.13365423, 0.55463811,

0.24329369, -1.06872399, -0.0792752 , -0.72015879, -0.03266665,

-0.35233853, 0.89186204, -0.31862884, -0.01163667, -0.0043089 ,

-0.60102044, 0.64323071, 1.01355728, -0.20745425, -0.38895885])

>>> 产生100个正太分布的随机数以零为中心

np.random.normal(loc = 175,scale=10,size=20)

array([171.00845317, 173.18642661, 179.62602741, 169.97356954,

183.40271728, 181.23758864, 165.65119933, 186.40289641,

182.33613485, 182.49041946, 171.20258278, 181.67741833,

167.81011297, 176.8276235 , 188.37718704, 174.20204526,

164.05009916, 185.83293973, 160.80993772, 183.45846588])

产生20个随机数，以175为中心波动系数为10

np.random.random(size=(5,5,3))

array([[[0.64123107, 0.15499673, 0.61510688],

[0.35868677, 0.68369404, 0.00613867],

[0.13975722, 0.76736526, 0.86223803],

[0.69251773, 0.63653175, 0.33740486],

[0.54023603, 0.1246829 , 0.75715704]],

[[0.81843097, 0.98600987, 0.33229412],

[0.32300797, 0.87697556, 0.49187322],

[0.95446863, 0.95139269, 0.16011724],

[0.12072147, 0.94797314, 0.44881757],

[0.052932 , 0.79495936, 0.81476853]],

[[0.84759662, 0.33428409, 0.02649364],

[0.06872688, 0.0499028 , 0.28084684],

[0.62091731, 0.23778735, 0.94556048],

[0.67564929, 0.42806521, 0.73337969],

[0.01137036, 0.90679013, 0.12479393]],

[[0.56840726, 0.32098105, 0.48563106],

[0.34479233, 0.30752574, 0.95330636],

[0.2945246 , 0.05664123, 0.58739862],

[0.23435391, 0.41945289, 0.09710961],

[0.46570456, 0.86916912, 0.39539866]],

[[0.42793506, 0.13326206, 0.95348895],

[0.83154412, 0.37675605, 0.75554649],

[0.4074704 , 0.33219232, 0.44972131],

[0.75427299, 0.39757514, 0.09302678],

[0.80792545, 0.51770092, 0.5195222 ]]])

>>>产生 25个三维0到1数组

3：numpy的一些操作

matplotlib库

import matplotlib.pyplot as plt

Cat=plt.imread("C:/Users/19575/Desktop/a.jpg")//读取一个图片变成数组ndarray

plt.imshow(cat)

<matplotlib.image.AxesImage object at 0x000000000EE88EB8>

>>> plt.show()//把图片给显示出来

>>> cat3=cat-20//对图片进行减操作

>>> plt.imshow(cat3)

<matplotlib.image.AxesImage object at 0x000000000E7FAF98>

>>> plt.show()

>>> n2.shape

(2L, 4L) #表明是二维四列的数组

#其实任意一个二维的图片转换成三维数组，长宽最后一维是颜色

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

>>> n3=np.arange(0,10,1)

>>> n3

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

>>> n3[::-1]#反方向取数据，间隔为-1

array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

>>>

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

n3.reshape(5,2)

array([[0, 1],

[2, 3],

[4, 5],

[6, 7],

[8, 9]])

>>> n3.shape

(10L,)

>>> #表明长度为10，变成5*2的形状

>>> #使用reshape可以对多维数组进行降维，

#如果reshape(负数),则负数默认为1

>>>

>>> n1

array([53, 41, 55, 32, 79, 81, 91, 34, 72, 68])

>>> n1.concatence((n1,n1))

>>> np.concatenate ((n1,n1),axis=0)

array([53, 41, 55, 32, 79, 81, 91, 34, 72, 68, 53, 41, 55, 32, 79, 81, 91,

34, 72, 68])

#级联操作。将两个列表对维度0进行合并

>>> #变成垂直结构

>>> n2=np.vstack (n1)

>>> n2

array([[53],

[41],

[55],

[32],

[79],

[81],

[91],

[34],

[72],

[68]])

>>> n3=np.hstack (n2)#变成水平结构

>>> n3

array([53, 41, 55, 32, 79, 81, 91, 34, 72, 68])

>>>

>>> n3

array([53, 41, 55, 32, 79, 81, 91, 34, 72, 68])

>>> np.hstack(np.hstack(p))

array([ 11, 117, 201, ..., 92, 201, 244], dtype=uint8)

>>> #使刚才的图片变成了一维

>>> n4=np.random.randint(0,150,size=(5,7))#声明一个五行七列的数组

>>> n4

array([[107, 131, 143, 59, 75, 143, 137],

[ 87, 71, 45, 146, 29, 92, 64],

[106, 112, 41, 106, 140, 96, 71],

[ 18, 0, 40, 77, 44, 96, 125],

[ 67, 148, 54, 80, 95, 103, 76]])

>>> np.split(n4,(1,3)，axis=0)#在第一行和第三行进行切割,如果axis为1的话就是竖直切割

[array([[107, 131, 143, 59, 75, 143, 137]]), array([[ 87, 71, 45, 146, 29, 92, 64],

[106, 112, 41, 106, 140, 96, 71]]), array([[ 18, 0, 40, 77, 44, 96, 125],

[ 67, 148, 54, 80, 95, 103, 76]])]

>>> pp=np.split(p,(100,200))[0]

>>> plt.imshow(pp)

<matplotlib.image.AxesImage object at 0x000000001CEFB7F0>

>>> pa=plt.imshow(pp)

>>> plt.show(pa)#把图片在100和200之间分割成三份然后展示第0份

>>>

>>> np.vsplit (n4,[1,4])

[array([[107, 131, 143, 59, 75, 143, 137]]), array([[ 87, 71, 45, 146, 29, 92, 64],

[106, 112, 41, 106, 140, 96, 71],

[ 18, 0, 40, 77, 44, 96, 125]]), array([[ 67, 148, 54, 80, 95, 103, 76]])]

>>> #竖直方向切割的是行

>>> np.hsplit (n4,[0,3])

[array([], shape=(5L, 0L), dtype=int32), array([[107, 131, 143],

[ 87, 71, 45],

[106, 112, 41],

[ 18, 0, 40],

[ 67, 148, 54]]), array([[ 59, 75, 143, 137],

[146, 29, 92, 64],

[106, 140, 96, 71],

[ 77, 44, 96, 125],

[ 80, 95, 103, 76]])]

>>> #在水平方向切割的是列，第0到2列

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

>>> l=[1,2,3,4]

>>> n=np.array(l)#n变成ndarray

>>> n[2]=512#修改n[2]

>>> n2=n

>>> n2[1]=22

>>> n2

array([ 1, 22, 512, 4])

>>> n

array([ 1, 22, 512, 4])

>>> #当我们的数据是ndarray,如果我们用=赋值，内存没有改变,所以n2和n会一起发生变化

>>> n3=n.copy()#如果是拷贝的话不会一起发生变化

>>> n3

array([ 1, 22, 512, 4])

>>> n3[2]=111

>>> n3

array([ 1, 22, 111, 4])

>>> n

array([ 1, 22, 512, 4])

>>>

ndarray的聚合操作

1求和np.sum

>>> p.sum ()

1098660384

>>> p.min()

>>> p.max()

255

>>> p.mean ()

159.82374443571615

>>> #求平均值

>>> n=np.random.randint(0,150,size=(3,3))

>>> n

array([[ 58, 64, 70],

[111, 108, 40],

[124, 23, 115]])

>>> np.mean (n,axis=0)

array([97.66666667, 65. , 75. ])

>>> #求每一列的平均值

>>> np.mean(n,axis=1)

array([64. , 86.33333333, 87.33333333])

>>> #求每一行的平均值

>>> np.argmax (n)

>>> #求最大值得索引

>>> np.argmin (n)

>>> #求最小值的索引

>>>

#可以对整个数组进行加减乘除运算比如，n+2，n/2等

4：矩阵乘法

>>> q1=np.random.randint(0,10,size=(2,2))

>>> q2=np.random.randint(0,10,size=(2,2))

>>> q1*q2

array([[40, 12],

[12, 0]])

>>> q1

array([[5, 2],

[4, 4]])

>>> q2

array([[8, 6],

[3, 0]])

>>> np.dot(q1,q2)

array([[46, 30],

[44, 24]])

>>> #矩阵乘法。。。注意不可以直接用乘号，如果直接用乘法符号的话是点乘

>>> m=np.ones((2,3))

>>> a=np.arange(3)

>>> print(m,a)

(array([[1., 1., 1.],

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

>>> m+a

array([[1., 2., 3.],

[1., 2., 3.]])

>>> #numpy广播机制，维度不对应，自动补全

>>> #广播机制两条规则：

>>> #规则一：微缺失的维度补一

>>> #规则二：假定缺失元素用已有值填充。

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

矩阵元素相乘

>>> two_dim_matrix_one = np.array([[1, 2, 3], [4, 5, 6]])

>>> two_dim_matrix_two = np.array([[1, 2], [3, 4], [5, 6]])

>>> two_multi_res = np.dot(two_dim_matrix_one, two_dim_matrix_two)

>>> two_multi_res

array([[22, 28],

[49, 64]])

>>>

对应元素相乘

>>> first=np.array([[1,2,3],[2,3,4]])

>>> second=np.array([[1,2,3],[3,2,1]])

>>> first*second

array([[1, 4, 9],

[6, 6, 4]])

>>> np.multiply (first,second)

array([[1, 4, 9],

[6, 6, 4]])#点乘

5：实现排序

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、实现冒泡排序

>>> aa=np.array([4,3,2,45,6])

>>> sort(aa)

>>> def sort(nd):#冒泡排序

for i in range(nd.size):

for j in range(i,nd.size):

if nd[i]>nd[j]:

nd[i],nd[j]=nd[j],nd[i]

return nd

>>> sort(aa)

array([ 2, 3, 4, 6, 45])

>>> #下面是改进的冒泡排序

>>> def sorted1(nd):#该方法可以降低时间复杂度和空间复杂度

for i in range(nd.size):

s=np.argmin(nd[i:])+i#切片所以不对应，要加上i

print(s)

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、#快速排序

np.sort和ndarray都可以，但有区别

>>> aaa

array([ 1, 2, 33, 22, 11])

>>> aaa.sort()

>>> aaa

array([ 1, 2, 11, 22, 33])

>>> #使用ndarray.sort(),原来的数据改变了，不占内存

>>> w=np.array([5,3,2,4,2])

>>> np.sort(w)

array([2, 2, 3, 4, 5])

>>> w

array([5, 3, 2, 4, 2])

>>> #使用np.sort(),原来的数据没有改变，生成了新的空间占内存

>>>

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、部分排序

np.partition(a,k)

有的时候我们不对所有的数据感兴趣，我们可能是只对部分数据感兴趣

1当k为正时，我们得到最小的k个数

2当k为负时，我们得到最大的K个数

>>> nd=np.random.randint (0,150,size=20)

>>> nd

array([148, 35, 129, 83, 145, 76, 145, 6, 54, 149, 83, 77, 130,

21, 106, 27, 127, 70, 119, 9])

>>> np.partition(nd,-5)#

array([ 6, 54, 27, 21, 35, 9, 70, 129, 119, 127, 83, 77, 76,

83, 106, 130, 145, 145, 148, 149])#得到5个最大的数，但不一定排序好

>>> np.partition(nd,5)

array([ 6, 9, 21, 27, 35, 54, 70, 145, 76, 145, 83, 77, 130,

83, 106, 129, 127, 119, 148, 149])#得到5个最小的数，但不一定排序好

6：对图片的一些操作

>>> fish=plt.imread('C:\\Users\\19575\\Desktop\\a.jpg')

>>> plt.imshow(fish)

<matplotlib.image.AxesImage object at 0x000000000EF23358>

>>> plt.show()

>>> fish1=fish[::-1]

>>> plt.show()

>>> plt.imshow(fish1)

<matplotlib.image.AxesImage object at 0x000000000F432470>

>>> plt.show()

>>> #实现上下颠倒

>>> fish2=fish[::-1,::-1]#上下颠倒，又左右颠倒

>>> plt.imshow(fish2)

<matplotlib.image.AxesImage object at 0x000000001C2CF4E0>

>>> plt.show()

>>> fish3=fish[::,::,::-1]#对颜色颠倒，红变蓝，。。等

>>> plt.imshow(fish3)

<matplotlib.image.AxesImage object at 0x000000001C834E10>

>>> plt.show()

>>> fish5=fish[::5,::5]#每隔五个数据取一个数据

>>> plt.imshow(fish5)

<matplotlib.image.AxesImage object at 0x000000001CB59B38>

>>> plt.show()

>>> #图形变得模糊

>>>

7总结：numpy是一个用python实现的科学计算包。包括:1、一个强大的N维数组对象Array;2、比较成熟的(广播)函数库;3、用于整合C/C++和Fortran代码的工具包;4、实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便，总之这个随笔是numpy基础的总结，之后我还会继续写一些numpy方面的应用的随笔。

猜你喜欢