NumPy库入门

>>>前篇

#数据的维度

一个数据 —>一组数据（不同形式展示）

【维度：一组数据的组织形式】

一维数据 —> 二维数据 —> 多维数据 —> 高维数据

【数据维度的Python展示】

>>>一维数据：采用线性方式组织

3.1413 ，3.1398, 3.1404, 3.1401，3.1349， 3.1376

对应列表、数组和集合等概念，列表数组是一组数据的有序结构

#区别：

列表：数据类型可不相同

数组：数据类型相同

>>>二维数据：是一维数据的组合形式

【表格是典型的二维数据，其中表头是二维数据的一部分，也可以是二维数据之外的部分】

>>>多维数据：由一维或二维数据在新维度上扩展形成【时间维度】

>>>高维数据：仅利用最基本的二元关系展示数据间的复杂结构

利用 “ 键值对 ” 将数据组织起来形成的数据方式

>>>用Python表示数据维度

一维：在Python中用列表和集合类型表示【列表：有序数据，集合：无需数据】

二维，多维：都是通过列表类型表示【由两个列表组成一个列表】

[ [3.1413 ，3.1398, 3.1404],

[3.1401，3.1349， 3.1376] ]

高维：字典类型或用一些数据表示的格式来表示

【数据表示的格式主要有三种：JSON XML YAML,可以用来组织数据并使它们形成数据维度的关系】

>>>正文

>>NumPy的数组对象：ndarry

>>ndarray数组的创建和变换

>>ndarray数组的操作

>>ndarray数组的运算

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------>>> NumPy ：是一个开源的Python科学计算基础库，包含：

* 一个强大的N维数组对象 ndarray && 广播功能函数【用来进行数组的计算】&& 整合C/C++/Fortran代码的工具 && 线性代数、傅里叶变换、随机数生成等功能

【NumPy是SciPy、Pandas等数据处理或科学计算库的基础】

#NumPy的引用 import numpy as np

>>>N维数组对象：ndarray

【引入问题：为什么要引入数组类型的数据】

 1 #计算A^2+B^3,其中A B是一维数组
 2 #传统办法
 3 def pySum():
 4     a = [0,1,2,3,4]
 5     b = [9,8,7,6,5]
 6     c=[]
 7     for i in range(len(a)):
 8         c.append(a[i]**2 + b[i]**3)
 9     return c
10 print(pySum())
11 #NumPy库方法，不需要遍历，提高效率
12 import numpy as np            
13 def npSum():
14     a = [0,1,2,3,4]
15     b = [9,8,7,6,5]
16     c = a**2 + b**3
17     return c
18 print(npSum())

回答：1）数组对象可去掉元素间运算所需的循环，使一维向量更像单个数据

2）设置专门的数组对象，经优化，可提升运算速度

3）数组对象采用相同的数据类型，有助于节省运算和存储空间

4） ndarray是一个多维数组对象，由 *实际数据&&描述这些数据的元数据（数据维度、数据类型等）两部分构成

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

*编译器Spyder,交互式命令行IPython

ndarray实例

>>>ndarray对象的属性

##ndarray数组的元素类型【问题：ndarray为什么要支持这么多种元素类型】

【对比：Python语法仅支持整数、浮点数、复数3种类型】

回答：科学计算涉及数据较多，对存储和性能都有较高要求

对元素类型精细定义，有助于numpy合理使用存储空间并优化性能，有助于对程序规模有合理评估

#非同质的ndarray对象

ndarray数组可由非同质对象构成，但非同质ndarray 对象无法有效发挥numpy优势，尽量避免使用

>>>ndarray数组的创建

创建方法（4种）

【***从Python中的列表、元组等类型创建

***使用NumPy中函数创建ndarray数组，如：arange,ones,zeros等

从字节流（raw bytes)中创建ndarray数组

从文件中读取特定格式，创建ndarray数组】

1）从Python中的列表、元组等类型创建 x = np.array(list/tuple)

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

【当np.array（）不指定dtype时，numpy将根据数据情况关联一个dtype类型】

代码示例

>>> x = np.array([0,1,2,3])
>>> print(x)#从列表中创建
[0 1 2 3]
>>> x = np.array((4,5,6,7))
>>> print(x)#从元组类型创建
[4 5 6 7]
>>> x = np.array([[1,2],[9,8],(0.1,0.2)])
>>> print(x)#从列表和元组混合类型创建
[[1.  2. ]
 [9.  8. ]
 [0.1 0.2]]

2）使用NumPy中函数创建ndarray数组，如：arange,ones,zeros等

代码

>>> np.arange(10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.ones((3,6))
array([[1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.]])
>>> np.zeros((3,6),dtype=np.int32)
array([[0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0]])
>>> np.zeros((3,6))
array([[0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0.]])
>>> np.eye(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.]])

>>> x = np.ones((2,3,4))
>>> 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.]]]
>>> x.shape
(2, 3, 4)

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

>>> a = np.linspace(1,10,4)
>>> a
array([ 1.,  4.,  7., 10.])
>>> a = np.linspace(2,10,4)
>>> a
array([ 2.        ,  4.66666667,  7.33333333, 10.        ])
>>> a = np.linspace(2,10,4,endpoint = False)
>>> a
array([2., 4., 6., 8.])
>>> a = np.linspace(1,10,4,endpoint = False)
>>> a
array([1.  , 3.25, 5.5 , 7.75])

【如果带终点，即endpoint是True，则会等分成num-1份，不带终点，则等分成num份。】

>>>ndarray数组的变换【可进行维度、元素类型的变换】

维度变换

代码

a = np.ones((2,3,4),dtype=np.int32)
>>> a
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]]])
>>> a.reshape((3,8))
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]])
>>> a
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]]])
>>> a.resize((3,8))
>>> a
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]])

数据类型的变换

new_a = a.astype(new_type)

【astype()方法一定会创建新的数组（原始数据的一个拷贝），即使两个类型一致】

数组向列表的转换

ls = a.tolist()

>>>ndarray数组的操作

数组的索引和切片【索引：获取数组中特定元素的过程切片：获取数组元素子集的过程】

一维&&多维

代码示例

#一维
>>> a = np.array([9,8,7,6,5])
>>> a[2]
7
>>> a[1:4:2] #起始编号 终止编号 步长
array([8, 6])  #编号0从左递增，-1开始从右递减

#多维数组的索引
>>> a = np.arange(24).reshape((2,3,4))
>>> a
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]]])
>>> a[1,2,3]
23
>>> a[0,1,2]
6
>>> a[-1,-2,-3]
17
>>> a[-1,-1,-1]
23
#切片
a[:,1,-3]
array([ 5, 17])
>>> a[:,2,1]
array([ 9, 21])
>>> a[:,1,1]
array([ 5, 17])#选取一个维度用“：”
>>> a[:,0:2,:]
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7]],

       [[12, 13, 14, 15],
        [16, 17, 18, 19]]])
>>> a[:,1:3,:]
array([[[ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],

       [[16, 17, 18, 19],
        [20, 21, 22, 23]]])#每个维度切片方法与一维数组相同
>>> a[:,:,::2]#每个维度可使用步长跳跃切片
array([[[ 0,  2],
        [ 4,  6],
        [ 8, 10]],

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

>>>ndarray数组的运算

数组与标量之间的运算

numpy一元函数

实例演示：

numpy二元函数

>>> a = np.arange(24).reshape((2,3,4))
>>> np.square(a)
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]]])
>>> a = np.sqrt(a)
>>> a
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]]])
#注意数组是否被真实改变【square没有改变原数组】