Python——Numpy基础知识

Posted 2021-01-20 咕噜咕噜——干饭啦干饭啦

一、Numpy的引入

1、标准的Python 中用列表(list)保存一组值，可以当作数组使用。但由于列表的元素可以是任何对象，因此列表中保存的是对象的指针。对于数值运算来说，这种结构显然比较浪费内存和CPU 计算

2、虽然Python 提供了array 模块，它和列表不同，能直接保存数值，但是由于它不支持多维数组，也没有各种运算函数，因此也不适合做数值运算。

 

　　NumPy 的诞生弥补了这些不足。

　　NumPy 提供了两种基本的对象：ndarray（n-dimensional array object）和ufunc（universal function object）。

　　ndarray(下文统一称之为数组)是存储单一数据类型的多维数组，而ufunc 则是能够对数组进行处理的函数。

二、Numpy简介

Numpy 是一个专门用于矩阵化运算、科学计算的开源Python库，Numpy将Python相当于变成一种免费的更强大的Matlab系统
优势：
1、强大的 ndarray 多维数组结构
2、成熟的函数库
3、用于整合C/C++和Fortran代码的工具包
4、实用的线性代数、傅里叶变换和随机数模块
5、Numpy 和稀疏矩阵运算包scipy 配合使用非常方便

三、语法简介

首先，简单的创建数组及相关操作：

 1 import numpy as np
 2 　　#生成简单的一维矩阵
 3 a=np.array([1,2,3,4])     
 4 　　#生成简单的二维矩阵
 5 c=np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
 6 　　#获取类型
 7 print(type(a))
 8　　 #数组的大小可以通过其属性获得
 9 print (a.shape,b.shape)
10　　 #打印数组
11 print (c)
12 　　#可以通过修改数组的shape属性，在爆出数组元素个数不变的情况下，改变数组每个轴的长度
13 c.shape=4,3
14 　　##注意，并不是对数组进行转置，而是只改变每个轴的大小
15 print(c)
16     #当某个轴的元素为-1时，将根据数组元素的阁主自动计算此轴的长度
17 c.shape=2,-1
18 print(c)
19 　　#使用reshape方法可以创建一个改变了尺寸的新数组，原数组保持不变
20 d=a.reshape((2,2))
21 print(d)
22 print(a)
23 d=c.reshape((3,3))#不能讲一个12个元素的数组分成3*3，会报错
24 print(c)
25 　　#数组a和d实际上时共享数据存储内存区域，修改其一另一个也会改变

输出

<class ‘numpy.ndarray‘>#打印类型
#shape
(4,) (3, 4)
#打印数组
[[ 1  2  3  4]
 [ 4  5  6  7]
 [ 7  8  9 10]]
#修改轴长
[[ 1  2  3]
 [ 4  4  5]
 [ 6  7  7]
 [ 8  9 10]]
#修改轴长，其一参数为-1
[[ 1  2  3  4  4  5]
 [ 6  7  7  8  9 10]]
#reshape
[[1 2]
 [3 4]]
[1 2 3 4]
#错误
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-13-430fc5495966> in <module>()
     21 print(d)
     22 print(a)
---> 23 d=c.reshape((3,3))
     24 print(c)

ValueError: cannot reshape array of size 12 into shape (3,3)

上面的例子都是先创建一个Python序列，然后通过array函数将其转换为数组，这样做显然效率不高。因此NumPy提供了很多专门用来创建数组的函数。

初始化数组：

 1 import numpy as np
 2 a=np.arange(0,1,0.1)
 3 print("a=",a)
 4 b=np.linspace(0,1,10)
 5 print("b=",b)
 6 c=np.linspace(0,1,10,endpoint=False)
 7 print("c=",c)
 8 d=np.logspace(0,2,20)
 9 print("d=",d)
10 e=np.empty((2,3),np.int)
11 print("e=",e)
12 f=np.zeros(4,np.float)
13 print("f=",f)

运行结果：

a= [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
b= [0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
 0.66666667 0.77777778 0.88888889 1.        ]
c= [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
d= [  1.           1.27427499   1.62377674   2.06913808   2.6366509
   3.35981829   4.2813324    5.45559478   6.95192796   8.8586679
  11.28837892  14.38449888  18.32980711  23.35721469  29.76351442
  37.92690191  48.32930239  61.58482111  78.47599704 100.        ]
e= [[          0           0  1863334416]
 [        588           0 -2147483648]]
f= [0. 0. 0. 0.]

 　　arange函数类似于python的range函数，通过指定开始值、终值和步长来创建一维数组，注意数组不包括终值。

　　linspace函数通过指定开始值、终值和元素个数来创建一维数组，可以通过endpoint关键字指定是否包括终值，缺省设置是包括终值:
　　numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
　　Endpoint 如果是真，则一定包括stop，如果为False，一定不会有stop

　　#numpy.logspace(start, stop, num, endpoint=true, base=10, dtype)
　　#数据头一定是base^start，若endpoint=True，数据尾为base^end，其余数据为base^(start,end)
　　 logspace函数和linspace类似，不过它创建等比数列，下面的例子产生1(10^0)到100(10^2)、有20个元素的等比数列。

　　zeros()、ones()、empty()可以创建指定形状和类型的数组。

　　此外，zeros_like()、ones_like()、empty_like()等函数可创建与参数数组的形状及类型相同的数组。因此，“zeros_like(a)”和“zeros(a.shape, a.dtype)”的效果相同。

 

存取元素：

 1 >>> a = np.arange(10)
 2 >>> a[5] # 用整数作为下标可以获取数组中的某个元素
 3 5
 4 >>> a[3:5] # 用范围作为下标获取数组的一个切片，包括a[3]不包括a[5]
 5 array([3, 4])
 6 >>> a[:5] # 省略开始下标，表示从a[0]开始
 7 array([0, 1, 2, 3, 4])
 8 >>> a[:-1] # 下标可以使用负数，表示从数组后往前数
 9 array([0, 1, 2, 3, 4, 5, 6, 7, 8])
10 >>> a[2:4] = 100,101 # 下标还可以用来修改元素的值
11 >>> a
12 array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9])
13 
14 >>> a[1:-1:2] # 范围中的第三个参数表示步长，2表示隔一个元素取一个元素
15 array([ 1, 101, 5, 7])
16 >>> a[::-1] # 省略范围的开始下标和结束下标，步长为-1，整个数组头尾颠倒
17 array([ 9, 8, 7, 6, 5, 4, 101, 100, 1, 0])
18 >>> a[5:1:-2] # 步长为负数时，开始下标必须大于结束下标
19 array([ 5, 101])
20 
21 >>> b = a[3:7] # 通过下标范围产生一个新的数组b，b和a共享同一块数据空间
22 >>> b
23 array([101, 4, 5, 6])
24 >>> b[2] = -10 # 将b的第2个元素修改为-10
25 >>> b
26 array([101, 4, -10, 6])
27 >>> a # a的第5个元素也被修改为10
28 array([ 0, 1, 100, 101, 4, -10, 6, 7, 8, 9])

　　除了使用下标范围存取元素之外，NumPy还提供了两种存取元素的高级方法。
　　1、使用整数序列
        当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标，整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空间。

 1 >>> x = np.arange(10,1,-1)
 2 >>> x
 3 array([10, 9, 8, 7, 6, 5, 4, 3, 2])
 4 >>> x[[3, 3, 1, 8]] # 获取x中的下标为3, 3, 1, 8的4个元素，组成一个新的数组
 5 array([7, 7, 9, 2])
 6 >>> b = x[np.array([3,3,-3,8])] #下标可以是负数
 7 >>> b[2] = 100
 8 >>> b
 9 array([7, 7, 100, 2])
10 >>> x # 由于b和x不共享数据空间，因此x中的值并没有改变
11 array([10, 9, 8, 7, 6, 5, 4, 3, 2])
12 >>> x[[3,5,1]] = -1, -2, -3 # 整数序列下标也可以用来修改元素的值
13 >>> x
14 array([10, -3, 8, -1, 6, -2, 4, 3, 2])

注：”:”用以表示当前维度的所有子模块 ； “-1”用以表示当前维度所有子模块最后一个；”负号用以表示从后往前数的元素”
　　2、使用布尔数组

　　当使用布尔数组b作为下标存取数组x中的元素时，将收集数组x中所有在数组b中对应下标为True的元素。
        使用布尔数组作为下标获得的数组不和原始数组共享数据空间，注意这种方式只对应于布尔数组，不能使用布尔列表。

 1 >>> x = np.arange(5,0,-1)
 2 >>> x
 3 array([5, 4, 3, 2, 1])
 4 
 5 >>> x=np.random.rand(10)
 6 >>> x
 7 array([ 0.5993579 ,  0.68693925,  0.74380945,  0.40993085,  0.72345401, 0.64499497,  0.48715468,  0.80924589,  0.43362779,  0.06554248])
 8 >>> x>0.5 #对每个元素都比较
 9 array([ True,  True,  True, False,  True,  True, False,  True, False, False], dtype=bool)
10 >>> x[x>0.5] #将它当做索引传回原数组，只获取那些>0.5的
11 array([ 0.5993579 ,  0.68693925,  0.74380945,  0.72345401,  0.64499497, 0.80924589])
12 >>> np.all(x<1) #测试x<1所返回的数组(传给all)中所有元素是否都等价True  
13 >>> a=np.array([1,2,3])
14 >>> b=np.array([3,2,1])
15 >>> a>b #对应位置作比较
16 array([False, False,  True], dtype=bool)
17 >>> a[a==b] #获取一样的
18 array([2])
19 >>>(a==b).all()
20 >>>(a==b).any()
21 >>> np.any([1,2,3,4]) #如果传入的数组中有至少一个元素等价True都返回True
22 True