numpy学习

import numpy as np 
array = np.array([[1,2,3],[4,5,6]])
print(array)
print('====================')
print('number of dim:',array.ndim)#显示这个数组是几维数组
print('====================')
print('shape:',array.shape)#显示数组是几行几列
print('====================')
print('size:',array.size)#显示有几个元素

[[1 2 3]
 [4 5 6]]
====================
number of dim: 2
====================
shape: (2, 3)
====================
size: 6

In [9]:

'''
数组可以定义数组的字节类型，numpy中使用dtype来定义，
有int32,int64,还有float32，float64,float32,查看类型
可以使用.dtype来查看
'''
import numpy as np
a = np.array([1,23,4],dtype=np.int64)
print(a.dtype)

int64

In [11]:

import numpy as np
a= np.zeros((3,4))#生成三行四列的元素为零的矩阵
print(a)

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

In [12]:

import numpy as np
a= np.ones((3,4))#生成三行四列的元素为1的矩阵
print(a)

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

In [15]:

import numpy as np
a= np.arange(1,4)#生成1-4的一维数组
print(a)

[1 2 3]

In [19]:

import numpy as np
a= np.linspace(1,10,5)#从1-10生成5个数
print(a)

[ 1.    3.25  5.5   7.75 10.  ]

In [26]:

import numpy as np
a= np.linspace(1,10,6).reshape((2,3))#从1-10生成6个数,重新定义为2行3列，但是前提是生成的数数刚好满足矩阵元素
print(a)

[[ 1.   2.8  4.6]
 [ 6.4  8.2 10. ]]

In [5]:

import numpy as np
a= np.array([10,20,30,40])#生成一位数字【10，20，30，40】
b = np.arange(4)#生成一维数组【0，1，2，3】
print(a,b)
print('====================')
print(a+b)#逐个相加
print('====================')
print(a-b)#逐个相减
print('====================')
print(a*b)#相乘
print('====================')
print(a>20)#[False False  True  True]
print('====================')
print(a==20)#[False  True False False]

[10 20 30 40] [0 1 2 3]
====================
[10 21 32 43]
====================
[10 19 28 37]
====================
[  0  20  60 120]
====================
[False False  True  True]
====================
[False  True False False]

In [31]:

import numpy as np
a= np.array([10,20,30,40]).reshape((2,2))
b = np.arange(4).reshape((2,2))
print(a==20)

[[False  True]
 [False False]]

In [2]:

import numpy as np
a= np.array([10,20,30,40]).reshape((2,2))
b = np.arange(4).reshape((2,2))
print(a)
print('====================')
print(b)
print('====================')
print(a*b)#逐个相乘，0*10，1*20，2*30，3*40
c_dot = np.dot(a,b)#矩阵运算结果
c_dot2 = a.dot(b)#相当于c_dot = np.dot(a,b)
print(c_dot2)
print('====================')
print(c_dot)

[[10 20]
 [30 40]]
====================
[[0 1]
 [2 3]]
====================
[[  0  20]
 [ 60 120]]
[[ 40  70]
 [ 80 150]]
====================
[[ 40  70]
 [ 80 150]]

In [3]:

import numpy as np
a = np.random.random((2,3))#随机生成三行四列的随机数
print(a)
print(np.sum(a))
print('====================')
print(np.max(a))
print('====================')
print(np.min(a))

[[0.05621001 0.8422847  0.54361525]
 [0.93049848 0.66283586 0.5442016 ]]
3.579645897844816
====================
0.9304984790692439
====================
0.05621001007889814

In [4]:

import numpy as np
a = np.random.random((2,3))#随机生成三行四列的随机数
print(a)
print(np.sum(a,axis=1))#针对每一行
print('====================')
print(np.max(a,axis=0))#针对每一列
print('====================')
print(np.min(a,axis=1))#针对每一行

[[0.48756707 0.97080884 0.3491784 ]
 [0.97905997 0.61933038 0.09642127]]
[1.80755432 1.69481162]
====================
[0.97905997 0.97080884 0.3491784 ]
====================
[0.3491784  0.09642127]

In [6]:

a = np.arange(2,14).reshape((3,4))
#求数组最大值最小值索引
print(np.argmin(a))
print('====================')
print(a.argmin())
print('====================')
print()
print(np.argmax(a))
print('====================')
print(a.argmax())
print()
#求数组平均值
print(np.mean(a))
print('====================')
print(a.mean())

print(np.median(a))#中位数
print('====================')
#   print(a.median())失效
print(np.cumsum(a))#累加
print('====================')
print(np.diff(a))
print('====================')
print(np.nonzero(a))#非0元素位置
print('====================')
print(np.sort(a))#排序（逐行）
print('====================')
print(np.transpose(a))#转置
print('====================')
print((a.T).dot(a))
print('====================')
print(np.clip(a,3,11))#保持在3-11之间，小于3的用3替换，大于11的使用11替换

0
====================
0
====================

11
====================
11

7.5
====================
7.5
7.5
====================
[ 2  5  9 14 20 27 35 44 54 65 77 90]
====================
[[1 1 1]
 [1 1 1]
 [1 1 1]]
====================
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))
====================
[[ 2  3  4  5]
 [ 6  7  8  9]
 [10 11 12 13]]
====================
[[ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]
 [ 5  9 13]]
====================
[[140 158 176 194]
 [158 179 200 221]
 [176 200 224 248]
 [194 221 248 275]]
====================
[[ 3  3  4  5]
 [ 6  7  8  9]
 [10 11 11 11]]

In [15]:

import numpy as np
a = np.arange(0,16).reshape((2,8))
print(a)#行
print('====================')
print(a.T)#列
print('====================')
print(a.flatten())#转为一维数组
print('====================')
for i in a.flat:#转为一维数组后转置
    print(i)

[[ 0  1  2  3  4  5  6  7]
 [ 8  9 10 11 12 13 14 15]]
====================
[[ 0  8]
 [ 1  9]
 [ 2 10]
 [ 3 11]
 [ 4 12]
 [ 5 13]
 [ 6 14]
 [ 7 15]]
====================
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
====================
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

In [75]:

'''
合并
'''

import numpy as np
a = np.array([1,1,1])
b = np.array([2,2,2])
print(np.vstack((a,b)))#上下合并
print(np.hstack((a,b)))#左右合并

[[1 1 1]
 [2 2 2]]
[1 1 1 2 2 2]

In [16]:

import numpy as np
a = np.array([1,1,1])[:,np.newaxis]
b = np.array([2,2,2])[:,np.newaxis]
print(a)
print('====================')
print(b)
print('====================')
c = np.concatenate((a,b,a,b),axis=1)
print(c)

[[1]
 [1]
 [1]]
====================
[[2]
 [2]
 [2]]
====================
[[1 2 1 2]
 [1 2 1 2]
 [1 2 1 2]]

In [17]:

import numpy as np
a = np.arange(16).reshape((4,4))
print(a)
print('====================')
print(np.split(a,2,axis=1))#对a进行分割，分成两块，按照列分割（等量）
print('====================')
print(np.split(a,2,axis=0))#对a进行分割，分成两块，按照行分割（等量）
print('====================')
print(np.array_split(a,3,axis=1))#对a进行分割，分成两块，按照列分割(不等量)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
====================
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]
====================
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
====================
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2],
       [ 6],
       [10],
       [14]]), array([[ 3],
       [ 7],
       [11],
       [15]])]

In [18]:

import numpy as np
print('====================')
a = np.arange(16).reshape((4,4))
print('====================')
print(np.vsplit(a,2))
print('====================')
print(np.hsplit(a,2))

====================
====================
[array([[0, 1, 2, 3],
       [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])]
====================
[array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])]

In [99]:

import numpy as np
a = np.array([1,2,3,4])
print(a)
b=a
c=b
a[0]=10
print(a,b,c)
#赋值语句就是浅拷贝，会随着原来的数一起改变
d=a.copy()#不会改变，属于deep_copy
a[1] = 11
print(a)
print(d)

[1 2 3 4]
[10  2  3  4] [10  2  3  4] [10  2  3  4]
[10 11  3  4]
[10  2  3  4]

In [ ]: