《Python数据分析与展示》-Numpy学习笔记01

此系列文章是作为学习嵩天老师的《Python数据分析与展示》的记录文章，以此来练习和巩固学习到的这个课程的内容。其中文章大部分内容都在摘取自嵩天老师的PPT的内容。如果你也对这个课程感兴趣的话，建议直接到中国MOOC上面搜索嵩天老师的这个课程来学习，嵩天老师的课程讲得很基础也很详细，并且嵩天老师的Python系列课程都是值得一听，值得一学。

第一章  numpy入门

import numpy as np

引用模板用import numpy

设置别名 as np,其中np为约定俗成的别名名称

 

numpy的实例：

 

N维数组对象：ndarray

ndarray是一个多维数组对象，由两部分构成：

• 实际的数据

• 描述这些数据的元数据（数据维度、数据类型等）

ndarray数组一般要求所有元素类型相同（同质），数组下标从 0开始

ndarray实例：

ndarray的对象属性如下：

属性	说明
.ndim	秩，及轴的数量或维度的数量
.shape	ndarray对象的尺度，对于矩阵，n行m列
.size	ndarray对象元素的个数，相当于.shape中n*m的值
.dtype	ndarray对象的元素类型
.itemsize	ndarray对象中每个元素的大小，以字节为单位

用以下的实例来理解ndarray中的对象属性：

.ndim（秩，及轴的数量或维度的数量）实例：

In [4]: a=np.array([[0,1,2,3,4],
   ...: [9,8,7,6,5]])

In [5]: a.ndim
Out[5]: 2

因为[0,1,2,3,4]为秩1，[9,8,7,6,5]为秩2 ，所以a.ndim的结果为2

注意：练习a=np.array(）的时候，不要忘记里面的最外层有一个列表，我最开始敲击这个代码的时候，总是漏掉了最外层的[ ]。

.shape（ndarray对象的尺度，对于矩阵，n行m列）实例：

In [6]: a.shape
Out[6]: (2, 5)

 因为a为2行，5列，所以a.shape的值为（2,5）

.size（ndarray对象元素的个数，相当于.shape中n*m的值）实例：

In [7]: a.size
Out[7]: 10

 因为a为2行，5列，所以a.shape的值为2*5=10

.dtype（ndarray对象的元素类型）实例：

In [8]: a.dtype
Out[8]: dtype('int32')

.itemsize（ndarray对象中每个元素的大小，以字节为单位）实例：

In [9]: a.itemsize
Out[9]: 4

ndarray的元素类型

数据类型	说明
bool	布尔类型，True 或False
intc	与 C语言中的int类型一致，一般是int32 或int64
intp	用于索引的整数，与 C语言中ssize_t一致，int32 或int64
int8	字节长度的整数，取值： [ ‐128, 127]
int16	16位长度的整数，取值： [ ‐32768, 32767]
int32	32位长度的整数，取值： [ ‐ 231 , 231 ‐1]
int64	64位长度的整数，取值： [ ‐ 263 , 263 ‐1]

数据类型	说明
uint8	8位无符号整数，取值：[0, 255]
uint16	16位无符号整数，取值：[0, 65535]
uint32	32位无符号整数，取值：[0, 232 ‐1]
uint64	32位无符号整数，取值：[0, 264 ‐1]
float16	16位半精度浮点数： 1位符号位， 5位指数，10位尾数
float32	32位半精度浮点数： 1位符号位， 8位指数，23位尾数
float64	64位半精度浮点数： 1位符号位，11位指数，52位尾数

 

数据类型	说明
complex64	复数类型，实部和虚部都是32位浮点数 实部(.real) + j虚部(.imag)
complex128	复数类型，实部和虚部都是64位浮点数 实部(.real) + j虚部(.imag)

 

非同质的ndarray对象

实例：

In [10]: x=np.array([[0,1,2,3,4],
    ...: [9,8,7,6]])

In [11]: x.shape
Out[11]: (2,)

In [12]: x.dtype
Out[12]: dtype('O')

In [13]: x
Out[13]: array([list([0, 1, 2, 3, 4]), list([9, 8, 7, 6])], dtype=object)

In [14]: x.itemsize
Out[14]: 8

In [15]: x.size
Out[15]: 2

因为[0,1,2,3,4]与[9,8,7,6]不对等，所以属于非同质对象。Out[13]可以看出非同质的ndarray元素为对象类型。

非同质ndarray对象无法有效发挥NumPy优势，尽量避免使用

ndarray数组的创建方法

1）从Python中的列表、元组等类型创建ndarray数组

x = np.array(list/tuple )

x = np.array(list/tuple, dtype=np.float32)

当np.array()不指定dtype时，NumPy将根据数据情况关联一个dtype类型

实例：

In [16]: x=np.array([0,1,2,3])

In [17]: print(x)
[0 1 2 3]

In [18]: x=np.array((4,5,6,7))

In [19]: print(x)
[4 5 6 7]

In [20]: x=np.array([[1,2],[9,8],(0.1,0.2)])

In [21]: print(x)
[[1.  2. ]
 [9.  8. ]
 [0.1 0.2]]

1.ndarray数组可由列表类型创建；2.ndarray数组可由元组类型创建；3.ndarray数组可由列表和元组的混合类型创建。

2）使用NumPy中函数创建ndarray数组①

函数	说明
np.arange(n)	类似range()函数，返回ndarray类型，元素从 0 到 n ‐ 1
np.ones(shape)	根据shape生成一个全 1数组，shape是元组类型
np.zeros(shape)	根据shape生成一个全 0数组，shape是元组类型
np.full(shape,val)	根据shape生成一个数组，每个元素值都是val
np.eye(n)	创建一个正方的n*n单位矩阵，对角线为 1，其余为 0

实例：

In [1]: import numpy as np

In [2]: np.arange(10)
Out[2]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [3]: np.ones((3,6))
Out[3]:
array([[1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.]])

In [4]: np.zeros((3,6),dtype=np.int32)
Out[4]:
array([[0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0]])

In [5]: np.eye(5)
Out[5]:
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 [6]: x=np.ones((2,3,4))

In [7]: print(x)
[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]

In [8]: x.shape
Out[8]: (2, 3, 4)

In [10]: np.full(10,4)
Out[10]: array([4, 4, 4, 4, 4, 4, 4, 4, 4, 4])

2）使用NumPy中函数创建ndarray数组②

函数	说明
np.ones_like(a)	根据数组a的形状生成一个全1数组
np.zeros_like(a)	根据数组a的形状生成一个全0数组
np.full_like(a,val)	根据数组a的形状生成一个数组，每个元素值都是val

In [12]: np.ones_like(x)
Out[12]:
array([[[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]],

       [[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]]])

In [14]: np.zeros_like(x)
Out[14]:
array([[[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]],

       [[0., 0., 0., 0.],
        [0., 0., 0., 0.],
        [0., 0., 0., 0.]]])

In [15]: np.full_like(x,6)
Out[15]:
array([[[6., 6., 6., 6.],
        [6., 6., 6., 6.],
        [6., 6., 6., 6.]],

       [[6., 6., 6., 6.],
        [6., 6., 6., 6.],
        [6., 6., 6., 6.]]])

3）使用NumPy中其他函数创建ndarray数组

函数	说明
np.linspace()	根据起止数据等间距地填充数据，形成数组
np.concatenate()	将两个或多个数组合并成一个新的数组

实例：

In [16]: a=np.linspace(1,10,4)

In [17]: a
Out[17]: array([ 1.,  4.,  7., 10.])

In [18]: b=np.linspace(1,10,4,endpoint=False)

In [19]: b
Out[19]: array([1.  , 3.25, 5.5 , 7.75])

In [20]: c=np.concatenate((a,b))

In [21]: c
Out[21]: array([ 1.  ,  4.  ,  7.  , 10.  ,  1.  ,  3.25,  5.5 ,  7.75])

ndarray数组的维度变换

方法	说明
.reshape(shape)	不改变数组元素，返回一个shape形状的数组，原数组不变
.resize(shape)	与.reshape()功能一致，但修改原数组
.swapaxes(ax1,ax2)	将数组 n个维度中两个维度进行调换
.flatten()	对数组进行降维，返回折叠后的一维数组，原数组不变

实例：

In [23]: a=np.ones((2,3,4),dtype=np.int32)

In [24]: a
Out[24]:
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

In [25]: a.reshape((3,8))
Out[25]:
array([[1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1]])

In [26]: a
Out[26]:
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

In [27]: a.resize((3,8))

In [28]: a
Out[28]:
array([[1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1]])

In [29]: a.flatten()
Out[29]:
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1])

In [30]: a
Out[30]:
array([[1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1, 1, 1, 1]])

In [31]: b=a.flatten()

In [32]: b
Out[32]:
array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1])

In [33]: a=np.ones((2,3,4),dtype=np.int)

In [34]: a
Out[34]:
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])

In [35]: b=a.astype(np.float)

In [36]: b
Out[36]:
array([[[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]],

       [[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]]])

In [37]: a=np.full((2,3,4),25,dtype=np.int32)

In [38]: a
Out[38]:
array([[[25, 25, 25, 25],
        [25, 25, 25, 25],
        [25, 25, 25, 25]],

       [[25, 25, 25, 25],
        [25, 25, 25, 25],
        [25, 25, 25, 25]]])

In [39]: a.tolist()
Out[39]:
[[[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]],
 [[25, 25, 25, 25], [25, 25, 25, 25], [25, 25, 25, 25]]]

数组的索引和切片

一维数组的索引和切片：与Python的列表类似

起始编号: 终止编号 (不含): 步长， 3元素冒号分割

实例：

In [40]: a=np.array([9,8,7,6,5])

In [41]: a[2]
Out[41]: 7

In [42]: a[1:4:2]
Out[42]: array([8, 6])

多维数组的索引：

每个维度一个索引值，逗号分割

实例：

In [43]: a=np.arange(24).reshape((2,3,4))

In [44]: a
Out[44]:
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]]])

In [45]: a[1,2,3]
Out[45]: 23

In [46]: a[0,1,2]
Out[46]: 6

In [47]: a[-1,-2,-3]
Out[47]: 17

注意：索引和切片下标都是从0开始的。

多维数组的切片：

In [48]: a[:,1,-3]
Out[48]: array([ 5, 17])

没有选取具体维度，那么可以用：表示所有维度。维度1的1行-3列的数据为5，维度2的1行-3列的数据为17，所以结果为[5,17]

In [49]: a[:,1:3,:]
Out[49]:
array([[[ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23]]])

此例当中，维度和列数都是没有限制的，只有中间的行数有限制。行数是以下标1开始的，也就是维度1当中的第2列开始切片，相对应的维度2当中的第2列开始切片。

In [50]: a[:,:,::2]
Out[50]:
array([[[ 0,  2],
        [ 4,  6],
        [ 8, 10]],

       [[12, 14],
        [16, 18],
        [20, 22]]])

此例中，维度和行数都是没有限制的，而在列数中进行了限制。列数当中的起始和截止位置没有限制，但是步长设置成了2，所以得到结果如上所示。

ndarray数组的运算

NumPy一元函数

函数	说明
np.abs(x) np.fabs(x)	计算数组各元素的绝对值
np.sqrt(x)	计算数组各元素的平方根
np.square(x)	计算数组各元素的平方
np.log(x) np.log10(x) np.log2(x)	计算数组各元素的自然对数、10底对数和 2底对数
np.ceil(x) np.floor(x)	计算数组各元素的ceiling值 或 floor 值
np.rint(x)	计算数组各元素的四舍五入值
np.modf(x)	将数组各元素的小数和整数部分以两个独立数组形式返回
np.cos(x) np.cosh(x) np.sin(x) np.sinh(x) np.tan(x) np.tanh(x)	计算数组各元素的普通型和双曲型三角函数
np.exp(x)	计算数组各元素的指数值
np.sign(x)	计算数组各元素的符号值，1(+), 0, ‐1( ‐ )

实例：

In [51]: a=np.arange(24).reshape((2,3,4))

In [52]: a
Out[52]:
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]]])

In [53]: a.mean()
Out[53]: 11.5

In [54]: a=a/a.mean()

In [55]: a
Out[55]:
array([[[0.        , 0.08695652, 0.17391304, 0.26086957],
        [0.34782609, 0.43478261, 0.52173913, 0.60869565],
        [0.69565217, 0.7826087 , 0.86956522, 0.95652174]],

       [[1.04347826, 1.13043478, 1.2173913 , 1.30434783],
        [1.39130435, 1.47826087, 1.56521739, 1.65217391],
        [1.73913043, 1.82608696, 1.91304348, 2.        ]]])

In [56]: a=np.arange(24).reshape((2,3,4))

In [57]: np.square(a)
Out[57]:
array([[[  0,   1,   4,   9],
        [ 16,  25,  36,  49],
        [ 64,  81, 100, 121]],

       [[144, 169, 196, 225],
        [256, 289, 324, 361],
        [400, 441, 484, 529]]], dtype=int32)

In [58]: a=np.sqrt(a)

In [59]: a
Out[59]:
array([[[0.        , 1.        , 1.41421356, 1.73205081],
        [2.        , 2.23606798, 2.44948974, 2.64575131],
        [2.82842712, 3.        , 3.16227766, 3.31662479]],

       [[3.46410162, 3.60555128, 3.74165739, 3.87298335],
        [4.        , 4.12310563, 4.24264069, 4.35889894],
        [4.47213595, 4.58257569, 4.69041576, 4.79583152]]])

In [60]: np.modf(a)
Out[60]:
(array([[[0.        , 0.        , 0.41421356, 0.73205081],
         [0.        , 0.23606798, 0.44948974, 0.64575131],
         [0.82842712, 0.        , 0.16227766, 0.31662479]],

        [[0.46410162, 0.60555128, 0.74165739, 0.87298335],
         [0.        , 0.12310563, 0.24264069, 0.35889894],
         [0.47213595, 0.58257569, 0.69041576, 0.79583152]]]),
 array([[[0., 1., 1., 1.],
         [2., 2., 2., 2.],
         [2., 3., 3., 3.]],

        [[3., 3., 3., 3.],
         [4., 4., 4., 4.],
         [4., 4., 4., 4.]]]))

NumPy二元函数

函数	说明
+ ‐ * / **	两个数组各元素进行对应运算
np.maximum(x,y) np.fmax() np.minimum(x,y) np.fmin()	元素级的最大值 /最小值计算
np.mod(x,y)	元素级的模运算
np.copysign(x,y)	将数组 y中各元素值的符号赋值给数组 x对应元素
> < >= <= == !=	算术比较，产生布尔型数组

实例：

In [61]: a=np.arange(24).reshape((2,3,4))

In [62]: b=np.sqrt(a)

In [63]: np.maximum(a,b)
Out[63]:
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.]]])

In [64]: a>b
Out[64]:
array([[[False, False,  True,  True],
        [ True,  True,  True,  True],
        [ True,  True,  True,  True]],

       [[ True,  True,  True,  True],
        [ True,  True,  True,  True],
        [ True,  True,  True,  True]]])