Pandas笔记-2-Pandas基础

文件的读写、基本数据结构、常用基本函数、窗口对象

文件的读写

文件读取

pandas可以读取很多文件格式,此处只讲csv,excel,txt

  • df_csv=pd.read_csv(.csv)
  • df_txt=pd.read_table(.txt)
  • df_excel=pd.read_excel(.xlsx)
    有一些常用的公共参数
  • header=None表示第一行不作为列名
  • index_col=['col1','col2']表示将某一列或几列作为索引
  • usecols=['col1','col2']要读取的列的集合,默认全部
  • parse_dates=['col']需要转化为时间的列
  • nrows=3要读取的行数
    读取txt文件遇到分隔符非空格,添加分割参数sep,并指定引擎为python,如
pd.read_table('filepath.txt',sep='re',engine='python')

需要注意,sep是正则参数

数据写入

df_csv.to_csv('filepath.csv',index=False)常把index设置为False,特别是在索引无特殊意义时,保存时能够去除索引。
df_txt.to_csv('filepath.txt',sep='\t',index=False)没有to_table,常用\t分割
df_csv.to_markdown()df_csv.to_latex()能将表格转换为markdownlatex语言

基本数据结构

一维的Series和二维的DataFrame

Series

s = pd.Series(data = [100, 'a', {'dic1':5}],#序列的值
              index = pd.Index(['id1', 20, 'third'], name='my_idx'),#索引,也可以指定名字,默认为空
              dtype = 'object',#存储类型
              name = 'my_name'#序列名字)

object代表一种混合类型,pandas将纯字符串序列也默认视为object类型序列,但也可以用string类型存储
可以通过.的方式获取属性,如s.values,s.index等,使用.shape获取序列的长度

DataFrame

DataFrameSeries上增加了列索引,可以通过二维的data与行列索引来构造

data = [[1, 'a', 1.2], [2, 'b', 2.2], [3, 'c', 3.2]]
df = pd.DataFrame(data = data,
                  index = ['row_%d'%i for i in range(3)],
                  columns=['col_0', 'col_1', 'col_2'])

更多的,会采用从列索引名到数据的映射来构造数据框,并加上行索引

df = pd.DataFrame(data = {'col_0': [1,2,3],
                          'col_1':list('abc'),
                          'col_2': [1.2, 2.2, 3.2]},
                  index = ['row_%d'%i for i in range(3)])

DataFrame中可以用df.['col_1']df.[[col_1,col_2]]来取出相应的列与多个列组成的表,返回类型分别为SeriesDataFrame
Series类似,DataFrame也可以取出相应的属性
通过.TDataFrame转置

常用基本函数

汇总函数

head(n)tail(n)返回前n或后n行,n默认为5
info(),describe()返回表的信息概况和表中数值列对应的主要统计量

特征统计函数

sum求和,mean平均值,median中位数,var方差,std标准差,maxmin
quantile(n)分位数,count非缺失值个数,idxmax最大值对应索引
以上函数有公共参数axis,默认0逐列聚合,1逐行聚合

唯一值函数

对序列使用unique,nunique得到唯一值组成的列表和唯一值个数
value_counts得到唯一值和其对应的频数
drop_duplicates(['col_name1','col_name2',···],keep=first)多个列组合的唯一值,keep默认first表示保留第一次出现的行,last最后,false重复的删除(这让我想起了sql的distinct)drop_duplicated返回是否为唯一值的布尔列表

替换函数

pandas中的替换函数包含映射替换、逻辑替换、数值替换

  • 映射替换(replace,str.replace,cat.codes

  • replace
    可以通过字典构造,或者传入两个列表来替换

    df['col_name1'].replace({'key_1': value_1,'key_2':value_2})
    df['col_name1'].replace(['key_1','key_2'],[value_1,value_2])

    可以指定method参数为ffillbfill,分别使用前一个或后一个未被替换的值替换
    如果没有这样的值,那么就取头或尾的值,如

    s = pd.Series(['a', 1, 'b', 2, 1, 1, 1])
    s.replace([1, 2], method='bfill')
  • 逻辑替换(where,mask
    where对不符合传入条件的行进行替换,mask反之,不指定替换之则替换为缺失值NaN
    s.where(s_condition,value)
    也可以传入与s索引一致的布尔序列

    s_condition =pd.Series([True,False,···],index=s.index)
    s.where(s_condition,value)
  • 数值替换(round,abs,clip

    • round按给定精度四舍五入
    • abs取绝对值
    • clip截断

排序函数

  • 值排序(sort_values
    df.sort_values('col_1',ascending=True)ascending默认True升序。
    可以对多列排序
    df.sort_values(['col_1','col_2',···],descending=[True,False]),传入两个列表即可
  • 索引排序(sort_index
    用法与值排序一致,但元素的值在索引中,要指定索引层的名字或层号,用level表示。字符串按字母顺序排序
    df.sort_index(level=['col_1','col2'],ascending=[True,False])

apply方法

apply方法常用于DataFrame的行迭代或者列迭代,其参数往往是一个以序列为输入的函数,如.mean(),可以这样写出

def my_mean(x):#x为输入的序列
    res=x.mean()
    return res
df.apply(my_mean())

也可以使用lambda表达式df.apply(lambda x:x.mean())
apply使用性能换取自由度,仅在有自定义需求时再去考虑使用

窗口对象

滑窗对象

要使用滑窗函数,必须先对一个序列使用.rolling得到滑窗对象,最重要的参数是滑窗大小window

roller=s.rolling(window=3)

类滑窗函数,公共参数periods=n,默认为1,可以为负,表示反向操作
它们的功能可以用窗口大小为n+1rolling方法等价替代

  • shift取向前第n个元素的值

    s.rolling(3).apply(lambda x:list(x)[0]) # s.shift(2)
  • diff与向前第n个元素做差(区别于numpy)

    s.rolling(3).apply(lambda x:list(x)[0]) # s.shift(2)
  • pct_change与向前第n个元素相比计算增长率。

    def my_pct(x):
       L = list(x)
       return L[-1]/L[0]-1
    s.rolling(2).apply(my_pct) # s.pct_change()

扩张窗口

又称累计窗口,可以理解为一个动态长度的窗口,其窗口的大小就是从序列开始处到具体操作的对应位置,其使用的聚合函数会作用于这些逐步扩张的窗口上。具体地说,设序列为a1, a2, a3, a4,则其每个位置对应的窗口即[a1]、[a1, a2]、[a1, a2, a3]、[a1, a2, a3, a4]。
与类滑窗函数类似,也有类扩张窗口函数

  • cummax

    s.expanding().apply(lambda x: max(x))#s.cummax()
  • cumsum

    s.expanding().apply(lambda x: sum(x))#s.cumsum()
  • cumprod

    s.expanding().apply(lambda x: x.values.prod())#s.cumprod()