python 创建空的numpy数组_python数据分析包|NumPy-01
详细介绍数据分析基础包： Numpy的基础使用方法。
欢迎微信随缘关注@pythonic生物人
本篇您将学到什么？
1、numpy简介
2、numpy数组ndarray使用
创建numpy数组ndarray
array函数借助列表（list）创建一维数组
array函数借助列表（list）创建二维数组
array函数借助元组（tuple）创建数组
arange函数创建数组
empty函数创建空数组
zeros函数创建元素全为0的数组
ones函数创建元素全为1的数组
full函数创建某个元素填充的数组
eye函数创建对角线为1的数组
其它创建数组的方式
numpy数据类型
numpy数组属性
dtype指定numpy数组数据类型
dtype查看numpy数组数据类型
astype转换numpy数组数据类型
ndim查看numpy数组的维度
shape查看numpy数组的形状
size查看numpy数组的大小（总元素数目）
numpy数组操作
一维数组索引
二维数组索引
三维数组索引
利用布尔值索引
利用布尔索引修改数组值
通过整数数组使用花式索引（Fancy indexing）
通过take函数使用花式索引
利用索引修改数组值
一维数组切片
二维数组切片
numpy数组拼接（concatenate/vstack/hstack）
split拆分数组
arange函数借助reshape创建数组
repeat产生更大数组（沿着0轴或者1轴的某行或某列为单位）
tile产生更大数组（整个数组为重复单位）
any判断数组元素是否至少有一个True
判断数组元素是否都是False
unique函数去数组重复元素
其它去重函数
numpy数组计算
numpy的统计方法
numpy中的线性代数运算
随机数生成（np.random）1、numpy简介
NumPy，Numerical Python的简称，NumPy与各包之间的关系，见下图；
NumPy的数组（N维数组对象，即numpy.ndarray）是多数pyhton科学计算包的构建基础；
可以直接对ndarray进行复杂数学运算，而不必借助循环或者推导式；
相比于python的内置序列，ndarray使用的内存更少；
理解numpy.ndarray的功能有助于更高效的使用Pandas等包；
关于numpy中任何函数的使用方法，点击网址：https://numpy.org/doc/stable/，搜索即可见详细文档：
Python中导入numpy模块，Python社区，习惯将numpy模块的名称简写为np，导入方式如下：
In [6]: import numpy as np
2、numpy数组ndarray使用
创建numpy数组ndarray
- array函数借助列表（list）创建一维数组
语法：np.array(list)
In [7]: np.array([1,2,3,4])
Out[7]: array([1, 2, 3, 4])
- array函数借助列表（list）创建二维数组
In [3]: np.array([[1,2,3,4],[2,3,4,5]])
Out[3]:
array([[1, 2, 3, 4],
[2, 3, 4, 5]])
- array函数借助元组（tuple）创建数组
语法：np.array((tuple))
In [8]: np.array((1,2,3,4))
Out[8]: array([1, 2, 3, 4])
- arange函数创建数组
语法：numpy.arange(start，stop, step，dtype=None)
start，起始值，默认为0，可选
stop，终止值
step，步长，默认为1
dtype，数据类型
In [27]: np.arange(7)#不包含7
Out[27]: array([0, 1, 2, 3, 4, 5, 6])
In [29]: np.arange(3,7,2)
Out[29]: array([3, 5])
- empty函数创建空数组
创建一个元素未被初始化（uninitialized “garbage” values）的数组。
语法：numpy.empty(shape, dtype=float, order='C')
shape，数组形状，int or tuple of int
dtype，数据类型，默认为numpy.float64.
order，数组填充顺序，行优先（C）或者列优先（F），默认为 C
In [10]: np.empty(5)
Out[10]:
array([8.20939596e-315, 9.84800637e-312, 0.00000000e+000, 8.19903220e-315,
0.00000000e+000])
In [11]: np.empty((2,3))
Out[11]:
array([[0., 0., 0.],
[0., 0., 0.]])
- zeros函数创建元素全为0的数组
语法：numpy.zeros(shape, dtype=float, order='C')
In [16]: np.zeros(3)
Out[16]: array([0., 0., 0.])
In [17]: np.zeros((2,3))
Out[17]:
array([[0., 0., 0.],
[0., 0., 0.]])
- ones函数创建元素全为1的数组
语法：numpy.ones(shape, dtype=None, order='C')
In [18]: np.ones(3)
Out[18]: array([1., 1., 1.])
In [19]: np.ones((2,3))
Out[19]:
array([[1., 1., 1.],
[1., 1., 1.]])
- full函数创建某个元素填充的数组
语法：numpy.full(shape, fill_value, dtype=None, order='C')
shape，数组形状
fill_value，填充值
dtype，数据类型
order，填充顺序，默认为行优先（C），否则列优先（F）
In [32]: np.full((5, 2), 20200531)
Out[32]:
array([[20200531, 20200531],
[20200531, 20200531],
[20200531, 20200531],
[20200531, 20200531],
[20200531, 20200531]])
- eye函数创建对角线为1的数组
In [38]: np.eye(5)
Out[38]:
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.]])
In [37]: np.eye(5,4)
Out[37]:
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.],
[0., 0., 0., 0.]])
- 其它创建数组的方式
numpy有大量创建数组的函数，详细戳：https://numpy.org/doc/1.18/reference/routines.array-creation.html#routines-array-creation
numpy数据类型
以下展示部分，详细戳： https://numpy.org/doc/1.18/user/basics.types.html
数据类型 描述
bool_ 布尔值（真、True 或假、False），用一个字节存储
int_ 默认整型（类似于 C 语言中的 long，通常情况下是 int64 或 int32）
intc 同 C 语言的 int 相同（通常是 int32 或 int64）
intp 用作索引的整型（和 C 语言的 ssize_t 相同，通常情况下是 int32 或 int64）
int8 字节（byte，范围从 –128 到 127）
int16 整型（范围从 –32768 到 32767）
int32 整型（范围从 –2147483648 到 2147483647）
int64 整型（范围从 –9223372036854775808 到 9223372036854775807）
uint8 无符号整型（范围从 0 到 255）
uint16 无符号整型（范围从 0 到 65535）
uint32 无符号整型（范围从 0 到 4294967295）
uint64 无符号整型（范围从 0 到 18446744073709551615）
float_ float64 的简化形式
float16 半精度浮点型：符号比特位，5 比特位指数（exponent），10 比特位尾数（mantissa）
float32 单精度浮点型：符号比特位，8 比特位指数，23 比特位尾数
float64 双精度浮点型：符号比特位，11 比特位指数，52 比特位尾数
complex_ complex128 的简化形式
complex64 复数，由两个 32 位浮点数表示
complex128 复数，由两个 64 位浮点数表示
numpy数组属性
- dtype指定numpy数组数据类型
In [17]: np.array([1,2,3],dtype='float64')#dtype指定数据类型
Out[17]: array([1., 2., 3.])
- dtype查看numpy数组数据类型
In [16]: np.array([1,2,3],dtype='float64').dtype#括号外dtype查看数据类型
Out[16]: dtype('float64')
- astype转换numpy数组数据类型
In [21]: np.array([1,2,3],dtype='float64').astype('int32')#astype转换数据类型为int32
Out[21]: array([1, 2, 3])
- ndim查看numpy数组的维度
In [41]: np.ones((2,1,2)).ndim#查看三维数组的维度
Out[41]: 3
In [42]: np.ones((2,)).ndim#查看一维数组维度
Out[42]: 1
- shape查看numpy数组的形状
返回一个tuple
In [43]: np.ones((2,1,2)).shape
Out[43]: (2, 1, 2)
In [44]: np.ones((2,)).shape
Out[44]: (2,)
- size查看numpy数组的大小（总元素数目）
In [148]: np.random.randn(2, 2)#创建一个2维随机数数组
Out[148]:
array([[ 1.22543299, -1.55108322],
[-1.45944234, 1.03853137]])
In [149]: np.random.randn(2, 2).size
Out[149]: 4
numpy数组操作
- 一维数组索引
与python中的list，string索引一样。
- 二维数组索引
In [55]: np.arange(6).reshape(2,3)
Out[55]:
array([[0, 1, 2],
[3, 4, 5]])
In [56]: np.arange(6).reshape(2,3)[0][1]#取出第一行第二个元素
Out[56]: 1
In [58]: np.arange(6).reshape(2,3)[0,1]#等价于上面方法
Out[58]: 1
- 三维数组索引
In [64]: np.arange(30).reshape(2,3,5)
Out[64]:
array([[[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]],
[[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24],
[25, 26, 27, 28, 29]]])
In [65]: np.arange(30).reshape(2,3,5)[0]
Out[65]:
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
- 利用布尔值索引
In [81]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
In [82]: data = np.random.randn(7, 4)
In [83]: names == 'Bob'
Out[83]: array([ True, False, False, True, False, False, False])
In [84]: data[names == 'Bob']#names的长度必须与data的列数相同
Out[84]:
array([[-1.8653866 , -1.19338385, -0.41261043, 0.3738265 ],
[-1.31116172, 0.30590346, -1.78701343, 0.97881115]])
In [85]: data[~(names == 'Bob')]#利用~取反，等价于!=
Out[85]:
array([[-1.38267468, 1.76340527, 0.77059621, -0.59177404],
[-1.34254353, 1.13842461, -0.45519978, 0.30491083],
[ 0.5932616 , -1.47068615, -0.2197892 , 0.1454878 ],
[-0.85105165, -0.3954181 , -0.33781022, 1.11844449],
[-0.17161047, -0.44451218, -1.7549707 , -2.15973562]])
In [86]: data[(names == 'Bob') | (names == 'Will')]#多个布尔运算符[&（和）、|（或）]连用索引。不能使用and和or。
Out[86]:
array([[-1.8653866 , -1.19338385, -0.41261043, 0.3738265 ],
[-1.34254353, 1.13842461, -0.45519978, 0.30491083],
[-1.31116172, 0.30590346, -1.78701343, 0.97881115],
[ 0.5932616 , -1.47068615, -0.2197892 , 0.1454878 ]])
- 利用布尔索引修改数组值
In [87]: data[data < 0] = 0#data中元素小于0的全部替换为0
In [88]: data
Out[88]:
array([[0. , 0. , 0. , 0.3738265 ],
[0. , 1.76340527, 0.77059621, 0. ],
[0. , 1.13842461, 0. , 0.30491083],
[0. , 0.30590346, 0. , 0.97881115],
[0.5932616 , 0. , 0. , 0.1454878 ],
[0. , 0. , 0. , 1.11844449],
[0. , 0. , 0. , 0. ]])
- 通过整数数组使用花式索引（Fancy indexing）
总是返回一个一维数组。
In [93]: arr = np.arange(32).reshape((8, 4))
In [94]: arr
Out[94]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23],
[24, 25, 26, 27],
[28, 29, 30, 31]])
In [95]: arr[[1, 5, 7, 2], [0, 3, 1, 2]]#返回(1,0)、(5,3)、(7,1)和(2,2)位置处元素。
Out[95]: array([ 4, 23, 29, 10])
- 通过take函数使用花式索引
这里和通过整数数组花式索引有区别
In [57]: arr.take([[1, 5, 7, 2], [0, 3, 1, 2]], axis=0)#可以传入对那个轴索引，传入二维数组，则输出二维数组
Out[57]:
array([[[ 4, 5, 6, 7],
[20, 21, 22, 23],
[28, 29, 30, 31],
[ 8, 9, 10, 11]],
[[ 0, 1, 2, 3],
[12, 13, 14, 15],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]]])
- 利用索引修改数组值
In [68]: arr3d = np.arange(30).reshape(2,3,5)
In [69]: arr3d
Out[69]:
array([[[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]],
[[15, 16, 17, 18, 19],
[20, 21, 22, 23, 24],
[25, 26, 27, 28, 29]]])
In [70]: arr3d[0] = 1314
In [71]: arr3d
Out[71]:
array([[[1314, 1314, 1314, 1314, 1314],
[1314, 1314, 1314, 1314, 1314],
[1314, 1314, 1314, 1314, 1314]],
[[ 15, 16, 17, 18, 19],
[ 20, 21, 22, 23, 24],
[ 25, 26, 27, 28, 29]]])
- 一维数组切片
与python中list，string切片类似。
- 二维数组切片
In [74]: np.arange(1,10).reshape(3,3)
Out[74]:
array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
In [78]: np.arange(1,10).reshape(3,3)[:2, 1:]#[:2, 1:]逗号前限制行，逗号后限制列
Out[78]:
array([[2, 3],
[5, 6]])
其它的一些例子
- numpy数组拼接（concatenate/vstack/hstack）
numpy.concatenate可以按指定轴（axis=0或者1）将一个由数组组成的序列（如元组、列表等）连接到一起。numpy中的轴0和轴1如下图。
In [115]: arr1 = np.array([[1, 2, 3], [4, 5, 6]])
In [116]: arr2 = np.array([[7, 8, 9], [10, 11, 12]])
In [117]: np.concatenate([arr1, arr2], axis=0)
Out[117]:
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])
In [118]: np.concatenate([arr1, arr2], axis=0)
Out[118]:
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])
#等价于：
In [120]: np.vstack((arr1, arr2))
Out[120]:
array([[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]])
In [119]: np.concatenate([arr1, arr2], axis=1)
Out[119]:
array([[ 1, 2, 3, 7, 8, 9],
[ 4, 5, 6, 10, 11, 12]])
#等价于：
In [121]: np.hstack((arr1, arr2))
Out[121]:
array([[ 1, 2, 3, 7, 8, 9],
[ 4, 5, 6, 10, 11, 12]])
- split拆分数组
In [122]: arr = np.random.randn(5, 2)
In [123]: arr
Out[123]:
array([[ 1.11164491, 0.08360515],
[ 0.64533294, -0.06500025],
[ 2.02772361, -0.12831337],
[ 1.20166079, -1.12280857],
[-1.75115202, -0.66202488]])
In [124]: first, second, third = np.split(arr, [1, 3])#[1,3],指定arr[1],arr[3]处拆分arr数组
In [125]: first
Out[125]: array([[1.11164491, 0.08360515]])
In [126]: second
Out[126]:
array([[ 0.64533294, -0.06500025],
[ 2.02772361, -0.12831337]])
In [127]: third
Out[127]:
array([[ 1.20166079, -1.12280857],
[-1.75115202, -0.66202488]])
- arange函数借助reshape创建数组
In [112]: np.arange(12).reshape((3, 4),order='F')
Out[112]:
array([[ 0, 3, 6, 9],
[ 1, 4, 7, 10],
[ 2, 5, 8, 11]])
In [113]: np.arange(12).reshape((3, 4),order='C')
Out[113]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
In [114]: np.arange(12).reshape((3, 4))#默认行优先（按行填充）
Out[114]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
C与F区别，见下图：
- repeat产生更大数组（沿着0轴或者1轴的某行或某列为单位）
In [135]: arr1 = np.random.randn(2, 2)
In [136]: arr1
Out[136]:
array([[ 0.73228467, -0.80587163],
[-1.88009575, 1.51073337]])
In [138]: arr1.repeat(2, axis=0)#沿着0轴重复两次
Out[138]:
array([[ 0.73228467, -0.80587163],
[ 0.73228467, -0.80587163],
[-1.88009575, 1.51073337],
[-1.88009575, 1.51073337]])
In [140]: arr1.repeat([2, 3], axis=0)#沿着0轴重复2次，再重复3次
Out[140]:
array([[ 0.73228467, -0.80587163],
[ 0.73228467, -0.80587163],
[-1.88009575, 1.51073337],
[-1.88009575, 1.51073337],
[-1.88009575, 1.51073337]])
- tile产生更大数组（整个数组为重复单位）
与repeat不同，title直接以整个数组为单位重复。
In [144]: arr
Out[144]:
array([[ 1.16084593, -0.09869962],
[-0.21193357, -0.86409564]])
In [145]: np.tile(arr, 2)
Out[145]:
array([[ 1.16084593, -0.09869962, 1.16084593, -0.09869962],
[-0.21193357, -0.86409564, -0.21193357, -0.86409564]])
In [146]: np.tile(arr, (2, 1))
Out[146]:
array([[ 1.16084593, -0.09869962],
[-0.21193357, -0.86409564],
[ 1.16084593, -0.09869962],
[-0.21193357, -0.86409564]])
In [147]: np.tile(arr, (3, 2))
Out[147]:
array([[ 1.16084593, -0.09869962, 1.16084593, -0.09869962],
[-0.21193357, -0.86409564, -0.21193357, -0.86409564],
[ 1.16084593, -0.09869962, 1.16084593, -0.09869962],
[-0.21193357, -0.86409564, -0.21193357, -0.86409564],
[ 1.16084593, -0.09869962, 1.16084593, -0.09869962],
[-0.21193357, -0.86409564, -0.21193357, -0.86409564]])
- any判断数组元素是否至少有一个True
In [100]: bools = np.array([False, False, True, False])
In [101]: bools.any()
Out[101]: True
- 判断数组元素是否都是False
In [102]: bools.all()
Out[102]: False
- unique函数去数组重复元素
In [103]: names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
In [104]: np.unique(names)
Out[104]: array(['Bob', 'Joe', 'Will'], dtype='- 其它去重函数
函数 说明
unique(x) 计算x单一的元素，并对结果排序
intersect1d(x, y) 计算x和y相同的元素，并对结果排序
union1d 结合x和y的元素，并对结果排序
in1d(x, y) 得到一个布尔数组指示x中的每个元素是否在y中
setdiff1d(x, y) 差集，在x中但不再y中的集合
setxor1d(x, y) 对称差集，不同时在两个数组中的元素
numpy数组计算
numpy.ndarray的元素级（不用使用循环，直接作用于每个元素）函数：
函数 说明
【一元数组函数】
abs、fabs 计算整数、浮点数或复数的绝对值。对于复数数值，可以使用更快的fabs
sqrt 计算各元素的平方根
square 计算各元素的平方
exp 计算各元素的指数e^x
log、log10、log2、log1p 分别为自然对数、底数为10的log、底数为2的log、log(1 + x)
sign 计算各元素的正负号：1（正数）、0（零）、-1（负数）
ceil 计算各元素的ceiling值
floor 计算各元素的floor值
rint 四舍五入到正数，保留dtype
modf 将数组的小数和整数部分以两个独立数组的形式返回
isnan 返回一个表示“哪些值是NaN”的布尔型数组
isfinite、isinf 分别返回一个表示“哪些元素是有穷的”或“哪些元素是无穷的”的布尔型数组
cos、cosh、sin、sinh、tan、tanh 普通型和双曲型三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh 反三角函数
logical_not 计算各元素not x的真值。想到与-arr
【二元数组函数】
函数 说明
add 将数组中对应的元素相加
subtract 从第一个数组中减去第二个数组中的元素
multiply 数组元素相乘
divide、floor_divide 除法或向下圆整除法
power 对第一个数组中的元素A，根据第二个数组中的相应元素B,计算A的B次方
maximum、fmax 元素级的最大值计算。fmax忽略NaN
minmum、fmin 元素级的最小值计算。fmin忽略NaN
mod 元素级的求模计算
copysign 将第二个数组中的值得负号复制到第一个数组中的值
greate、greate_equal、less、less_equal、equal、not_equal 执行元素级的比价运算，最终产生布尔型的数组。相当于运算符>、>=、<、<=、==、!=
logical_and、logical_or、logical_xor 执行元素级的真值逻辑运算。相当于中缀运算符&
In [96]: np.sqrt(np.arange(9))#开根号
Out[96]:
array([0. , 1. , 1.41421356, 1.73205081, 2. ,
2.23606798, 2.44948974, 2.64575131, 2.82842712])
numpy的统计方法
方法 描述
sum 对数组的所有或一个轴向上的元素求和。零长度的数组的和为灵。
mean 算术平均值。灵长度的数组的均值为NaN。
std, var 标准差和方差，有可选的调整自由度（默认值为n）。
min, max 最大值和最小值
argmin, argmax 索引最小和最大元素。
cumsum 从0元素开始的累计和。
cumprod 从1元素开始的累计乘。
In [97]: np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]).cumsum(axis=0)
Out[97]:
array([[ 0, 1, 2],
[ 3, 5, 7],
[ 9, 12, 15]], dtype=int32)
numpy中的线性代数运算
常用的线性代数函数：
函数 描述
diag 返回一个方阵的对角线（或非对角线）元素为一个一维数组，或者转换一个一维数组到一个方阵（非对角线元素为零）
dot 矩阵乘积
trace 计算对角线上元素的和
det 计算矩阵行列式
eig 计算方阵的特征值和特征向量
inv 计算方阵的逆
pinv 计算方阵 Moore-Penrose 伪逆
qr 计算 QR 分解
svd 计算奇异值分解（SVD）
solve 求解线性系统方程 Ax = b 的x，其中A是一个方阵
lstsq 计算 y = Xb 的最小二乘解
x = np.array([[1., 2., 3.], [4., 5., 6.]])
y = np.array([[6., 23.], [-1, 7], [8, 9]])
np.dot(x,y)#2x3 乘3x2得2x2
In [105]: x = np.array([[1., 2., 3.], [4., 5., 6.]])
...: y = np.array([[6., 23.], [-1, 7], [8, 9]])
...: np.dot(x,y)#运用于矩阵乘法的dot函数
Out[105]:
array([[ 28., 64.],
[ 67., 181.]])
随机数生成（np.random）
np.random常用函数
函数 说明
seed 确定随机数生成数的种子
permutation 返回一个序列的随机排列或返回一个随机排列的范围
shuffle 对一个序列就地随机排列
rand 产生均匀分布的样本值
randint 从给定的上下限范围内（不包括上限）随机选取整数
randn 产生标准正态分布的样本值
binomial 产生二项分布的样本值
normal 产生正态（高斯）分布的样本值
beta 产生Beta分布的样本值
chisquare 产生卡方分布的样本值
gamma 产生Gamma分布的样本值
uniform 产生在[0,1]中均匀分布的样本值
In [106]: np.random.normal(size=(4, 4))#normal函数生成正态（高斯）分布的样本值
Out[106]:
array([[ 0.50504633, 1.54045071, 0.57667657, 1.51146063],
[ 0.50717688, 0.72992122, 0.08976756, -0.24651979],
[ 0.88960944, -0.4800031 , 0.44611413, -0.95683946],
[-0.47617506, -2.28027206, 2.11041587, -0.92954048]])
参考资料
Python for Data Analysis, 2nd Edition英文版
Python for Data Analysis, 2nd Edition中文版
Python数据科学手册 https:// numpy.org/doc/stable/
欢迎微信随缘关注@pythonic生物人