python基础之Numpy库中array⽤法总结
⽬录
前⾔
为什么要⽤numpy
数组的创建
⽣成均匀分布的array：
⽣成特殊数组
获取数组的属性
数组索引，切⽚，赋值
数组操作
输出数组
总结
前⾔
Numpy是Python的⼀个科学计算的库，提供了矩阵运算的功能，其⼀般与Scipy、matplotlib⼀起使⽤。其实，list已经提供了类似于矩阵的表⽰形式，不过numpy为我们提供了更多的函数。
NumPy数组是⼀个多维数组对象，称为ndarray。数组的下标从0开始，同⼀个NumPy数组中所有元素的类型必须是相同的。>>> import numpy as np
为什么要⽤numpy
Python中提供了list容器，可以当作数组使⽤。但列表中的元素可以是任何对象，因此列表中保存的是对象的指针，这样⼀来，为了保存⼀个简单的列表[1,2,3]。就需要三个指针和三个整数对象。对于数值运算来说，这种结构显然不够⾼效。
Python虽然也提供了array模块，但其只⽀持⼀维数组，不⽀持多维数组(在TensorFlow⾥⾯偏向于矩阵理解)，也没有各种运算函数。因⽽不适合数值运算。
NumPy的出现弥补了这些不⾜。
数组的创建
使⽤numpy.array⽅法将tuple和list, array, 或者其他的序列模式的数据转创建为 ndarray, 默认创建⼀个新的 ndarray.
>>> np.array([1,2,3,4])
[1 2 3 4]
>>> b = array( [ (1.5,2,3),
(4,5,6)  ]  ) 
array([[ 1.5,  2. ,  3. ],
    [ 4. ,  5. ,  6. ]])
>>> c = array( [ [1,2], [3,4] ], dtype=complex)
#指定数组中元素的类型
>>> c
array([[ 1.+0.j,  2.+0.j],
      [ 3.+0.j,  4.+0.j]])
⽣成均匀分布的array：
arange（最⼩值，最⼤值，步长）（左闭右开） : 创建等差数列
linspace（最⼩值，最⼤值，元素数量）
logspace(开始值, 终值, 元素个数): 创建等⽐数列
>>> np.arange(15)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
>>> np.arange(15).reshape(3,5)
[[ 0  1  2  3  4]
[ 5  6  7  8  9]
[10 11 12 13 14]]
>>> np.arange( 0, 2, 0.3 )
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])
>>> np.linspace(1,3,9)
[ 1.    1.25  1.5  1.75  2.    2.25  2.5  2.75  3.  ]
⽣成特殊数组
np.identity: 创建⼀个主对⾓线为 1 其他为 0 的⽅阵. >>> np.zeros((3,4))
[[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]
[ 0.  0.  0.  0.]]
>>> np.ones((3,4))
[[ 1.  1.  1.  1.]
[ 1.  1.  1.  1.]
[ 1.  1.  1.  1.]]
>>> np.eye(3)
[[ 1.  0.  0.]
[ 0.  1.  0.]
[ 0.  0.  1.]]
获取数组的属性
>>> a = np.zeros((2,2,2))
>>> a.ndim  #数组的维数
3
>>> a.shape  #数组每⼀维的⼤⼩
(2, 2, 2)
>>> a.size  #数组全部元素的数量
8
>>> a.dtype  #数组中元素的类型
float64
>>> print a.itemsize  #每个元素所占的字节数
8
数组索引，切⽚，赋值
‘…'符号表⽰将所有未指定索引的维度均赋为 ‘：'
‘：'在python中表⽰该维所有元素
>>> a = np.array( [[2,3,4],[5,6,7]] )
>>> a
[[2 3 4]
[5 6 7]]
>>> a[1,2]
7
>>> a[1,:]
[5 6 7]
>>> print a[1,1:2]
[6]
>>> a[1,:] = [8,9,10]
>>> a
[[ 2  3  4]
[ 8  9 10]]
>>> c[1,...]                                  # same as c[1,:,:] or c[1]
array([[100, 101, 102],
[110, 112, 113]])
>>> c[...,2]                                  # same as c[:,:,2]
array([[  2,  13],
[102, 113]])
>>> def f(x,y):
...    return 10*x+y
...
>>> b = np.fromfunction(f,(5,4),dtype=int)    #
>>> b
array([[ 0,  1,  2,  3],
[10, 11, 12, 13],
[20, 21, 22, 23],
[30, 31, 32, 33],
[40, 41, 42, 43]])
数组操作
>>> a = np.ones((2,2))
>>> b = np.eye(2)
>>> print a
[[ 1.  1.]
[ 1.  1.]]
>>> print b
[[ 1.  0.]
[ 0.  1.]]
>>> print a > 2
[[False False]
[False False]]
>>> print a+b            #数组加，对应位置相加
[[ 2.  1.]
[ 1.  2.]]
>>> print a-b            #数组减，对应位置相减
[[ 0.  1.]
[ 1.  0.]]
>>> print b*2            #数组与数值相乘，对应位置乘
[[ 2.  0.]
[ 0.  2.]]
>>> print (a*2)*(b*2)    #数组与数组相乘，按位置⼀对⼀相乘
[[ 4.  0.]
[ 0.  4.]]
>>> print b/(a*2)          #数组与数组相除，按位置⼀对⼀相除
[[ 0.5  0. ]
[ 0.  0.5]]
>>> print a.dot(b)                    # matrix product，矩阵乘
>>> np.dot(a,a)                      #矩阵乘法
array([[ 2.,  2.],
[ 2.,  2.]])
>>> print (a*2)**4
[[ 16.  16.]
[ 16.  16.]]
>>> b = a              #浅拷贝
>>> b is a
True
>>> c = a.copy()      #深拷贝
>>> c is a
False
内置函数（min,max,sum)，同时可以使⽤axis指定对哪⼀维进⾏操作： >>> a.sum()
numpy库统计函数
4.0
>>> a.sum(axis=0)    #计算每⼀列（⼆维数组中类似于矩阵的列）的和
array([ 2.,  2.])
>>> a.min()          #数组最⼩值
1.0
>>> a.max()          #数组最⼤值
1.0
使⽤numpy下的⽅法：
>>> np.sin(a)
array([[ 0.84147098,  0.84147098],
[ 0.84147098,  0.84147098]])
>>> np.max(a)
1.0
>>> np.floor(a)
array([[ 1.,  1.],
[ 1.,  1.]])
>>> np.exp(a)              #e^x
array([[ 2.71828183,  2.71828183],
[ 2.71828183,  2.71828183]])
>>> print np.vstack((a,b))  #合并数组
[[ 1.  1.]
[ 1.  1.]
[ 1.  0.]
[ 0.  1.]]
>>> print np.hstack((a,b))  #合并数组
[[ 1.  1.  1.  0.]
[ 1.  1.  0.  1.]]
>>> anspose()      #转置
numpy.linalg模块中有很多关于矩阵运算的⽅法：
>>> import numpy.linalg as nplg
NumPy中的基本数据类型
名称描述
bool⽤⼀个字节存储的布尔类型（True或False）
inti由所在平台决定其⼤⼩的整数（⼀般为int32或int64）
int8/16/32/64整数，1/2/4/8个字节⼤⼩
uint8/16/32/64⽆符号整数
float16/32/64半/单/双精度浮点数，16/32/64位，指数、精度也不同
complex64/128复数，分别⽤两个32/64位浮点数表⽰实部和虚部
输出数组
当输出⼀个数组时，NumPy以特定的布局⽤类似嵌套列表的形式显⽰：
第⼀⾏从左到右输出
每个切⽚通过⼀个空⾏与下⼀个隔开
⼀维数组被打印成⾏，⼆维数组成矩阵，三维数组成矩阵列表。
如果⼀个数组太长，则NumPy⾃动省略中间部分⽽只打印两端的数据：　
>>> a = arange(6)                        # 1d array
>>> print a
[0 1 2 3 4 5]
>>> b = arange(12).reshape(4,3)          # 2d array
>>> print b
[[ 0  1  2]
[ 3  4  5]
[ 6  7  8]
[ 9 10 11]]  　
>>> c = arange(24).reshape(2,3,4)        # 3d array
>>> print c
[[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
总结
到此这篇关于python基础之Numpy库中array⽤法的⽂章就介绍到这了，更多相关python Numpy中array⽤法内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。