numpy基本操作

r囧r小猫 2023-02-23 08:52 24阅读 0赞

## numpy概述 ##

1.  Numerical Python，数值的Python，补充了Python语言所欠缺的数值计算能力。
2.  Numpy是其它数据分析及机器学习库的底层库。
3.  Numpy完全标准C语言实现，运行效率充分优化。
4.  Numpy开源免费。

### numpy`历史` ###

1.  1995年，Numeric，Python语言数值计算扩充。
2.  2001年，Scipy->Numarray，多维数组运算。
3.  2005年，Numeric+Numarray->Numpy。
4.  2006年，Numpy脱离Scipy成为独立的项目。

### numpy的核心：多维数组 ###

1.  代码简洁：减少Python代码中的循环。
2.  底层实现：厚内核©+薄接口(Python)，保证性能。

## numpy基础 ##

### ndarray数组 ###

用np.ndarray类的对象表示n维数组

import numpy as np
    ary = np.array([1, 2, 3, 4, 5, 6])
    print(type(ary))

#### 内存中的ndarray对象 ####

**元数据（metadata）**

存储对目标数组的描述信息，如：dim count、dimensions、dtype、data等。

**实际数据**

完整的数组数据

将实际数据与元数据分开存放，一方面提高了内存空间的使用效率，另一方面减少对实际数据的访问频率，提高性能。

#### ndarray数组对象的特点 ####

1.  Numpy数组是同质数组，即所有元素的数据类型必须相同
2.  Numpy数组的下标从0开始，最后一个元素的下标为数组长度减1

#### ndarray数组对象的创建 ####

np.array(任何可被解释为Numpy数组的逻辑结构)

import numpy as np
    a = np.array([1, 2, 3, 4, 5, 6])
    print(a)

np.arange(起始值(0),终止值,步长(1))

import numpy as np
    a = np.arange(0, 5, 1)
    print(a)
    b = np.arange(0, 10, 2)
    print(b)

np.zeros(数组元素个数, dtype=‘类型’)

import numpy as np
    a = np.zeros(10)
    print(a)

np.ones(数组元素个数, dtype=‘类型’)

import numpy as np
    a = np.ones(10)
    print(a)

#### ndarray对象属性的基本操作 ####

\*\*数组的维度：\*\*np.ndarray.shape

import numpy as np
    ary = np.array([1, 2, 3, 4, 5, 6])
    print(type(ary), ary, ary.shape)
    #二维数组
    ary = np.array([
        [1,2,3,4],
        [5,6,7,8]
    ])
    print(type(ary), ary, ary.shape)

\*\*元素的类型：\*\*np.ndarray.dtype

import numpy as np
    ary = np.array([1, 2, 3, 4, 5, 6])
    print(type(ary), ary, ary.dtype)
    #转换ary元素的类型
    b = ary.astype(float)
    print(type(b), b, b.dtype)
    #转换ary元素的类型
    c = ary.astype(str)
    print(type(c), c, c.dtype)

\*\*数组元素的个数：\*\*np.ndarray.size

import numpy as np
    ary = np.array([
        [1,2,3,4],
        [5,6,7,8]
    ])
    #观察维度，size，len的区别
    print(ary.shape, ary.size, len(ary))

**数组元素索引(下标)**

数组对象\[…, 页号, 行号, 列号\]

下标从0开始，到数组len-1结束。

import numpy as np
    a = np.array([[[1, 2],
                   [3, 4]],
                  [[5, 6],
                   [7, 8]]])
    print(a, a.shape)
    print(a[0])
    print(a[0][0])
    print(a[0][0][0])
    print(a[0, 0, 0])
    for i in range(a.shape[0]):
        for j in range(a.shape[1]):
            for k in range(a.shape[2]):
                print(a[i, j, k])

#### ndarray对象属性操作详解 ####

**Numpy的内部基本数据类型**

<table> 
 <thead> 
  <tr> 
   <th>类型名</th> 
   <th>类型表示符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>布尔型</td> 
   <td>bool_</td> 
  </tr> 
  <tr> 
   <td>有符号整数型</td> 
   <td>int8(-128~127)/int16/int32/int64</td> 
  </tr> 
  <tr> 
   <td>无符号整数型</td> 
   <td>uint8(0~255)/uint16/uint32/uint64</td> 
  </tr> 
  <tr> 
   <td>浮点型</td> 
   <td>float16/float32/float64</td> 
  </tr> 
  <tr> 
   <td>复数型</td> 
   <td>complex64/complex128</td> 
  </tr> 
  <tr> 
   <td>字串型</td> 
   <td>str_，每个字符用32位Unicode编码表示</td> 
  </tr> 
 </tbody> 
</table>

**自定义复合类型**

# 自定义复合类型
    import numpy as np
    
    data=[
    	('zs', [90, 80, 85], 15),
    	('ls', [92, 81, 83], 16),
    	('ww', [95, 85, 95], 15)
    ]
    #第一种设置dtype的方式
    a = np.array(data, dtype='U3, 3int32, int32')
    print(a)
    print(a[0]['f0'], ":", a[1]['f1'])
    print("=====================================")
    #第二种设置dtype的方式
    b = np.array(data, dtype=[('name', 'str_', 2),
                        ('scores', 'int32', 3),
                        ('ages', 'int32', 1)])
    print(b[0]['name'], ":", b[0]['scores'])
    print("=====================================")
    
    #第三种设置dtype的方式
    c = np.array(data, dtype={ 'names': ['name', 'scores', 'ages'],
                        'formats': ['U3', '3int32', 'int32']})
    print(c[0]['name'], ":", c[0]['scores'], ":", c.itemsize)
    print("=====================================")
    
    #第四种设置dtype的方式 
    d = np.array(data, dtype={ 'names': ('U3', 0),
                        'scores': ('3int32', 16),
                        'ages': ('int32', 28)})
    print(d[0]['names'], d[0]['scores'], d.itemsize)
    
    print("=====================================")
    
    #第五种设置dtype的方式
    e = np.array([0x1234, 0x5667],
                 dtype=('u2', { 'lowc': ('u1', 0),
                                'hignc': ('u1', 1)}))
    print('%x' % e[0])
    print('%x %x' % (e['lowc'][0], e['hignc'][0]))
    
    print("=====================================")
    #测试日期类型数组
    f = np.array(['2011', '2012-01-01', '2013-01-01 01:01:01','2011-02-01'])
    f = f.astype('M8[D]')
    f = f.astype('int32')
    print(f[3]-f[0])
    
    print("=====================================")
    a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
                  [4 + 2j, 5 + 5j, 6 + 8j],
                  [7 + 3j, 8 + 6j, 9 + 9j]])
    print(a.T)
    
    for x in a.flat:
    	print(x.imag)

**类型字符码**

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字符码</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>np.bool_</td> 
   <td>?</td> 
  </tr> 
  <tr> 
   <td>np.int8/16/32/64</td> 
   <td>i1/i2/i4/i8</td> 
  </tr> 
  <tr> 
   <td>np.uint8/16/32/64</td> 
   <td>u1/u2/u4/u8</td> 
  </tr> 
  <tr> 
   <td>np.float/16/32/64</td> 
   <td>f2/f4/f8</td> 
  </tr> 
  <tr> 
   <td>np.complex64/128</td> 
   <td>c8/c16</td> 
  </tr> 
  <tr> 
   <td>np.str_</td> 
   <td>U&lt;字符数&gt;</td> 
  </tr> 
  <tr> 
   <td>np.datetime64</td> 
   <td>M8[Y] M8[M] M8[D] M8[h] M8[m] M8[s]</td> 
  </tr> 
 </tbody> 
</table>

**字节序前缀，用于多字节整数和字符串：**  
`</>/[=]分别表示小端/大端/硬件字节序。`

**类型字符码格式**

<字节序前缀><维度><类型><字节数或字符数>

<table> 
 <thead> 
  <tr> 
   <th>3i4</th> 
   <th>释义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>3i4</td> 
   <td>大端字节序，3个元素的一维数组，每个元素都是整型，每个整型元素占4个字节。</td> 
  </tr> 
  <tr> 
   <td>&lt;(2,3)u8</td> 
   <td>小端字节序，6个元素2行3列的二维数组，每个元素都是无符号整型，每个无符号整型元素占8个字节。</td> 
  </tr> 
  <tr> 
   <td>U7</td> 
   <td>包含7个字符的Unicode字符串，每个字符占4个字节，采用默认字节序。</td> 
  </tr> 
 </tbody> 
</table>

##### ndarray数组对象的维度操作 #####

**视图变维（数据共享）：** reshape() 与 ravel()

import numpy as np
    a = np.arange(1, 9)
    print(a)		# [1 2 3 4 5 6 7 8]
    b = a.reshape(2, 4)	#视图变维 : 变为2行4列的二维数组
    print(b)
    c = b.reshape(2, 2, 2) #视图变维 变为2页2行2列的三维数组
    print(c)
    d = c.ravel()	#视图变维 变为1维数组
    print(d)

\*\*复制变维（数据独立）：\*\*flatten()

e = c.flatten()
    print(e)
    a += 10
    print(a, e, sep='\n')

**就地变维：直接改变原数组对象的维度，不返回新数组**

a.shape = (2, 4)
    print(a)
    a.resize(2, 2, 2)
    print(a)

##### ndarray数组切片操作 #####

#数组对象切片的参数设置与列表切面参数类似
    # 步长+：默认切从首到尾
    # 步长-：默认切从尾到首
    数组对象[起始位置:终止位置:步长, ...]
    #默认位置步长：1

import numpy as np
    a = np.arange(1, 10)
    print(a)  # 1 2 3 4 5 6 7 8 9
    print(a[:3])  # 1 2 3
    print(a[3:6])   # 4 5 6
    print(a[6:])  # 7 8 9
    print(a[::-1])  # 9 8 7 6 5 4 3 2 1
    print(a[:-4:-1])  # 9 8 7
    print(a[-4:-7:-1])  # 6 5 4
    print(a[-7::-1])  # 3 2 1
    print(a[::])  # 1 2 3 4 5 6 7 8 9
    print(a[:])  # 1 2 3 4 5 6 7 8 9
    print(a[::3])  # 1 4 7
    print(a[1::3])  # 2 5 8
    print(a[2::3])  # 3 6 9

**多维数组的切片操作**

import numpy as np
    a = np.arange(1, 28)
    a.resize(3,3,3)
    print(a)
    #切出1页 
    print(a[1, :, :])		
    #切出所有页的1行
    print(a[:, 1, :])		
    #切出0页的1行1列
    print(a[0, :, 1])

##### **ndarray数组的掩码操作** #####

import numpy as np
    a = np.arange(1, 10)
    mask = [True, False,True, False,True, False,True, False,True, False]
    print(a[mask])

##### 多维数组的组合与拆分 #####

垂直方向操作：

import numpy as np
    a = np.arange(1, 7).reshape(2, 3)
    b = np.arange(7, 13).reshape(2, 3)
    # 垂直方向完成组合操作，生成新数组
    c = np.vstack((a, b))
    # 垂直方向完成拆分操作，生成两个数组
    d, e = np.vsplit(c, 2)

水平方向操作：

import numpy as np
    a = np.arange(1, 7).reshape(2, 3)
    b = np.arange(7, 13).reshape(2, 3)
    # 水平方向完成组合操作，生成新数组 
    c = np.hstack((a, b))
    # 水平方向完成拆分操作，生成两个数组
    d, e = np.hsplit(c, 2)

长度不等的数组组合：

import numpy as np
    a = np.array([1,2,3,4,5])
    b = np.array([1,2,3,4])
    # 填充b数组使其长度与a相同
    b = np.pad(b, pad_width=(0, 1), mode='constant', constant_values=-1)
    print(b)
    # 垂直方向完成组合操作，生成新数组
    c = np.vstack((a, b))
    print(c)

深度方向操作：（3维）

import numpy as np
    a = np.arange(1, 7).reshape(2, 3)
    b = np.arange(7, 13).reshape(2, 3)
    # 深度方向（3维）完成组合操作，生成新数组
    i = np.dstack((a, b))
    # 深度方向（3维）完成拆分操作，生成两个数组
    k, l = np.dsplit(i, 2)

多维数组组合与拆分的相关函数：

# 通过axis作为关键字参数指定组合的方向，取值如下：
    # 若待组合的数组都是二维数组：
    # 0: 垂直方向组合
    # 1: 水平方向组合
    # 若待组合的数组都是三维数组：
    # 0: 垂直方向组合
    # 1: 水平方向组合
    # 2: 深度方向组合
    np.concatenate((a, b), axis=0)
    # 通过给出的数组与要拆分的份数，按照某个方向进行拆分，axis的取值同上
    np.split(c, 2, axis=0)

简单的一维数组组合方案

a = np.arange(1,9)		#[1, 2, 3, 4, 5, 6, 7, 8]
    b = np.arange(9,17)		#[9,10,11,12,13,14,15,16]
    #把两个数组摞在一起成两行
    c = np.row_stack((a, b))
    print(c)
    #把两个数组组合在一起成两列
    d = np.column_stack((a, b))
    print(d)

#### ndarray类的其他属性 ####

*  shape - 维度
 *  dtype - 元素类型
 *  size - 元素数量
 *  ndim - 维数，len(shape)
 *  itemsize - 元素字节数
 *  nbytes - 总字节数 = size \* itemsize
 *  real - 复数数组的实部数组
 *  imag - 复数数组的虚部数组
 *  T - 数组对象的转置视图
 *  flat - 扁平迭代器

import numpy as np
    a = np.array([[1 + 1j, 2 + 4j, 3 + 7j],
                  [4 + 2j, 5 + 5j, 6 + 8j],
                  [7 + 3j, 8 + 6j, 9 + 9j]])
    print(a.shape)
    print(a.dtype)
    print(a.ndim)
    print(a.size)
    print(a.itemsize)
    print(a.nbytes)
    print(a.real, a.imag, sep='\n')
    print(a.T)
    print([elem for elem in a.flat])
    b = a.tolist()
    print(b)

**金融相关**

import numpy as np
    # 终值 = np.fv(利率, 期数, 每期支付, 现值)
    # 将1000元以1%的年利率存入银行5年，每年加存100元，
    # 到期后本息合计多少钱？
    fv = np.fv(0.01, 5, -100, -1000)
    print(round(fv, 2))
    # 现值 = np.pv(利率, 期数, 每期支付, 终值)
    # 将多少钱以1%的年利率存入银行5年，每年加存100元，
    # 到期后本息合计fv元？
    pv = np.pv(0.01, 5, -100, fv)
    print(pv)
    # 净现值 = np.npv(利率, 现金流)
    # 将1000元以1%的年利率存入银行5年，每年加存100元，
    # 相当于一次性存入多少钱？
    npv = np.npv(0.01, [
        -1000, -100, -100, -100, -100, -100])
    print(round(npv, 2))
    fv = np.fv(0.01, 5, 0, npv)
    print(round(fv, 2))
    # 内部收益率 = np.irr(现金流)
    # 将1000元存入银行5年，以后逐年提现100元、200元、
    # 300元、400元、500元，银行利率达到多少，可在最后
    # 一次提现后偿清全部本息，即净现值为0元？
    irr = np.irr([-1000, 100, 200, 300, 400, 500])
    print(round(irr, 2))
    npv = np.npv(irr, [-1000, 100, 200, 300, 400, 500])
    print(npv)
    # 每期支付 = np.pmt(利率, 期数, 现值)
    # 以1%的年利率从银行贷款1000元，分5年还清，
    # 平均每年还多少钱？
    pmt = np.pmt(0.01, 5, 1000)
    print(round(pmt, 2))
    # 期数 = np.nper(利率, 每期支付, 现值)
    # 以1%的年利率从银行贷款1000元，平均每年还pmt元，
    # 多少年还清？
    nper = np.nper(0.01, pmt, 1000)
    print(int(nper))
    # 利率 = np.rate(期数, 每期支付, 现值, 终值)
    # 从银行贷款1000元，平均每年还pmt元，nper年还清，
    # 年利率多少？
    rate = np.rate(nper, pmt, 1000, 0)
    print(round(rate, 2))