python 02数据分析（numpy入门）

素颜马尾好姑娘i 2023-10-08 12:00 68阅读 0赞

#### python 02数据分析 ####

*   *  写在前面
     *   *  1、numpy快速入门
         *  2、数组的 索引、切片和迭代
         *   *  2.1、难点：切片
             *  2.2、迭代
         *  3、改变数组形状
         *  4、数组叠加、拆分
         *   *  4.1、叠加
             *  4.2、拆分
         *  5、numpy的深浅拷贝
         *   *  5.1、完全不复制
             *  5.2、视图或浅拷贝
             *  5.3、深拷贝
             *  5.4、深浅拷贝总结

### 写在前面 ###

numpy学习有一些数学里矩阵的知识，如果没学过矩阵也没关系

#### 1、numpy快速入门 ####

numpy主要用来创建多维数组

> nump中文文档：https://www.numpy.org.cn/user/quickstart.html\#%E5%85%88%E5%86%B3%E6%9D%A1%E4%BB%B6

直接上代码

import numpy as np
    
    # array用来将序列转化为数组
    a = np.array([(1.5,2,3), (4,5,6)])
    # 也可以在创建时显式指定数组的类型
    b = np.array( [ [1,2], [3,4] ], dtype=complex )
    # 函数zeros创建一个由0组成的数组，c输出为array([[ 0.,  0.,  0.],[ 0.,  0.,  0.]])
    c = np.zeros( (2,3) )
    # 和zeros类似的还有ones创建由1组成的数组、empty创建一个随机内容的数组
    d = np.ones( (2,3,4), dtype=np.int16 ) 
    # arange用来创建数组，reshape将数据重新组织多维数组
    e = np.arange(15).reshape(3, 5)
           """
           这里e输出为
           array([[ 0,  1,  2,  3,  4],
                  [ 5,  6,  7,  8,  9],
                  [10, 11, 12, 13, 14]])
           """
    f = np.arange( 10, 30, 5 )
           """
           这里f输出为
           array([10, 15, 20, 25])
           """
    g = np.arange(10)**3
           """
           这里g输出为
    	   array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
           """
    
    
    # 另还有这些API
    # array， zeros， zeros_like， ones， ones_like， empty，
    # empty_like， arange， linspace， 
    # numpy.random.mtrand.RandomState.rand， 
    # numpy.random.mtrand.RandomState.randn， fromfunction， fromfile

numpy里的通用函数

>>> B = np.arange(3)
    >>> B
    array([0, 1, 2])
    >>> np.exp(B)
    array([ 1.        ,  2.71828183,  7.3890561 ])
    >>> np.sqrt(B)
    array([ 0.        ,  1.        ,  1.41421356])
    >>> C = np.array([2., -1., 4.])
    >>> np.add(B, C)
    array([ 2.,  0.,  6.])
    
    
    等等，还有其他很多函数，具体见官方文档

#### 2、数组的 索引、切片和迭代 ####

>>> a = np.arange(10)**3
    >>> a
    array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
    >>> a[2]
    8
    >>> a[2:5]
    array([ 8, 27, 64])

>>> def f(x,y):
    ...     return 10*x+y
    ...
    >>> b = np.fromfunction(f,(5,4),dtype=int)
    >>> b
    array([[ 0,  1,  2,  3],
           [10, 11, 12, 13],
           [20, 21, 22, 23],
           [30, 31, 32, 33],
           [40, 41, 42, 43]])
    >>> b[2,3]
    23
    >>> b[0:5, 1]                       # each row in the second column of b
    array([ 1, 11, 21, 31, 41])
    >>> b[ : ,1]                        # equivalent to the previous example
    array([ 1, 11, 21, 31, 41])
    >>> b[1:3, : ]                      # each column in the second and third row of b
    array([[10, 11, 12, 13],
           [20, 21, 22, 23]])

##### 2.1、难点：切片 #####

*  一维数组  
    数组\[起始位置：终点位置：序列符\]
 *  多维数组  
    多维的数组每个轴可以有一个索引。这些索引以逗号分隔的元组给出  
    当提供的索引少于轴的数量时，缺失的索引被认为是完整的切片:

> b = array(\[\[ 0, 1, 2, 3\],  
> \[10, 11, 12, 13\],  
> \[20, 21, 22, 23\],  
> \[30, 31, 32, 33\],  
> \[40, 41, 42, 43\]\])  
> b\[-1\] 输出：array(\[40, 41, 42, 43\])

##### 2.2、迭代 #####

按行迭代

>>> for n in b:
    ...     print(n)
    ...
    [0 1 2 3]
    [10 11 12 13]
    [20 21 22 23]

一个数一个数迭代：使用flat属性

>>> for n in b.flat:
    ...     print(n)
    ...
    0
    1
    2
    3
    10
    .......

#### 3、改变数组形状 ####

一个数组的形状是由每个轴的元素数量决定的

# 查看数组有多少行多少列
    a.shape
    
    # ravel()、reshape()、T 它们不会改变原数组，返回的是一个新数组
    # 把数组a变成一维数组
    a.ravel()
    # 把数组a变成6行2列数组
    a.reshape(6,2)
    # 行列置换，比如数组5行3列，置换后为3行5列
    a.T
    
    # resize()会改变原本的数组，返回的是带有修改形状的参数
    # 把数组a变成2行6列的数组
    a.resize((2,6))
    # 如果在 reshape 操作中将 size 指定为-1，则会自动计算其他的 size 大小
    a.reshape(3,-1)

#### 4、数组叠加、拆分 ####

##### 4.1、叠加 #####

np.vstack((a,b))将数组竖向叠加在一起  
np.hstack((a,b))将数组横向向叠加在一起

> 还有其他叠加方法，具体参考：  
> https://numpy.org/devdocs/reference/generated/numpy.hstack.html\#numpy.hstack

##### 4.2、拆分 #####

例：

# 创建一个2行12列的二维随机数组，np.floor()把小数变成整数向下取整
    a = np.floor(10*np.random.random((2,12)))
    # hsplit沿数组的水平轴拆分数组，把a拆成3个数组，如下图
    np.hsplit(a,3)

hsplit 拆分后行数不变  
![在这里插入图片描述][20200114221950184.png]

# vsplit沿垂直轴分割，把x拆成3个数组，如下图
    np.vsplit(x,2)

vsplit 拆分后列数不变  
![在这里插入图片描述][20200114221834477.png]

#### 5、numpy的深浅拷贝 ####

例：a = np.arange(12)

##### 5.1、完全不复制 #####

b = a

>>> b is a
    True
    
    # 值不会跟着改变，形状会跟着改变
    # 例如：
    >>> b.shape = 3,4    
    >>> a.shape
    (3, 4)
    
    
    >>> b = b*10   
    >>> b
    array([  0,  10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110])
    >>> a
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

##### 5.2、视图或浅拷贝 #####

c = a.view()

>>> c is a 
    False
    >>> c.base is a
    True
    >>> c.flags.owndata
    False
    
    
    # c数组的形状等变化，a不会变化。c的值变化，a的值也跟着变化。
    # 不同的数组对象可以共享相同的数据。该view方法创建一个查看相同数据的新数组对象。
    # 例如：
    >>> c.shape = 3,4    
    >>> a.shape
    (12,)

##### 5.3、深拷贝 #####

d = a.copy()

>>> d is a
    False
    >>> d.base is a                          
    False
    
    # d的改变不关c什么事了

有时，如果不再需要原始数组，则应在切片后调用 copy。
    例如，假设a是一个巨大的中间结果，
    最终结果d只包含a的一小部分，那么在用切片构造b时应该做一个深拷贝：
    
    >>> a = np.arange(int(1e8))
    >>> d = a[:100].copy()
    >>> del a 
    
    如果改为使用 d = a[:100]，则 a 由 d 引用，
    并且即使执行 del a 也会在内存中持久存在。

##### 5.4、深浅拷贝总结 #####

b = a         # a、b值不会跟着改变，形状会跟着改变，载入的是同一段内存
    c = a.view()  # a、c值会跟着改变，形状不会跟着改变
    d = a.copy()  # a、d单独存在，载入的不是同一段内存

[20200114221950184.png]: https://img-blog.csdnimg.cn/20200114221950184.png
[20200114221834477.png]: https://img-blog.csdnimg.cn/20200114221834477.png