Python模块之Pandas

╰+哭是因爲堅強的太久メ 2023-07-25 05:25 30阅读 0赞

#### 基本属性 ####

import pandas as pd
    # 形状
    df.shape
    # 行索引
    df.index
    # 列索引
    df.columns
    # 值
    df.values
    # 转置
    df.T
    # 前N行 默认是5行
    df.head()
    # 后N行 默认是5行
    df.tail()
    # 查看类型
    df.dtypes
    # 指定类型
    df.astype(int)

#### 常用操作 ####

import numpy as np
    import pandas as pd
    
    df: pd.DataFrame
        
    # 删除指定列 col1, col2
    df.drop([col1, col2], axis=1, inplace=True)
    
    # 针对 city name 2列进行去重
    df.drop_duplicates(subset=["city", "name"], inplace=True)
    
    # 对Series进行操作 Series.str转成srt 可调用string的方法
    df['typecode'].str.endswitch('00') # typecode 以00 结尾
    # 对 text 列 使用正则提取 放入rating
    df['rating'] = df['text'].str.extract(r'(\d+\.?\d*\/\d+)', expand=False)
    
    # 对1列 拆分成2列
    df = pd.DataFrame({ 'AB': ['A1-B1', 'A2-B2']})
    df['A'], df['B'] = df['AB'].str.split('-', 1).str
    
    # 对Series 转成list
    df['A'].values.tolist()

#### 索引 ####

# 修改所有行列索引
    new_idx = []
    new_col = []
    df = df(index=new_idx, columns=new_col)
    
    # 修改单个索引 inplace=True 替换原来的
    data.rename(index={ "0": "股票1", "1":"股票2"}, inplace=True)
    data.rename(columns={ "city": "cityname", "ccode": "citycode"}, inplace=True)
    
    # 设置新的下标索引
    df.reset_index(drop=True)
    
    # 把某列的值设置为索引,设多列 会变成MultiIndex 复合索引 表示多维数据
    df.set_inde(keys, drop=True)

#### 取值 ####

# 直接使用行列索引(先列后行)
    df["open"][9]  # 单个数据
    df[['open', 'close']][1:7]  # 连续行
    df[['open', 'close']][df.index.isin([1, 4, 8])]  # 非连续行
    
    # 通过loc 使用索引名 (先行后列)
    df.loc["行索引0": "行索引9", "NEW_TYPE":"中类"]
    
    # 通过iloc 使用索引下标 (先行后列)
    df.iloc[:3, 1:5]

#### 运算 ####

# 加减乘除 直接使用算术表达式 或者 使用函数 add/sub/mul/div
    df["pop_sum"] = df["pop_1"] + df["pop_2"]
    
    # 逻辑运算 > >= < <= == != 得到bool的结构
    df[df["pop_sum"] > 10]
    
    # 与(&)或(|)非(~)
    df[(df["pop_1"] > 10) & (df["pop_2"] < 50)]
    df[(df["pop_1"] > 10) | (df["pop_2"] < 50)]
    df[~df["pop_1"] > 10]
    
    # 传入布尔表达式,进行查询过滤
    df.query("pop_1 > 10 & pop_2 < 50")
    
    # 返回布尔结构 可做索引 
    df[df["pop_1"].isin([10, 20, 30, 40])]
    
    # 统计运算 返回每列 常见的统计量 非空数量/平均值/标准差/最大值/最小值/中位数/分位数
    df.describe()
    
    # 统计运算 默认对列操作, axis=1 对行操作
    df.sum()

*  统计运算(默认对列操作, `axis=1` 对行操作)

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>作用(针对非 NaN 值)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>sum</code></td> 
   <td>和</td> 
  </tr> 
  <tr> 
   <td><code>mean</code></td> 
   <td>平均数</td> 
  </tr> 
  <tr> 
   <td><code>median</code></td> 
   <td>中位数</td> 
  </tr> 
  <tr> 
   <td><code>min</code></td> 
   <td>最小值</td> 
  </tr> 
  <tr> 
   <td><code>max</code></td> 
   <td>最大值</td> 
  </tr> 
  <tr> 
   <td><code>mode</code></td> 
   <td>众数</td> 
  </tr> 
  <tr> 
   <td><code>abs</code></td> 
   <td>绝对值</td> 
  </tr> 
  <tr> 
   <td><code>prod</code></td> 
   <td>Product of values</td> 
  </tr> 
  <tr> 
   <td><code>std</code></td> 
   <td>标准差</td> 
  </tr> 
  <tr> 
   <td><code>var</code></td> 
   <td>方差</td> 
  </tr> 
  <tr> 
   <td><code>idxmax</code></td> 
   <td>计算最大值所在的索引</td> 
  </tr> 
  <tr> 
   <td><code>idxmin</code></td> 
   <td>计算最小值所在的索引</td> 
  </tr> 
  <tr> 
   <td><code>cumsum</code></td> 
   <td>计算前1/2/3/…/n个数的和</td> 
  </tr> 
  <tr> 
   <td><code>cumprod</code></td> 
   <td>计算前1/2/3/…/n个数的积</td> 
  </tr> 
  <tr> 
   <td><code>cummax</code></td> 
   <td>计算前1/2/3/…/n个数的最大值</td> 
  </tr> 
  <tr> 
   <td><code>cummin</code></td> 
   <td>计算前1/2/3/…/n个数的最小值</td> 
  </tr> 
 </tbody> 
</table>

*  **idxmax / idxmin** 调用报错

TypeError: reduction operation 'argmax' not allowed for this dtype

*  从文件中读取数据后, 默认元素类型是object
 *  df.dtypes 查询所有列的数据类型
 *  读取时使用dtype 或 读取后使用astype转换
 *  pd.to\_numeric(s, errors=’’") 转成数值
    
     *  error = ‘raise’ 无效值 报错
     *  errors=‘coerce’ 无效值强制转为NaN
     *  errors=‘ignore’ 异常值忽略
 *  自定义运算

df.apply(func, axis=0, args=())
     # func: 函数 对行/列进行操作
     # axis=0: 0或者'index'对行操作, 1或者'columns'是对列运算
     # result_type: {'expand', 'reduce', 'broadcast', None}, default None. axis=1才生效
     	# 'expand' : 类似列表的结果 返回列
        # 'reduce' : 跟'expand'相反
        # 'broadcast' : 结果广播
     # agrs: 其他位置参数
     # **kwds: 其他关键字参数
    
    def temp(a,  b):
        return a+1, b+2
    
    df = pd.DataFrame({ 'name': ['Amy', 'Bob', 'Cindy', 'David'],
                        'a': [1, 2,  3, 4],
                        'b': [1, 4, 9,  16]})
    
    df['name'] = df.apply(lambda x: x['name'].lower(), axis=1)
    df[['a', 'b']] = df.apply(lambda x: temp(x['a'], x['b']), axis=1, result_type='expand')

*  排序

# 对值排序 根据单个/多个列,进行排序,默认升序 
    df.sort_values(by=[], ascending=True)
    # 对索引排序
    df.sort_index(axis=0, ascending=True)

#### IO 操作 ####

##### 读写csv #####

pd.read_csv(filepath_or_buffer, sep=",", header="infer", names=None,index_col=None, dtype={ }, encoding="utf-8", usecols=None)

*  pd.read\_csv()
    
     *  读取csv 文件
     *  filepath\_or\_buffer: 文件路径
     *  sep: 分隔符 默认,
     *  header: 指定做列索引的行, 默认是 infer (推断)
     *  names: 添加列名. 有列名的情况下 设置 header=0
     *  index\_col: 指定做行索引的列, 传下标或者列名
     *  dtype: 指定类型 指定所有 或 特定几列 dict
     *  usecols: 指定读取的列名 list
     *  encoding: 编码格式
 *  pd.to\_csv()
    
     *  写入 csv
     *  path\_or\_buf: 路径
     *  sep: 分隔符, 默认是 ,
     *  columns: 指定列
     *  index: 是否写入行索引
     *  header: 是否写入列索引
     *  mode: ‘w’ 重写 ‘a’ 追加
     *  encoding: 编码格式

##### HDF5 一种容器 可以存放多份数据 通过不同的 key来区分比 csv 读写更快 内存更小 #####

*  pd.HDFStore("./test.h5").keys()
    
     *  获取 test.h5 文件所有的 key
 *  pd.read\_hdf()
    
     *  读取 hdf5 文件
     *  path\_or\_buf: 路径
     *  key: 读取的键 单份数据 可不输入
     *  mode: 打开文件的方式
 *  pd.to\_hdf()
    
     *  写入hdf5 文件
     *  path\_or\_buf: 路径
     *  key: 必须提供 key
     *  mode: 打开文件的方式

##### 读写json #####

*  pd.read\_json()
    
     *  读取 json 文件
     *  path\_or\_buf: 路径
     *  orient: json 文件的数据方式
        
         *  ‘split’ : dict like \{index -> \[index\], columns -> \[columns\], data -> \[values\]\}
         *  **’records’ : list like \[\{column -> value\}, … , \{column -> value\}\]**
         *  ‘index’ : dict like \{index -> \{column -> value\}\}
         *  **’columns’ : dict like \{column -> \{index -> value\}\}**,默认该格式
         *  ‘values’ : just the values array
     *  lines : boolean, default False
        
         *  按照每行读取json对象
 *  pd.to\_json()
    
     *  写入 json
     *  path\_or\_buf: 路径
     *  orient: json 文件的数据方式

##### 读取数据库 #####

import pandas as pd
    from sqlalchemy import create_engine
     # 使用 sqlalchemy
    engine = create_engine(f"mysql+pymysql://{DB_USERNAME}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}")
    # 或者 使用 pymysql
    import pymysql
    db = pymysql.connect(host, port, user, password,database, charset="utf8")
    sql = "select * from test_table"
    df = pd.read_sql(sql, engine)
    # 或者
    df = pd.read_sql(sql, db)

#### 缺失值(missing value)处理 ####

缺失值必须是 **np.nan**

*  判断缺失值是否存在
    
     *  df.isnull()
        
         *  配合 np.any() 查看整体是否有空值
     *  df.notnull()
 *  找出包含空值的列
    
     *  df.isnull().sum()
        
         *  为空 返回True 就是 1 累加>0 的列就含有空值
     *  df.isnull().apply(np.any)
 *  df.dropna(axis=‘rows’)
    
     *  删除包含空值的行
     *  需要接收返回值
 *  df.fillna(value, inplace=True)
    
     *  替换缺失值(均值/中值)
     *  inplace=True 修改原数据
     *  对几列操作 value 传 dict \{‘列名’:‘替换值’\}
        
         *  df.fillna(\{‘Live’: 111, ‘Task’:222\})

缺失值不为 np.nan 先替换再操作

*  df.replace(’?’, np.nan)

#### 离散化(结果是 Series) ####

*  pd.qcut(series, bins)
    
     *  按照给定的分组数量,自动切分series
     *  bins 传分组个数 int
 *  pd.cut(series,bins)
    
     *  按照给定的切分点分组
     *  bins 需要自定义分组区间 (传 list)
 *  pd.get\_dummies(*data*, *prefix=None*)
    
     *  创建one-hot 编码
     *  data:array-like, Series, or DataFrame
     *  prefix:分组名字

#### 合并 ####

*  pd.concat(\[data1, data2\], axis=1)
    
     *  按照行/列合并 axis=1 按行拼接
 *  pd.merge(left, right, how=‘inner’, on=None, left\_on=None, right\_on=None,left\_index=False, right\_index=False, sort=True,suffixes=(’\_x’, ‘\_y’), copy=True, indicator=False,validate=None)
    
     *  可以指定按照两组数据的共同键值对合并或者左右各自键合并
     *  基于一个/多个 key 合并(可以将多个 key 先组合视为一个 key 再合并)
     *  `how`: 连接方式
     *  `left`: A DataFrame object
     *  `right`: Another DataFrame object
     *  `on`: Columns (names) to join on. Must be found in both the left and right DataFrame objects.
     *  left\_on=None, right\_on=None：指定左右键

<table> 
 <thead> 
  <tr> 
   <th>Merge method</th> 
   <th>SQL Join Name</th> 
   <th>Description</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>left</code></td> 
   <td><code>LEFT OUTER JOIN</code></td> 
   <td>Use keys from left frame only</td> 
  </tr> 
  <tr> 
   <td><code>right</code></td> 
   <td><code>RIGHT OUTER JOIN</code></td> 
   <td>Use keys from right frame only</td> 
  </tr> 
  <tr> 
   <td><code>outer</code></td> 
   <td><code>FULL OUTER JOIN</code></td> 
   <td>Use union of keys from both frames</td> 
  </tr> 
  <tr> 
   <td><code>inner</code></td> 
   <td><code>INNER JOIN</code></td> 
   <td>Use intersection of keys from both frames</td> 
  </tr> 
 </tbody> 
</table>

#### 交叉透视表 ####

*  pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, margins\_name=‘All’, dropna=True, normalize=False)
    
     *  交叉表
     *  index: 指定交叉表的行
     *  columns: 指定交叉表的列d
     *  normalize: 默认为 False, ‘index’ 按行计算比例 ‘columns’ 按列计算比例
 *  pd.pivot\_table()
    
     *  透视表
     *  index
     *  columns
     *  values
     *  aggfunc=‘mean’ 计算平均值 count 计数

#### 分组与聚合 ####

对 df 做 groupby 生成 DataFrameGroupby 对象

做索引后 生成 SeriesGroupby 对象

*  df.groupby(key, as\_index=False)
    
     *  分组操作
     *  Key: 分组的列数据,可以多个
 *  聚合(sum/min/max/count/mean/std/var)

# 对 color 分组 对 price 求平均值
    data.groupby(['color'])['price'].mean()
    # 写法 2 Series.groupby(Series) 
    data['price'].groupby(data['color']).mean()

#### 分类 ####

*  pd.Categorical(values, categories=None, ordered=None, dtype=None, fastpath=False)
    
     *  数字化分类数据, 有效加快分类计算的效率
     *  values: list-like
     *  categories: 唯一类别
     *  ordered: 是否为有序分类
     *  属性
        
         *  categories: 分类索引
         *  codes: 对应的分类后的数组值d
         *  ordered: 顺序
         *  dtype: 类别
    
        c = pd.Categorical(['a','b','c','a','b','c'])
         c
         [a, b, c, a, b, c]
         Categories (3, object): [a, b, c]
             
         c.categories
         Index(['a', 'b', 'c'], dtype='object')
         
         c.codes
         array([0, 1, 2, 0, 1, 2], dtype=int8)
         
         c.ordered
         False
         
         c.dtype
         CategoricalDtype(categories=['a', 'b', 'c'], ordered=False)
 *  pd.factorize(values, sort=False, order=None, na\_sentinel=-1, size\_hint=None)
    
     *  转换为枚举或分类类型
     *  返回值
        
         *  labels : ndarray
         *  uniques : ndarray, Index, or Categorical

>>> labels, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'])
    >>> labels
    array([0, 0, 1, 2, 0])
    >>> uniques
    array(['b', 'a', 'c'], dtype=object)
    
    >>> labels, uniques = pd.factorize(['b', 'b', 'a', 'c', 'b'], sort=True)
    >>> labels
    array([1, 1, 0, 2, 1])
    >>> uniques
    array(['a', 'b', 'c'], dtype=object)
    
    >>> labels, uniques = pd.factorize(['b', None, 'a', 'c', 'b'])
    >>> labels
    array([ 0, -1,  1,  2,  0])
    >>> uniques
    array(['b', 'a', 'c'], dtype=object)
    
    >>> cat = pd.Categorical(['a', 'a', 'c'], categories=['a', 'b', 'c'])
    >>> labels, uniques = pd.factorize(cat)
    >>> labels
    array([0, 0, 1])
    >>> uniques
    [a, c]
    Categories (3, object): [a, b, c]

#### 时间索引 ####

*  pd.to\_datetime(arg, errors=‘raise’, dayfirst=False, yearfirst=False, utc=None, box=True, format=None, exact=True, unit=None, infer\_datetime\_format=False, origin=‘unix’, cache=False)
    
     *  转换成pandas的时间类型 Timestamp
     *  arg : integer, float, string, datetime, list, tuple, 1-d array, Series
     *  error: 异常解决办法 \{‘ignore’, ‘raise’, ‘coerce’\}, default ‘raise’
     *  dayfirst : boolean, default False.True 10/11/12 -> 2012-11-10
     *  yearfirst: boolean, default False.True 10/11/12 -> 2010-11-12
     *  format: 时间戳转为date 格式 %d/%m/%Y
     *  unit: 时间戳转 date 的精度 default ‘ns’
     *  origin: ‘unix’, 时间原点为 1970-01-01. 可自定义Timestamp 格式,从设置那天算起
    
        df = pd.DataFrame({ 'year': [2015, 2016],
                               'month': [2, 3],
                               'day': [4, 5]})
        pd.to_datetime(df)
        0   2015-02-04
        1   2016-03-05
        dtype: datetime64[ns]
        
        pd.to_datetime(1490195805433502912, unit='ns')
        Timestamp('2017-03-22 15:16:45.433502912')
        
        pd.to_datetime([1, 2, 3], unit='D',origin=pd.Timestamp('1960-01-01'))
        0    1960-01-02
        1    1960-01-03
        2    1960-01-04
        
        pd.Timestamp(1513393355.5, unit='s')
        Timestamp('2017-12-16 03:02:35.500000')
        
        # 有空值 结果会变成NaT类型
        dates = ['20200401', '20200402', '20200403', np.nan]
        pd.to_datetime(dates)
        DatetimeIndex(['2020-04-01', '2020-04-02', '2020-04-03','NaT'], dtype='datetime64[ns]', freq=None)
 *  pd.DatetimeIndex()
    
     *  与pd.to\_datetime 效果一样
 *  pd.Timestamp 类型
    
     *  属性 year,month,weekday,day,hour
     *  属性 .week 获取当前日期对应当前年份第几个星期(从 1 开始)
     *  方法.weekday() 获取当前日期对应星期几(从 0 开始)
 *  pd.date\_range(start=None, end=None, periods=None, freq=‘D’, tz=None, normalize=False, name=None, closed=None, \*\*kwargs)
    
     *  生成指定频率的时间序列
     *  start:开始时间
     *  end:结束时间
     *  periods:生成多长的序列
     *  freq:频率,默认是D(1天), ‘B’ 工作日
     *  tz: 时区
     *  close: 默认None 包含start和end, left 只包含start , end 只包含end
    
    <table> 
     <thead> 
      <tr> 
       <th align="center">参数</th> 
       <th align="center">含义</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="center">D</td> 
       <td align="center">每日</td> 
      </tr> 
      <tr> 
       <td align="center">B</td> 
       <td align="center">每工作日</td> 
      </tr> 
      <tr> 
       <td align="center">H、T或者min、S</td> 
       <td align="center">时、分、秒</td> 
      </tr> 
      <tr> 
       <td align="center">M</td> 
       <td align="center">每月最后一天</td> 
      </tr> 
      <tr> 
       <td align="center">BM</td> 
       <td align="center">每月最后一个工作日</td> 
      </tr> 
      <tr> 
       <td align="center">WOM-1MON, WOM-3FRI</td> 
       <td align="center">每月第几周的星期几</td> 
      </tr> 
     </tbody> 
    </table>
 *  pd.resample()
    
     *  频率转换和时间序列重采样，对象必须具有类似日期时间的索引（DatetimeIndex，PeriodIndex或TimedeltaIndex）
        
        <table> 
         <thead> 
          <tr> 
           <th>参数</th> 
           <th>说明</th> 
          </tr> 
         </thead> 
         <tbody> 
          <tr> 
           <td>rule</td> 
           <td>表示重采样频率，例如周’W’,月’M’,季度’Q’,5分钟’5min’,12天’12D’</td> 
          </tr> 
          <tr> 
           <td>how=’mean’</td> 
           <td>用于产生聚合值的函数名或数组函数，例如‘mean’、‘ohlc’、np.max等，默认是‘mean’，其他常用的值由：‘first’、‘last’、‘median’、‘max’、‘min’</td> 
          </tr> 
          <tr> 
           <td>axis=0</td> 
           <td>默认是纵轴，横轴设置axis=1</td> 
          </tr> 
          <tr> 
           <td>fill_method = None</td> 
           <td>升采样时如何插值，比如‘ffill’、‘bfill’等</td> 
          </tr> 
          <tr> 
           <td>closed = ‘right’</td> 
           <td>在降采样时，各时间段的哪一段是闭合的，‘right’或‘left’，默认‘right’</td> 
          </tr> 
          <tr> 
           <td>label= ‘right’</td> 
           <td>在降采样时，如何设置聚合值的标签，例如，9：30-9：35会被标记成9：30还是9：35,默认9：35</td> 
          </tr> 
          <tr> 
           <td>loffset = None</td> 
           <td>面元标签的时间校正值，比如‘-1s’或Second(-1)用于将聚合标签调早1秒</td> 
          </tr> 
          <tr> 
           <td>limit=None</td> 
           <td>在向前或向后填充时，允许填充的最大时期数</td> 
          </tr> 
          <tr> 
           <td>kind = None</td> 
           <td>聚合到时期（‘period’）或时间戳（‘timestamp’），默认聚合到时间序列的索引类型</td> 
          </tr> 
          <tr> 
           <td>convention = None</td> 
           <td>当重采样时期时，将低频率转换到高频率所采用的约定（start或end）。默认‘end’</td> 
          </tr> 
         </tbody> 
        </table>
 *  pd.rolling\_mean(arg, window, min\_periods=None, freq=None, center=False, how=None, \*\*kwargs)
    
     *  计算移动平均线
     *  arg: Series DataFrame
     *  window: 计算周期
 *  pd.ewma(com=None, span=one)
    
     *  指数平均线
     *  span:时间间隔
 *  pd.scatter\_matrix(frame, figsize=None)
    
     *  各项指数两两关联散点图
     *  frame:DataFrame