说明
本文代码运行环境
- macOS 10.13.1
- python 3.7
- Numpy 1.15.4
numpy安装与引用
conda安装numpy
conda install -c anaconda numpy
引入numpy
import numpy as np
生成数组
什么是数组
数组与列表区别
数组只能存储一种类型数据，列表可以存储任意类型的数据
存储其他类型报错
#导入数组
import array
#初始化类型为int数组
a = array.array('i',range(10))
#将数组设置非int类型值，则报错
a[1] = 's'
#报错，类型错误
#output:
TypeError: an integer is required (got type str)
指定元素值生成数组
列表转化数组
a = list(range(10))
array_from_list = np.array(a)
print(a)
print(array_from_list)
print(type(array_from_list))
#output:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0 1 2 3 4 5 6 7 8 9]
<class 'numpy.ndarray'>
生成全为零的数组
a = np.zeros(10)
print(type(a))
#默认为float类型
print(a.dtype)
#output:
<class 'numpy.ndarray'>
float64
指定dtype
a = np.zeros(10,dtype=int)
print(type(a))
print(a.dtype)
#output:
<class 'numpy.ndarray'>
int64
生成m行n列矩阵，元素全为0
a = np.zeros((4,4),dtype=int)
print(a)
#output:
[[0 0 0 0]
[0 0 0 0]
[0 0 0 0]
[0 0 0 0]]
生成m行n列矩阵，元素全为1
a = np.ones((4,4))
print(a)
#output:
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
生成m行n列矩阵，元素全为指定元素k
a = np.full((4,4),1.5)
print(a)
#output:
[[1.5 1.5 1.5 1.5]
[1.5 1.5 1.5 1.5]
[1.5 1.5 1.5 1.5]
[1.5 1.5 1.5 1.5]]
根据已有数组的结构，生成数组
np.zeros_like(a)
#output:
array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
np.ones_like(a)
#output:
array([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
np.full_like(a,3.14)
#output:
array([[3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14]])
随机生成数组
#随机生成5~10中整数
print(random.randint(5,10))
#随机生成[0,1)小数
print(random.random())
生成m * n 随机数组
np.random.random((3,3))
#output:
array([[0.50300093, 0.83929887, 0.10007557],
[0.68422998, 0.8545661 , 0.35985938],
[0.77191599, 0.6631718 , 0.62946225]])
指定最大值，最小值，生成m*n维元素全为整数的随机数组
np.random.randint(0,10,(3,3))
#output:
array([[7, 7, 6],
[4, 8, 4],
[6, 9, 4]])
以特定步长取值
从0到10，步长为2取值
print(list(range(0,10,2)))
#output:
[0, 2, 4, 6, 8]
#np的步长取值
np.arange(0,10,2)
#output:
array([0, 2, 4, 6, 8])
以均匀步长取值
#从0到3以均匀步长取10个值
np.linspace(0,3,10)
#output:
array([0. , 0.33333333, 0.66666667, 1. , 1.33333333,
1.66666667, 2. , 2.33333333, 2.66666667, 3. ])
生成斜对角为1其余值为零的二维数组
np.eye(5)
#output:
array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
数据类型
访问数组
嵌套列表的数据访问
var = [[1,2,3],[4,5,6],[7,8,9]]
print(var[0])
print(var[0][0])
#output:
[1, 2, 3]
1
访问数组第一行第一列数据
a = np.array(var)
print(a)
print(a[0][0])
#你可以这样访问
#print(a[0,0])
#output:
[[1 2 3]
[4 5 6]
[7 8 9]]
1
访问数组最后一行第一列数据
print(a[-1][0])
#你可以这样访问
#print(a[-1,0])
#output:
7
数组切片
#取前两行，前两列的数据
print(a[:2,:2])
#output:
array([[1, 2],
[4, 5]])
#取三行，第一列的数据
print(a[:3,:1])
#output:
array([[1],
[4],
[7]])
数组属性
数组维度
#生成个2维数组
m = np.random.randint(0,10,(3,3))
#生成个3维数组
n = np.random.randint(0,10,(2,4,2))
#生成个4维数组
k = np.random.randint(0,10,(1,10,5,5))
print(m.ndim)
print(n.ndim)
print(k.ndim)
#output:
2
3
4
数组Shape
shape，返回的是一个元组，元组中的元素是数组对应维度的数据长度
print(m.shape)
print(n.shape)
print(k.shape)
#output:
(3, 3)
(2, 4, 2)
(1, 10, 5, 5)
数组大小
#数组的元素总个数
print(m.size)
print(n.size)
print(k.size)
#output:
9
16
250
#数组第一维度元素总个数
print(np.size(m,0))
print(np.size(n,0))
print(np.size(k,0))
#output:
3
2
1
#数组第二维度元素总个数
print(np.size(m,1))
print(np.size(n,1))
print(np.size(k,1))
#output:
3
4
10
#数组第三维度元素总个数
print(np.size(m,2))
print(np.size(n,2))
print(np.size(k,2))
#报错，因为数组m没有第三维度
#output:
IndexError: tuple index out of range
数组的数据类型
print(a.dtype)
#output:
int64
数组中元素的字节数
x = np.array([1,2,3], dtype=np.float64)
x.itemsize
#output:
8
x = np.array([1,2,3], dtype=np.complex128)
x.itemsize
#output:
16
数组中元素占用的总字节数
print(a.nbytes)
# 9 elements * 8 bytes one element
#output:
72
数组操作
数组每个元素加上特定值
a = np.full((3,3),1.0,dtype=float)
a+10
#等价于
#np.add(a,10)
#output:
array([[11., 11., 11.],
[11., 11., 11.],
[11., 11., 11.]])
数组元素操作对应表
| 操作符 | 对应np方法名 | 描述 |
|---|---|---|
| + | np.add | 加 |
| - | np.subtract | 减 |
| * | np.multiply | 乘 |
| / | np.divide | 除 |
| ** | np.power | 平方 |
| % | np.mod | 取模 |
数组元素取sin值
a = np.linspace(0,np.pi,20)
b = np.sin(a)
print(a)
print(b)
#output:
[0. 0.16534698 0.33069396 0.49604095 0.66138793 0.82673491
0.99208189 1.15742887 1.32277585 1.48812284 1.65346982 1.8188168
1.98416378 2.14951076 2.31485774 2.48020473 2.64555171 2.81089869
2.97624567 3.14159265]
[0.00000000e+00 1.64594590e-01 3.24699469e-01 4.75947393e-01
6.14212713e-01 7.35723911e-01 8.37166478e-01 9.15773327e-01
9.69400266e-01 9.96584493e-01 9.96584493e-01 9.69400266e-01
9.15773327e-01 8.37166478e-01 7.35723911e-01 6.14212713e-01
4.75947393e-01 3.24699469e-01 1.64594590e-01 1.22464680e-16]
数组求和
a = np.full(10,2.3)
print(sum(a))
a = np.array([[1,2],[3,4]])
print(sum(a))
#求总和
print(np.sum(a))
#求横轴对应元素的和
print(np.sum(a,axis=0))
#求纵轴对应元素的和
print(np.sum(a,axis=1))
#output:
23.000000000000004
[4 6]
10
[4 6]
[3 7]
Notebook使用技巧
$timeit 用于测试代码的执行效率
$timeit sum(a)
#output:
2.34 µs ± 131 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
比较数组中每个值与特定值的大小
a = np.array(range(10))
print(a >= 3)
print(a != 3)
#output:
[False False False True True True True True True True]
[ True True True False True True True True True True]
#判断是否每个元素都大于某特定值
np.all(a>-1)
#output:
True
#判断是否某个元素大于某特定值
np.any(a>-1)
#output:
True
数组元素比较对应表
| 操作符 | 对应np方法名 | 描述 |
|---|---|---|
| == | np.equal | 等于 |
| > | np.greater | 大于 |
| < | np.less | 小于 |
| != | np.not_equal | 不等于 |
| >= | np.greater_equal | 大于等于 |
| <= | np.less_equal | 小于等于 |
变形
#将2x10数组变形为4x5,变形前提是变形后元素数量相同
a = np.full((2,10),3.14,dtype=float)
a.reshape(4,5)
#output:
array([[3.14, 3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14, 3.14],
[3.14, 3.14, 3.14, 3.14, 3.14]])
a.reshap(4,6)
#output:
ValueError: cannot reshape array of size 20 into shape (4,6)
axis
axis，中文为轴。
轴是个整型值，代表轴几的意思。一个二维数组，行为轴0，列为轴1，如下图所示，图片来自Google picture
l = [[1,3,2],
[4,6,5],
[9,8,7]
]
a = np.array(l)
print(a[0][0])
#output:
1
如上代码，对于二维数组，在取值时,a[0][0],第一个索引[0]便是轴0(axis=0),第二个索引[0]表示轴1(axis=1)
排序
l = [[1,3,2],
[4,6,5],
[9,8,7]
]
a = np.array(l)
np.sort(a)
#output:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
#不改变原数组的值
a
#output:
array([[1, 3, 2],
[4, 6, 5],
[9, 8, 7]])
#将元素按着轴1的方向排序(横向排序)
l = [[1,3,2],
[9,8,7],
[4,5,6]
]
a = nn.array(l)
a.sort(axis=1)
a
#output:
array([[1, 2, 3],
[7, 8, 9],
[4, 5, 6]])
#将元素按着轴0的方向排序(纵向排序)
a.sort(axis=0)
#output:
array([[1, 3, 2],
[4, 5, 6],
[9, 8, 7]])
拼接
b = np.array([[0,2,4],[1,3,5]])
#将元素按着轴0的方向拼接(纵向拼接)
np.concatenate([b,b,b],axis=0)
#output:
array([[0, 2, 4],
[1, 3, 5],
[0, 2, 4],
[1, 3, 5],
[0, 2, 4],
[1, 3, 5]])
#将元素按着轴1的方向拼接(横向拼接)
np.concatenate([b,b,b],axis=1)
#output:
array([[0, 2, 4, 0, 2, 4, 0, 2, 4],
[1, 3, 5, 1, 3, 5, 1, 3, 5]])
4665
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
