numpy知识点总结

78 阅读 0 评论 52 点赞

我是靠谱客的博主谨慎大山，最近开发中收集的这篇文章主要介绍numpy知识点总结，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

如何创建numpy数组？
数组和列表的区别？
数组的常用属性？
数组的切片和索引？
数组的广播机制？
常见的运算函数？
reshape(-1)的理解？
numpy矩阵的tranpose（）函数
numpy其他知识点补充

通过对以上问题的总结，全面了解numpy的基础知识

对于学习AI的同学来说，numpy是最最最常见和常用的，这次做一个个小总结，希望帮助大家省些时间。

1.创建数组通常有三种形式，第一种用列表调用np.array（）函数，第二种可以用arrange()函数生成有序的数组。第三种调用random模块进行随机生成数组

import numpy
import numpy as np
a = np.array([[4,5,6,],[1,2,3]])
b = [1,2,3]
print(a,b)
c = np.arange(24).reshape(2,3,4)
print(c)
d = np.random.random((4,5))
d
[[4 5 6]
[1 2 3]] [1, 2, 3]
[[[ 0
1
2
3]
[ 4
5
6
7]
[ 8
9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
import numpy
import numpy as np
a = np.array([[4,5,6,],[1,2,3]])
b = [1,2,3]
print(a,b)
c = np.arange(24).reshape(2,3,4)
print(c)
d = np.random.random((4,5))
d
[[4 5 6]
[1 2 3]] [1, 2, 3]
[[[ 0
1
2
3]
[ 4
5
6
7]
[ 8
9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
30
array([[0.35931087, 0.69348489, 0.91524303, 0.63752601, 0.99038298],
[0.03972497, 0.74238354, 0.13656875, 0.23698837, 0.28183197],
[0.5167193 , 0.10393672, 0.16264469, 0.69440481, 0.40414247],
[0.70334329, 0.81937474, 0.67459084, 0.82530735,

2.数组和列表的区别

数组中的元素类型必须统一，

list 是一个指针数组，所以可以存放指向各种数据类型的指针，这就是 list 可以存放不通数据结构元素的根本原因，列表可以存放不同类型的数据

Numpy 数组是一块连续的内存块，用来存放同一类型的数据，当你存放的数据类型确定了，你的内存步幅就确定了，他的本质是数组，所以只能存放同一类型的元素。

3.数组的常用属性

numpy数组通常拥有几个常规类型的属性

import numpy as np
a = np.arange(24).reshape(4,6)
print(a.shape) #形状
print(a.ndim) #维度
print(a.size) #个数多少
(4, 6)
2
24

4.numpy的切片和索引

numpy和list列表一样都存在索引和切片，区别为numpy的数组通常维度很高很难读出切片和索引以下举例为：

首先为一维：

a = np.arange(12)
print(a)
print(a[0],a[-1],a[2:],a[1:-2:2])
[ 0
1
2
3
4
5
6
7
8
9 10 11]
0 11 [ 2
3
4
5
6
7
8
9 10 11] [1 3 5 7 9]

其结果和列表完全相同

二维：

b = a.reshape(3,4)
print(b)
b[::2,3]
[[ 0
1
2
3]
[ 4
5
6
7]
[ 8
9 10 11]]
array([ 3, 11]

首先是行成三行四列的一个矩阵，解读b[::2,3]，首先，在逗号之前的为行，逗号之后的为列

b[::2,]，[::2]表示隔一行取一行，所以得到[0 1 2 3]和[ 8 9 10 11] ，在逗号之后索引3，表示的事矩阵的第三列[3 7 11]两者取并集得到结果[3,11]

接下来取3维依次类推

a = np.arange(12)
b = a.reshape(2,2,3)
print(b)
[[[ 0
1
2]
[ 3
4
5]]
[[ 6
7
8]
[ 9 10 11]]]
b[0:,:-1,::2]
array([[[0, 2]],
[[6, 8]]]

根据这个三维数组，可以分析切片b[0：,：-1，：：2]，从第一个逗号分析，得出取全部两个子数组

[[ 0
1
2]
[ 3
4
5]]
[[ 6
7
8]
[ 9 10 11]]

之后取第二个逗号的数组，：-1取到除最后一行的所有元素，所以第二个逗号取到

[ 0
1
2]

[ 6
7
8]

最后根据地三个逗号，获取到：第0列和第2列，等到结果

或者可以表示为

b[...,:-1,::2]所得结果相同

a = np.arange(12)
b = a.reshape(2,2,3)
print(b)
b[[0,1,1],[1,0,1]]
[[[ 0
1
2]
[ 3
4
5]]
[[ 6
7
8]
[ 9 10 11]]]
array([[ 3,
4,
5],
[ 6,
7,
8],
[ 9, 10, 11]])

首先，根据坐标定位，[0,1]应该为第一个
[ 3 4 5]]

第二个[1,0]表示[6,7,8]

第三个表示[1,1],表示[9,10,11]

5.广播机制：

广播机制，形状相同的数组可以做数学运算（+_*/）
不同形状：不一定一定不可以数学运算，能触发广播机制的可以
什么是广播机制？如何触发？
可以让满足一定条件的不同形状数组做数学运算
从右边往左边比较，只要满足大小相同（具体的数字相同或者其中有
一个数字为1 ）则比较下一位，直到维度少的数组位置，都满足
相同，则可以触发广播机制

a = np.arange(12).reshape(2,6)
b = np.arange(12).reshape(3,4)
c = np.arange(12).reshape(2,1,6)
d = np.arange(12).reshape(6,2)
e = np.arange(12).reshape(1,1,1,1,2,6)
h = np.arange(1,13).reshape(2,6)
print(a+c)
print(a+e)
print(a+h)
print(c+e)
[[[ 0
2
4
6
8 10]
[ 6
8 10 12 14 16]]
[[ 6
8 10 12 14 16]
[12 14 16 18 20 22]]]
[[[[[[ 0
2
4
6
8 10]
[12 14 16 18 20 22]]]]]]
[[ 1
3
5
7
9 11]
[13 15 17 19 21 23]]
[[[[[[ 0
2
4
6
8 10]
[ 6
8 10 12 14 16]]
[[ 6
8 10 12 14 16]
[12 14 16 18 20 22]]]]]]

6.常见的运算

#np。multiply和np.dot的区别
#np.multiply数组对应元素相乘和*一样
#np.dot是矩阵相乘
a = np.array([[1,2,3],[4,5,6]])
b = np.array([[1,2,3],[4,5,6]])
print(np.multiply(a,b))
print(np.dot(a,b.T))
[[ 1
4
9]
[16 25 36]]
[[14 32]
[32 77]]

multiply是各个元素相乘相加，dot为矩阵乘法

统计函数
import numpy as np
a = np.array([[3,7,5],[1,5,8],[6,2,9]])
print(a)
print(np.min(a),np.min(a,0),np.min(a,1))
#最大同理
#标准差
#方差
[[3 7 5]
[1 5 8]
[6 2 9]]
1 [1 2 5] [3 1 2]

a = np.array([[4,5],[7,1]])
print(np.sort(a,axis=0))
#argsort()
x = np.array([3,4,1])
y = np.argsort(x)
y
[[4 1]
[7 5]]
array([2, 0, 1], dtype=int64)

import numpy as np
x=np.arange(9).reshape(3,3)
print(x)
y = np.where(x>3)
print(y)
print(x[y])
[[0 1 2]
[3 4 5]
[6 7 8]]
(array([1, 1, 2, 2, 2], dtype=int64), array([1, 2, 0, 1, 2], dtype=int64))
[4 5 6 7 8]

7理解reshape(-1)

这个问题，其实，蛮难理解的，reshape(-1)，存在自我运算的机制，根据公式去进行。

import numpy as np
m = np.arange(1,11).reshape(2,5,-1)
#-1等于m.size/（10*10）=1
print(m)
n = m.reshape(5,-1)
#这里-1表示m.size/(5)=6
n.shape
print(n)
b = m.reshape(-1)
print(b)
[[[ 1]
[ 2]
[ 3]
[ 4]
[ 5]]
[[ 6]
[ 7]
[ 8]
[ 9]
[10]]]
[[ 1
2]
[ 3
4]
[ 5
6]
[ 7
8]
[ 9 10]]
[ 1
2
3
4
5
6
7
8
9 10]

8.理解transpose()

在不进行任何操作的时候执行转置操作。

import numpy as np
arr = np.arange(12).reshape(3,4)
print(arr)
arr = np.transpose(arr)
print(arr)
#0变化
arr = arr.reshape(2,2,3)
print(arr)
#设正常的索引为（x,y,z）=（0,1,2）
arr = np.transpose(arr,(1,0,2))
#通过改变小x,y的位置得到如下
print("*******")
print(arr)
#原本2的位置对应为（1,0,0）
#改变后为（0,1,0）
#依次类推，每个元素的坐标都按照transpose中，进行坐标替换得到
[[ 0
1
2
3]
[ 4
5
6
7]
[ 8
9 10 11]]
[[ 0
4
8]
[ 1
5
9]
[ 2
6 10]
[ 3
7 11]]
[[[ 0
4
8]
[ 1
5
9]]
[[ 2
6 10]
[ 3
7 11]]]
*******
[[[ 0
4
8]
[ 2
6 10]]
[[ 1
5
9]
[ 3
7 11]]]

def set_printoptions(precision=None, threshold=None, edgeitems=None,
linewidth=None, suppress=None, nanstr=None, infstr=None,
formatter=None, sign=None, floatmode=None, **kwarg):