【python学习第11节:numpy】

文章目录

  • 一,numpy(上)
    • 1.1基础概念
    • 1.2数组的属性
    • 1.3数组创建
    • 1.4 类型转换
    • 1.5ndarry基础运算(上)矢量化运算
    • 1.6拷贝和视图
      • 1.6.1完全不复制
      • 1.6.2视图或浅拷贝
      • 1.6.3深拷贝
    • 1.7索引,切片和迭代
      • 1.7.1一维数组
      • 1.7.2多维数组
    • 1.8形状操作
    • 1.9布尔索引和花式索引
    • 1.10字符串索引
    • 1.11搜索匹配函数
    • 1.12排序

一,numpy(上)

1.1基础概念

Numpy的数组的类称为ndarray(非动态数组),一但定义好了里面的内容可以变,但是长度不能变

1.2数组的属性

示例:

ndarray.ndim: 来获取数组的维度,维度的数量被称为rank

>>> import numpy as np
>>> x = np.array([[1,2,3],[4,5,6]])
>>> x
array([[1, 2, 3],
       [4, 5, 6]])
>>> x.ndim
2
>>>

ndarray.shape:来获取数组的行数,列数。

>>> import numpy as np
>>> x = np.array([[1,2,3],[4,5,6]])
>>> x
array([[1, 2, 3],
       [4, 5, 6]])
>>> x.shape
(2, 3)
>>>
>>>> x = np.array([1])
>>> x.shape
(1,)
>>> x = np.array([[1]])
>>> x.shape
(1, 1)

ndarray.size:来获取数组元素的总数,等于shape的元素的乘积

>>> import numpy as np
>>>> x = np.array([[1,2,3],[4,5,6]])
>>>> x.shape
(2, 3)
>>> x.size
6

ndarray.dtype:来获取数组的数据类型,它返回一个描述数组元素类型的对

>>> import numpy as np
>>> x = np.array([[1,2,3],[4,5,6]])
>>> x.dtype
dtype('int32')
>>> x = np.array([[1.1,2,3],[4,5,6]])
>>> x.dtype
>>>dtype('float64')
>>>

ndarray.itemsize:来获取数组中每个元素的字节大小(即每个元素占用的字节数)

>>> import numpy as np
>>> x = np.array([[1,2,3],[4,5,6]])
>>> x.itemsize
4
>>> x = np.array([[1.1,2,3],[4,5,6]])
>>> x.itemsize
8

ndarray.strides:来获取数组的步长,步长是描述在每个维度上移动一个元素所需的字节数

>>> import numpy as np
>>> x = np.array([[1.1,2,3],[4,5,6]])
>>> x.strides
(24, 8)#一行3个元素,每个大小8字节
>>> x = np.array([[1,2,3],[4,5,6]])
>>> x.strides
(12, 4)
>>>

1.3数组创建

说明:
使用numpy.array使用array函数从常规python列表或元组中创建数组。

>>> import numpy as np
>>> np.array([1,2,3])
array([1, 2, 3])
>>> np.array((1,2,3))
array([1, 2, 3])
>>>

数组的类型在创建的时候也可以明确指定

>>> import numpy as np
>>>> a = np.array([[1,2,3],[2,5,6]],dtype = complex)
>>> a
array([[1.+0.j, 2.+0.j, 3.+0.j],
       [2.+0.j, 5.+0.j, 6.+0.j]])
>>>

numpy.zeros创建一个由0组成的数组

>>> import numpy as np
>>> np.zeros((3,5))
array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]])
>>>

numpy.ones创建一个由1组成的数组

>>> import numpy as np
>>> np.ones((3,5))
array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])
>>>

numpy.random提供了各种方法来生成不同分布的随机数数组


>>> import numpy as np
>>> np.random.random((3,4))	#数组中的每个数是0-1之间的
array([[0.2192252 , 0.23184818, 0.53477907, 0.94434772],
       [0.93001715, 0.42585838, 0.41844402, 0.38080826],
       [0.9451442 , 0.55833465, 0.17982058, 0.77624287]])
>>>

numpy.arange 用于创建一个等差数列的 NumPy 数组,返回的是一个数组而不是列表

numpy.arange([start],stop, [step],dtype=None)
start(可选):序列的起始值,默认为 0。
stop:序列的终止值(不包括在序列中)。
step(可选):序列中的元素之间的步长,默认为 1。
dtype(可选):生成数组的数据类型。如果未指定,则根据输入参数自动推断数据类型。

>>> import numpy as np
>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.arange(2,10,3)
array([2, 5, 8])
>>>

numpy.linspace 用于创建一个等间距的线性数列的 NumPy 数组。

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
start:数列的起始值。
stop:数列的终止值。
num(可选):生成数列的元素个数,默认为 50。
endpoint(可选):如果为 True,则包含终止值;如果为 False,则不包含终止值。默认为 True。
retstep(可选):如果为 True,则返回数列的间隔(步长)。
dtype(可选):生成数组的数据类型。如果未指定,则根据输入参数自动推断数据类型。

>>> np.linspace(0,1,6)
array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])
>>>

numpy.fromfunction从给定函数创建一个数组

import numpy as np
def f(x,y):
    return 2*x+y
a = np.fromfunction(f,(4,4))
print(a)

#执行结果
[[0. 1. 2. 3.]
 [2. 3. 4. 5.]
 [4. 5. 6. 7.]
 [6. 7. 8. 9.]]

numpy.eye 用于创建一个单位矩阵
numpy.eye(N, M=None, k=0, dtype=float, order=‘C’)
N:矩阵的行数(或数组的维度)。
M(可选):矩阵的列数。如果未指定,则默认与行数 N 相等。
k(可选):对角线的偏移量。默认为 0,表示主对角线。正值表示位于主对角线上方的对角线,负值表示位于主对角线下方的对角线。
dtype(可选):生成数组的数据类型。
order(可选):数组的存储顺序。可以是 ‘C’(按行存储)或 ‘F’(按列存储)。默认为 ‘C’。

>>> import numpy as np
>>> np.eye(4)
array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]])
>>> np.eye(4,k=1)
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [0., 0., 0., 0.]])
>>> np.eye(4,k=-1)
array([[0., 0., 0., 0.],
       [1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.]])
>>>

1.4 类型转换

numpy.astype可以实现类型转换(创建一个新的对象,原对象的类型不变)

>>> import numpy as np
>>> a = np.array([1,2,3],dtype = float)
>>> a
array([1., 2., 3.])
>>> b = a.astype(int)
>>> b
array([1, 2, 3])
>>> b.dtype
dtype('int32')
>>> a.dtype
dtype('float64')
>>>

矩阵之间的点乘

>>> a = np.floor(10*np.random.random((3,3)))
>>> a
array([[3., 8., 8.],
       [8., 2., 7.],
       [1., 3., 7.]])
>>> b = np.floor(10*np.random.random((3,3)))
>>> b
array([[5., 7., 1.],
       [9., 3., 7.],
       [1., 5., 8.]])
>>> a.dot(b)
array([[ 95.,  85., 123.],
       [ 65.,  97.,  78.],
       [ 39.,  51.,  78.]])
>>>

1.5ndarry基础运算(上)矢量化运算

矢量:既有大小,又有方向
标量:只有大小,没有方向

矢量与标量相乘

>>> import numpy as np
>>> a = np.array([1,2,3])	#创建一个1维的数组(向量)
>>> b = a*2					#b等于矢量*标量
>>> a
array([1, 2, 3])
>>> b
array([2, 4, 6])	#对矢量里面的每个值都跟标量乘一下,相当于‘广播’
>>>

矢量与标量相加

>>> a
array([1, 2, 3])
>>> a+2
array([3, 4, 5])

矢量与矢量相加

>>> a
array([1, 2, 3])
>>> b = a+2
>>> b
array([3, 4, 5])
>>> a + b
array([4, 6, 8])
>>> a
array([1, 2, 3])
>>> c
array([1, 2])
>>> a+c
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,) (2,)
>>> c = np.array([1])
>>> c
array([1])
>>> a+c
array([2, 3, 4])
>>>

矢量与矢量相乘

>>> a
array([1, 2, 3])
>>> c
array([1, 2, 5])
>>> a*c
array([ 1,  4, 15])
array([1])
>>> a
array([1, 2, 3])
>>> a*c
array([1, 2, 3])
>>> c = np.array([1,2])
>>> a*c
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: operands could not be broadcast together with shapes (3,) (2,)
>>>

广播规则:
1,维度数较少的数组会在其维度前面自动填充1,直到维度数与另一个数组相同。这样,两个数组的维度会匹配。

2,如果两个数组在某个维度上的大小相等,或者其中一个数组在该维度上的大小为1,那么这两个数组在该维度上是兼容的。

3,如果两个数组在所有维度上都兼容,即满足维度匹配的条件,那么它们可以进行广播。

4,在进行广播时,数组会沿着维度大小为1的维度进行复制,以使其与另一个数组具有相同的形状。

1.6拷贝和视图

1.6.1完全不复制

简单赋值不会创建数组对象或其数据的拷贝

>>> import numpy as np
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = a
>>> b
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b is a
True
>>>

1.6.2视图或浅拷贝

不同的数组对象可以共享相同的数据。view方法创建一个新数组对象,通过该对象可看到相同的数据

>>> import numpy as np
>>> a = np.array([1,2,3,4])
>>> a
array([1, 2, 3, 4])
>>> b = a.view()
>>> b
array([1, 2, 3, 4])
>>> b is a
False
>>> a[1]
2
>>> a[1] = 7
>>> a
array([1, 7, 3, 4])
>>> b
array([1, 7, 3, 4])
>>> a.flags.owndata
True
>>> b.flags.owndata
False
>>>

1.6.3深拷贝

copy方法生成数组及其数据的完整拷贝。

>>> b = a.copy()
>>> b
array([1, 2, 3, 4])
>>> a
array([1, 2, 3, 4])
>>> b is a
False
>>> b[1] = 13
>>> b
array([ 1, 13,  3,  4])
>>> a
array([1, 2, 3, 4])
>>>

1.7索引,切片和迭代

1.7.1一维数组

一维数组可以索引,切片和迭代,非常类似列表和其他Python序列。

1.7.2多维数组

import numpy as np
def f(x,y):
    return 2*x+y
a = np.fromfunction(f,(4,4),dtype=int)
'''
[[0 1 2 3]
 [2 3 4 5]
 [4 5 6 7]
 [6 7 8 9]]
 '''

得到某个具体行具体列元素的值

print(a[2][3])	
7				#a中第2行3列元素的值

得到某一行的值

print(a[2])
[4 5 6 7] 		#第二行的值
print(a[1:3][1])
[4 5 6 7]		#在索引到的(1-2)行中的第一行(前面有一个第0行)
print(a[1][1:3])
[3 4]			#索引的第一行中的(1-2)的元素
print(a[-1])
[6 7 8 9]		#输出最后一行

得到某一列的值

print(a[:,1])
[1 3 5 7]		#第一列的值
print(a[1:3,1])
[3 5]			#第一列中的(1-2)元素的值

1.8形状操作

先创建一个4*4的数组a,再变形(不会直接操作再原对象上,而是产生一个新对象)

import numpy as np
def f(x,y):
    return 2*x+y
a = np.fromfunction(f,(4,4),dtype=int)
print(a)
'''
[[0 1 2 3]
 [2 3 4 5]
 [4 5 6 7]
 [6 7 8 9]]
 '''

变成1维

print(a.ravel())      
[0 1 2 3 2 3 4 5 4 5 6 7 6 7 8 9]  

重新指定形状,但是总数要不变

print(a.reshape(2,8))   #2*8 == 4*4
[[0 1 2 3 2 3 4 5]
 [4 5 6 7 6 7 8 9]]

转置

print(a.T)
[[0 2 4 6]
 [1 3 5 7]
 [2 4 6 8]
 [3 5 7 9]]

轴交换
第一个维度表示两个二维子数组的索引,第二个维度表示每个二维子数组中的行索引,第三个维度表示每个二维子数组中的列索引。第一个维度表示两个二维子数组的索引,第二个维度表示每个二维子数组中的行索引,第三个维度表示每个二维子数组中的列索引。
[2 3]的前两个索引是(0,1)
[4 5]的前两个索引是(1,0)
交换完后就是输出的结果

import numpy as np
a = np.arange(8).reshape(2,2,2)
print(a)
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
m = a.swapaxes(0,1) 	#将第一个轴和第二个轴交换m[y][z][k] = k[x][y][z]
print(m)
[[[0 1]
  [4 5]]

 [[2 3]
  [6 7]]]

1的三个轴是(0,0,1)轴0和轴2交换之后是(1,0,0)
4的三个轴是(1,0,0)轴0和轴2交换之后是(0,0,1)
所以1和4交换了位置,其他的类似

print(a)
[[[0 1]
  [2 3]]

 [[4 5]
  [6 7]]]
 m = a.swapaxes(0,2) 
print(m)
[[[0 4]
  [2 6]]

 [[1 5]
  [3 7]]]

垂直拼装两个数组
首先列数肯定得相同

>>> import numpy as np
>>> a = np.floor(10*np.random.random((2,3))) #np.floor是向下取整的意思
>>> a
array([[6., 4., 2.],
       [4., 7., 5.]])
>>> b = np.floor(10*np.random.random((3,3)))
>>> b
array([[7., 1., 3.],
       [4., 5., 2.],
       [4., 2., 2.]])
>>> np.vstack((a,b))
array([[6., 4., 2.],
       [4., 7., 5.],
       [7., 1., 3.],
       [4., 5., 2.],
       [4., 2., 2.]])
>>>

水平拼装两个数组

>>> import numpy as np
>>> a = np.floor(10*np.random.random((2,3)))
>>> a
array([[6., 4., 2.],
       [4., 7., 5.]])
>>> b = np.floor(10*np.random.random((2,3)))
>>> b
array([[3., 9., 4.],
       [7., 2., 5.]])
>>> np.hstack((a,b))
array([[6., 4., 2., 3., 9., 4.],
       [4., 7., 5., 7., 2., 5.]])
>>>

垂直切割数组

>>> a = np.floor(10*np.random.random((4,12)))
>>> a
array([[2., 1., 2., 7., 6., 9., 0., 9., 3., 1., 2., 3.],
       [0., 0., 1., 9., 3., 5., 5., 9., 7., 1., 2., 1.],
       [5., 0., 3., 1., 3., 0., 1., 7., 6., 1., 6., 0.],
       [0., 1., 3., 2., 4., 8., 6., 7., 5., 3., 8., 7.]])
>>> np.hsplit(a,3)			#垂直切三刀
[array([[2., 1., 2., 7.],
       [0., 0., 1., 9.],
       [5., 0., 3., 1.],
       [0., 1., 3., 2.]]), 
       
array([[6., 9., 0., 9.],
       [3., 5., 5., 9.],
       [3., 0., 1., 7.],
       [4., 8., 6., 7.]]), 
       
array([[3., 1., 2., 3.],
       [7., 1., 2., 1.],
       [6., 1., 6., 0.],
       [5., 3., 8., 7.]])]

把3,4,5列切割出来

>>> np.hsplit(a,(3,6))
[array([[2., 1., 2.],
       [0., 0., 1.],
       [5., 0., 3.],
       [0., 1., 3.]]), 
       
array([[7., 6., 9.],
       [9., 3., 5.],
       [1., 3., 0.],
       [2., 4., 8.]]), 
       
array([[0., 9., 3., 1., 2., 3.],
       [5., 9., 7., 1., 2., 1.],
       [1., 7., 6., 1., 6., 0.],
       [6., 7., 5., 3., 8., 7.]])]

水平切割数组

>>> a = np.floor(10*np.random.random((4,12)))
>>> a
array([[2., 1., 2., 7., 6., 9., 0., 9., 3., 1., 2., 3.],
       [0., 0., 1., 9., 3., 5., 5., 9., 7., 1., 2., 1.],
       [5., 0., 3., 1., 3., 0., 1., 7., 6., 1., 6., 0.],
       [0., 1., 3., 2., 4., 8., 6., 7., 5., 3., 8., 7.]])
>>> np.vsplit(a,2)
[array([[2., 1., 2., 7., 6., 9., 0., 9., 3., 1., 2., 3.],
       [0., 0., 1., 9., 3., 5., 5., 9., 7., 1., 2., 1.]]), 
       
array([[5., 0., 3., 1., 3., 0., 1., 7., 6., 1., 6., 0.],
       [0., 1., 3., 2., 4., 8., 6., 7., 5., 3., 8., 7.]])]
>>>

把1,2行切割出来

>>> np.vsplit(a,(1,3))
[array([[2., 1., 2., 7., 6., 9., 0., 9., 3., 1., 2., 3.]]), 

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

1.9布尔索引和花式索引

布尔索引:使用布尔数组作为索引
相当于一个过滤的作用

>>> a = np.array([1,2,3,4,5,6])
>>> b = np.array([True,False,True,False,True,False])
>>> a[b]
array([1, 3, 5])
>>> a[b==False]
array([2, 4, 6])
>>> a >= 3
array([False, False,  True,  True,  True,  True])
>>>

花式索引:使用整数数组作为索引
(0,0) (1,0) (0,2)

>>> a = np.floor(10*np.random.random((2,4)))
>>> a
array([[3., 6., 5., 6.],
       [2., 3., 7., 2.]])
>>> a[[0,1,0],[0,0,2]]
array([3., 2., 5.])
>>>

1.10字符串索引


>>> x = np.array([('zwt',10,20),('qwe',1,2)],dtype=[('name','S10'),('age','i4'),('score','i4')])
>>> x
array([(b'zwt', 10, 20), (b'qwe',  1,  2)],
      dtype=[('name', 'S10'), ('age', '), ('score', ')])
>>> x['name']
array([b'zwt', b'qwe'], dtype='|S10')
>>> x['score']
array([20,  2])
>>>

1.11搜索匹配函数

where函数

np.where(condition[, x, y])
condition:一个布尔数组或条件表达式,指定要检查的条件。
x:可选参数,满足条件的元素的替代值。默认情况下,返回满足条件的元素的索引。
y:可选参数,不满足条件的元素的替代值。默认情况下,返回满足条件的元素的索引

>>> import numpy as np
>>> arr = np.array([1, 2, 3, 4, 5])
>>> arr
array([1, 2, 3, 4, 5])
>>> indices = np.where(arr > 2)
>>> indices
(array([2, 3, 4], dtype=int64),)
>>> indices = np.where(arr > 2, 1, 0)
>>> indices
array([0, 0, 1, 1, 1])
>>>

1.12排序

使用sort对数组/数组某一维度进行就地排序(会修改数组本身)
默认对最后一个轴进行排序,也可以选择对其他轴排序

>>> a = np.floor(10*np.random.random((3,3)))
>>> a
array([[4., 3., 9.],
       [8., 5., 7.],
       [8., 3., 7.]])
>>> a.sort()
>>> a
array([[3., 4., 9.],
       [5., 7., 8.],
       [3., 7., 8.]])
>>> a.sort(0)
>>> a
array([[3., 4., 8.],
       [3., 7., 8.],
       [5., 7., 9.]])       
>>>

你可能感兴趣的:(python学习,numpy,python,学习,笔记)