numpy和pandas学习笔记

我就是我 2022-10-31 12:28 232阅读 0赞

# numpy #

### 介绍 ###

NumPy是一个主要用于处理n维数组对象的Python工具包，是Python提供数值计算的基础模块，在使用Python进行科学计算时NumPy必不可少，Python的许多扩展模块都是基于NumPy开发的，对NumPy的深入了解将有助于高效地使用Pandas和SciPy这样的工具库。

### numpy 的几种属性 ###

#创建一个numpy
    array = np.array([[1,2,3],[2,3,4]]) #列表转化为矩阵 
    print(array)  #[[1, 2, 3], [2, 3, 4]]
    
    print('number of dim:',array.ndim)  # ndim属性为维度
    # number of dim: 2
    
    print('shape :',array.shape)    # shape属性会显示矩阵的形状，行数和列数
    # shape : (2, 3)
    
    print('size:',array.size)   # size属性会显示矩阵的元素个数
    # size: 6

### 基本使用 ###

*  引入

import numpy as np

*  创建

# numpy的使用，消耗资源少，运算速度快，采用矩阵方式运算
    numpy_array=np.array([[1,2,3,4],[5,6,7,8]])
    numpy_array2=np.array([[11,12,13,14],[15,16,17,18]])

*  指定数据类型，dtype用来指定数据类型，可以是float、int等

numpy_array3=np.array([[1,2,3,4],[5,6,7,8]],dtype=np.int)

*  创建特定类型矩阵

# 创建特定数据
    # 1、全为0的矩阵，第一个参数代表矩阵的形状
    numpy_array4=np.zeros((3,4),dtype=np.int)
    print(numpy_array4)
    # 2、全为1的矩阵
    numpy_array5=np.ones((4,5))
    print(numpy_array5)
    # 3、创建全空数组，每一个数都接近于0
    numpy_array6=np.empty((3,8))
    print(numpy_array6)
    # 使用reshape改变数组的形状
    numpy_array7=np.zeros((3,4)).reshape((4,3))
    print(numpy_array7)
    # 用linsace创建线段型数据，1到20之间取20个点
    numpy_array8=np.linspace(1,20,20).reshape(4,5)
    print(numpy_array8)
    # 用arange创建连续性数组，0到10之间以2为一步取点
    numpy_array9=np.arange(0,19,2).reshape((2,5))
    print(numpy_array9)

*  基础运算  
    numpy的计算与正常的数字运算类似，只不过运算时，如果是两个numpy计算，则两个numpy相对的元素一一进行计算；如果是一个numpy和一个数字，则numpy中的每一个元素分别于该数字进行计算。  
    numpy的一些函数包括：`sin()`、`sum()`、`min()`、`max()`等。

print("a =",a)
    # a = [[ 0.23651224 0.41900661 0.84869417 0.46456022]
    # [ 0.60771087 0.9043845 0.36603285 0.55746074]]
    
    print("sum =",np.sum(a,axis=1))  #axis为1表示列，即保留列，计算行，为0则相反。
    # sum = [ 1.96877324 2.43558896]
    
    print("min =",np.min(a,axis=0))
    # min = [ 0.23651224 0.41900661 0.36603285 0.46456022]

# pandas #

如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的，没有数值标签，而 Pandas 就是字典形式。Pandas是基于Numpy构建的，让Numpy为中心的应用变得更加简单。  
要使用pandas，首先需要了解他主要两个数据结构：Series和DataFrame。

### 基本使用 ###

*  **引入**

import pandas as pd
    import numpy as np

*  **Series**

s = pd.Series([1,3,6,np.nan,44,1])
    
    print(s)
    """ 0 1.0 1 3.0 2 6.0 3 NaN 4 44.0 5 1.0 dtype: float64 """

*  **DataFrame**

dates = pd.date_range('20160101',periods=6)
    df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=['a','b','c','d'])
    
    print(df)
    """ a b c d 2016-01-01 -0.253065 -2.071051 -0.640515 0.613663 2016-01-02 -1.147178 1.532470 0.989255 -0.499761 2016-01-03 1.221656 -2.390171 1.862914 0.778070 2016-01-04 1.473877 -0.046419 0.610046 0.204672 2016-01-05 -1.584752 -0.700592 1.487264 -1.778293 2016-01-06 0.633675 -1.414157 -0.277066 -0.442545 """

`DataFrame`是一个表格型的数据结构，它包含有一组有序的列，每列可以是不同的值类型（数值，字符串，布尔值等）。`DataFrame`既有行索引也有列索引， 它可以被看做由Series组成的大字典。

### 选择数据 ###

先创建pandas

dates = pd.date_range('20130101', periods=6)
    df = pd.DataFrame(np.arange(24).reshape((6,4)),index=dates, columns=['A','B','C','D'])
    
    """ A B C D 2013-01-01 0 1 2 3 2013-01-02 4 5 6 7 2013-01-03 8 9 10 11 2013-01-04 12 13 14 15 2013-01-05 16 17 18 19 2013-01-06 20 21 22 23 """

#### 简单的筛选 ####

如果我们想选取DataFrame中的数据，下面描述了两种途径, 他们都能达到同一个目的：

print(df['A'])
    print(df.A)
    
    """ 2013-01-01 0 2013-01-02 4 2013-01-03 8 2013-01-04 12 2013-01-05 16 2013-01-06 20 Freq: D, Name: A, dtype: int64 """

让选择跨越多行或多列:

print(df[0:3])
     
    """ A B C D 2013-01-01 0 1 2 3 2013-01-02 4 5 6 7 2013-01-03 8 9 10 11 """
    
    print(df['20130102':'20130104'])
    
    """ A B C D 2013-01-02 4 5 6 7 2013-01-03 8 9 10 11 2013-01-04 12 13 14 15 """

#### 根据标签 loc ####

同样我们可以使用标签来选择数据 `loc`, 本例子主要通过标签名字选择某一行数据， 或者通过选择某行或者所有行（:代表所有行）然后选其中某一列或几列数据。

print(df.loc['20130102'])
    """ A 4 B 5 C 6 D 7 Name: 2013-01-02 00:00:00, dtype: int64 """
    
    print(df.loc[:,['A','B']]) 
    """ A B 2013-01-01 0 1 2013-01-02 4 5 2013-01-03 8 9 2013-01-04 12 13 2013-01-05 16 17 2013-01-06 20 21 """
    
    print(df.loc['20130102',['A','B']])
    """ A 4 B 5 Name: 2013-01-02 00:00:00, dtype: int64 """

#### 根据序列 iloc ####

另外我们可以采用位置进行选择 iloc, 在这里我们可以通过位置选择在不同情况下所需要的数据例如选某一个，连续选或者跨行选等操作。

print(df.iloc[3,1])
    # 13
    
    print(df.iloc[3:5,1:3])
    """ B C 2013-01-04 13 14 2013-01-05 17 18 """
    
    print(df.iloc[[1,3,5],1:3])
    """ B C 2013-01-02 5 6 2013-01-04 13 14 2013-01-06 21 22 """

#### 根据混合的这两种 ix ####

当然我们可以采用混合选择 ix, 其中选择’A’和’C’的两列，并选择前三行的数据。

print(df.ix[:3,['A','C']])
    """ A C 2013-01-01 0 2 2013-01-02 4 6 2013-01-03 8 10 """

#### 通过判断的筛选 ####

最后我们可以采用判断指令 (Boolean indexing) 进行选择. 我们可以约束某项条件然后选择出当前所有数据.

print(df[df.A>8])
    """ A B C D 2013-01-04 12 13 14 15 2013-01-05 16 17 18 19 2013-01-06 20 21 22 23 """

### 设置值 ###

#### 根据位置设置 loc 和 iloc ####

我们可以利用索引或者标签确定需要修改值的位置。

df.iloc[2,2] = 1111
    df.loc['20130101','B'] = 2222
    
    """ A B C D 2013-01-01 0 2222 2 3 2013-01-02 4 5 6 7 2013-01-03 8 9 1111 11 2013-01-04 12 13 14 15 2013-01-05 16 17 18 19 2013-01-06 20 21 22 23 """

#### 根据条件设置 ####

如果现在的判断条件是这样, 我们想要更改B中的数, 而更改的位置是取决于 A 的. 对于A大于4的位置. 更改B在相应位置上的数为0.

df.B[df.A>4] = 0
    """ A B C D 2013-01-01 0 2222 2 3 2013-01-02 4 5 6 7 2013-01-03 8 0 1111 11 2013-01-04 12 0 14 15 2013-01-05 16 0 18 19 2013-01-06 20 0 22 23 """

#### 按行或列设置 ####

如果对整列做批处理, 加上一列 ‘F’, 并将 F 列全改为 NaN, 如下:

df['F'] = np.nan
    """ A B C D F 2013-01-01 0 2222 2 3 NaN 2013-01-02 4 5 6 7 NaN 2013-01-03 8 0 1111 11 NaN 2013-01-04 12 0 14 15 NaN 2013-01-05 16 0 18 19 NaN 2013-01-06 20 0 22 23 NaN """

#### 添加数据 ####

用上面的方法也可以加上 Series 序列（但是长度必须对齐）。

df['E'] = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130101',periods=6)) 
    """ A B C D F E 2013-01-01 0 2222 2 3 NaN 1 2013-01-02 4 5 6 7 NaN 2 2013-01-03 8 0 1111 11 NaN 3 2013-01-04 12 0 14 15 NaN 4 2013-01-05 16 0 18 19 NaN 5 2013-01-06 20 0 22 23 NaN 6 """

### 导入导出数据 ###

#### 导入 ####

pd.to_csv("../learn/kline_excel")
    # print(data_csv)

#### 导出 ####

data_csv=pd.read_csv("../learn/kline_excel")
    # print(data_csv)

> 导入导出分别使用`to_xxx`和`read_xxx`，其中`xxx`使用相应的文件类型，如`excel`、`txt`、`json`等等

### 合并 ###

`pandas`处理多组数据的时候往往会要用到数据的合并处理,使用 `concat`是一种基本的合并方式.而且`concat`中有很多参数可以调整,合并成你想要的数据形式.

#### axis (合并方向) ####

axis=0是预设值，因此未设定任何参数时，函数默认axis=0。

#定义资料集
    df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'])
    df2 = pd.DataFrame(np.ones((3,4))*1, columns=['a','b','c','d'])
    df3 = pd.DataFrame(np.ones((3,4))*2, columns=['a','b','c','d'])
    
    #concat纵向合并
    res = pd.concat([df1, df2, df3], axis=0)
    
    #打印结果
    print(res)
    # a b c d
    # 0 0.0 0.0 0.0 0.0
    # 1 0.0 0.0 0.0 0.0
    # 2 0.0 0.0 0.0 0.0
    # 0 1.0 1.0 1.0 1.0
    # 1 1.0 1.0 1.0 1.0
    # 2 1.0 1.0 1.0 1.0
    # 0 2.0 2.0 2.0 2.0
    # 1 2.0 2.0 2.0 2.0
    # 2 2.0 2.0 2.0 2.0

仔细观察会发现结果的`index`是0, 1, 2, 0, 1, 2, 0, 1, 2，若要将`index`重置，请看例子二。

#### ignore\_index (重置 index) ####

#承上一个例子，并将index_ignore设定为True
    res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)
    
    #打印结果
    print(res)
    #     a    b    c    d
    # 0  0.0  0.0  0.0  0.0
    # 1  0.0  0.0  0.0  0.0
    # 2  0.0  0.0  0.0  0.0
    # 3  1.0  1.0  1.0  1.0
    # 4  1.0  1.0  1.0  1.0
    # 5  1.0  1.0  1.0  1.0
    # 6  2.0  2.0  2.0  2.0
    # 7  2.0  2.0  2.0  2.0
    # 8  2.0  2.0  2.0  2.0

结果的`index`变0, 1, 2, 3, 4, 5, 6, 7, 8。

#### join (合并方式) ####

join='outer’为预设值，因此未设定任何参数时，函数默认join=‘outer’。此方式是依照column来做纵向合并，有相同的column上下合并在一起，其他独自的column个自成列，原本没有值的位置皆以NaN填充。

#定义资料集
    df1 = pd.DataFrame(np.ones((3,4))*0, columns=['a','b','c','d'], index=[1,2,3])
    df2 = pd.DataFrame(np.ones((3,4))*1, columns=['b','c','d','e'], index=[2,3,4])
    
    #纵向"外"合并df1与df2
    res = pd.concat([df1, df2], axis=0, join='outer')
    
    print(res)
    #     a    b    c    d    e
    # 1  0.0  0.0  0.0  0.0  NaN
    # 2  0.0  0.0  0.0  0.0  NaN
    # 3  0.0  0.0  0.0  0.0  NaN
    # 2  NaN  1.0  1.0  1.0  1.0
    # 3  NaN  1.0  1.0  1.0  1.0
    # 4  NaN  1.0  1.0  1.0  1.0

原理同上个例子的说明，但只有相同的column合并在一起，其他的会被抛弃。

#承上一个例子
    
    #纵向"内"合并df1与df2
    res = pd.concat([df1, df2], axis=0, join='inner')
    
    #打印结果
    print(res)
    #     b    c    d
    # 1  0.0  0.0  0.0
    # 2  0.0  0.0  0.0
    # 3  0.0  0.0  0.0
    # 2  1.0  1.0  1.0
    # 3  1.0  1.0  1.0
    # 4  1.0  1.0  1.0
    
    #重置index并打印结果
    res = pd.concat([df1, df2], axis=0, join='inner', ignore_index=True)
    print(res)
    #     b    c    d
    # 0  0.0  0.0  0.0
    # 1  0.0  0.0  0.0
    # 2  0.0  0.0  0.0
    # 3  1.0  1.0  1.0
    # 4  1.0  1.0  1.0
    # 5  1.0  1.0  1.0