数据分析-pandas

数据分析，pandas python pandas使用详解 各种函数 命令 读取储存等 汇总 笔记

pandas for python

• 模块介绍
  • 功能及应用
    • 处理数值之外的数据类型，比如字符串，时间序列
    • 处理的数据类型
      • Series，一维带标签数组
      • DataFrame，二维的Series容器
  • 安装
    • pip install pandas，canda install pandas
  • 配套模块
    • numpy，matplotlib
  • 导入模块
    • import pandas as pd
• 数据的诞生
  • 读取与储存
    • 读取文件
      • csv
        • pd.read_csv('文件名'）
      • excel
        • （excel、hdf、sql、json、msgpack、 html、gbqstata、sas、clipboard、pickle） pd.read_sql(sql_sentence,connection），
      • josn
      • sql
      • html
    • 保存文件
      • to_csv
        • pd.to_csv('文件名'）（excel、hdf、sql、json、msgpack、 html、gbqstata、sas、clipboard、pickle）
      • to_excel
      • to_sql
      • to_josn
  • 创建一维Series
    • 手动输入数据
      • 默认索引
        • pd.Series([1,2,3,4...]),默认索引为01234... pd.Series([i for i in range(n)])
      • 指定索引
        • pd.Series(dict)
    • 随机生成数据
      • 默认索引
        • pd.Series([1,2,3,4...]，index=list('abcd...')) pd.Series([1,2,3,4...]，index=list('abcd...'))
      • 指定索引
      • 随机索引
  • 创建二维DataFrame
    • 手动输入数据
      • 默认索引
        • pd.Series([1,2,3,4...]，index=list('abcd...')) pd.Series([1,2,3,4...]，index=list('abcd...'))
      • 指定索引
    • 索引生成
      • 字母索引
        • index=list（string.ascii_uppercase[:]）
      • 时间索引
    • 随机生成数据
      • 默认索引
        • pd.Series([1,2,3,4...]，index=list('abcd...')) pd.Series([1,2,3,4...]，index=list('abcd...'))
      • 指定索引
        • pd.DataFrame(np.arange(12).reshape(3,4),index=list('abc'),columns=list('ABCD'))
      • 随机索引
• 数据的查询操作
  • 数据结构查询
    • 查看数据类型
      • x.describe()
    • 查看数据形状
      • df.shape
    • 取列名
      • list(df) or df.columns
    • 为每列去重并统计个数
      • df.nunique()
  • 数据信息查询
    • 查看数据键值信息
      • df.info()
    • 查看每列空值的占比
      • df.apply(lambda x: sum(x.isnull()) / len(x), axis=0)
    • 查看数据头部n行
      • df.head(n)
    • 查看数据尾部n行
      • df.tail(n)
    • 查看所有数据的统计信息
      • df.describe()
    • 对选定列进行去重计数
      • counts = df[df['Quantity']>0]['InvoiceNo'].drop_duplicates().count()
  • 列查询
    • 标签索引取值
      • x['标签名']
    • 默认索引取值
      • x[a]，x[a：b]
    • 布尔索引取值
      • x[x>a]
    • 列数据筛选
      • 删除含有空值的列，慎用，并copy新的数组
        • df1 = dropna（axis=1，how="any"，inplace="True"）.copy()
      • 单列筛选
        • df1=df[df['列名']>0]
      • 多列筛选
        • df1=df[(df['列名1']>0)&(df['列名2']>0)]
    • DataFrame查询
      • x.index，x.columns， x.shape，x.values，x.dtype
    • Series查询
      • x.index， x.values，x.dtype
    • 包含字符查询
      • df[df.col.str.contains('str')]
  • 行查询
    • 单层索引
      • 首尾查询
        • df.head(a)：头部a行内容，df.tail(a)：尾部a行内容
      • 取行值
        • pf[a]，pf[：a]，pf[a：]，pf[a：b]
          • 单纯数字索引只选择行
      • 取列值
        • pf[“abc”]
          • 字符串索引只选择列
      • 子主题
        • pf（[a][“abc”]）
          • 通过行和列共同取值
    • 多层索引
      • df.index.levels[0]
      • L7D_desc=cou_desc.loc[(slice(None),last_7_day),:]
  • 行列混合查询
    • 标签索引取值
      • 取单一值
        • pf.loc[“a”，“A”]
          • 取a行a列的那个值
      • 取行值
        • 单一行
          • pf.loc[“a”]，或 pf.loc[“a”，：]
        • 零散的多行
          • pf.loc[“a","b","c"]，或 pf.loc[[“a","b","c"]，：]
        • 连续的多行
          • pf.loc['a':'c']，或pf.loc['a':'c',:]
      • 取列值
        • 单一列
          • pf.loc[：，“a”]
        • 零散的多列
          • pf.loc[：,[“a","b","c"]]
        • 连续的多列
          • pf.loc[：，[“a":"b"]]
      • 取行列交叉处
        • 零散挑取
          • pf.loc[[“a","b","c"]，[“A","B","C"]]
        • 连续取
          • pf.loc['a':'c','A':'C']
    • 布尔取值
      • 数值判断取值
        • pf[(df["abc"]>m)&(df["abc"]<n)]
      • 字符串长度取值
        • pf[(df["abc"].str.len()>m)&(df["abc"]<n)]
    • 定位取值
      • 和nunpy的切片取值一样，赋值方法也一样，行和列都用数字标序，中间用逗号隔开
      • pf.iloc[m,n]，pf.iloc[m,：]，pf.iloc[：,m]，pf.iloc[[m,n],[m,n]]，pf.iloc[[m:n],[m:n]]
• 数据的数据操作
  • 处理异常值
    • # all_data.fillna({np.inf:0},inplace=True) all_data.replace(np.inf,0,inplace=True) #all_data[np.isinf(all_data[''])]# = 0 ## 将无穷大替换成nan
  • 处理NAN空值
    • 是否NaN
      • pd.isnull(pf)，pd.notnull(pf)
        • 返回布尔值
    • 处理为0的数据
      • ps[ps==0]=np.nan
        • pandas 里nan 不参与计算，均值和中值就更准确
    • 处理方法
      • 删除
        • dropna（axis=0，how="any"，inplace="True"）
          • 0为行，1为列；any为行列有nan就删， all为行列全为nan才删，True为改修原数组 False不修改原数组
      • 填充
        • pf.fillna(a)，pf.fillna(pd.mean())，pf["xxx"].fillna(pd["xxx"].median())
  • 处理重复值
    • 删除重复行
      • df.drop_duplicates()
  • 处理数据格式
    • 将str转换成datetime：df1['Date'] = pd.to_datetime(df1['Date'],errors='coerce')
    • for i in ['Days_score','Buys_score','Amounts_score']: df[i] = df[i].astype(float)
  • 处理字符型数据
    • 按条件修改数据
      • df['payment'].mask(df['Discount']>1,None)
    • 批量修改指定数据
      • data['week']=data.orderTime.dt.dayofweek.map({1:'星期一',2:'星期二',3:'星期三',4:'星期四',5:'星期五',6:'星期六',0:'星期日'})
  • 处理时间型数据
    • set，cat，contains，count，endswith，startswith，findall，get，join，len，lower，upper，match，pad，center，repeat，replace，slice，split，strip，rstrip，lstrip
    • 转化成列表
      • pf.tolist()
        • 转化成词典
          • pf.to_dict()
  • 处理数值型数据
    • 数据分等级
      • scores = pd.cut(df['column'],bins=[数据区间], labels=[编号(比bins小一个)],right=False)
      • 将列数据区分等级
• 数据的结构操作
  • 1. 数据结构增加
    • 1. 删除含有空值的行，并copy新的数组
      • df1 = dropna（axis=0，how="any"，inplace="True"）.copy()
    • 2. 添加列
      • 以多个原列数学运算的方式增加列
        • df['new_column'] = df['column1'] * df['column2']
        • df1['new_column'] = df1.apply(lambda x: x[列序号]*x[列序号],axis=1)
      • 以函数方式增加列
        • df['新列名'] =df['原列名'].apply(函数名)
      • 以某列为基础判断增加列
        • df['新列名'] = np.where(df['列名']>某个值, '是','否')
      • 原列中直接提取列
        • 列属性是str：df['Year'] = [x.split('/')[2] for x in df['Date']]
      • 在时间列中提取新列
        • 列属性是datetime：df1['month'] = df1['date'].dt.month
      • 多列合并生成新列
        • df['新列名'] = df['列名1'].str[:]+df['列名2'].str[:]+df['列名3'].str[:]
      • 添加其他行数相同的数组
        • df.append([df1,df2],axis=0,ingore_index=True)
    • 3. 添加行
    • 4. 替换空值列
      • df['column'] = df['column'].fillna('U')
  • 2. 数据结构修改
    • 改columns
      • df.rename(columns={'原列名':'新列名'},inplace = True)
    • 改index
      • 重新设置index
        • df.reset_index(inplace=True) 设置新index，并将原来的index改成列
        • df.reset_index(drop=True，inplace=True) 设置新index，并删除原来的index
      • 将某列设置成index
        • df.set_index(['col'],inplace=True)
    • 排序
      • df.sort_values(by="列索引名"，ascending=Ture（升序）False（降序）)
  • 3. 数据结构删除
    • 1. 删除列
      • df.drop(['column'], axis=1, inplace=True)
    • 2. 删除行
      • df.drop(index=df[df.orderID.duplicated()].index,inplace=True)
  • 4. 数据结构重组
    • 1. 数据聚合
      • df.groupby('col').agg({'InvoiceNo':'nunique','Quantity':np.sum, 'Amount':np.sum})
      • new_df = df[df['Quantity'] > 0].groupby('CustomerID').agg({'InvoiceNo':'nunique', 'Quantity':np.sum, 'Amount':np.sum})
      • 给定条件及分组情况下， 进行多列去重并计算，生成新数组
    • 2. 数据透视
      • pd.pivot_table(df1,index='Year',columns='Month', alues='Amount',aggfunc={'Amount':np.sum})
      • 数据透视函数 pandas.pivot_table()
  • 5. 数据结构拼接
    • 相似结构聚合
      • 补全式合并
        • pd.concat([df0,df1,df2],axis=0,ingore_index=True) 0为竖着合并，1为横着合并；形状不同，以大数组为准，小数组补全处填充nan
      • 相同行数直接拼接
        • df = pd.concat([Dataframe1,Series1,Series2],axis=1)
      • 相同标签合并
        • pd.concat([df0,df1,df2],join='inner',axis=0,ingore_index=True) join 默认为outer 填充nan 补充；inner只选择列标签相同的合并
      • 指定数组合并
        • pd.concat([df0,df1],axis=1,join_axes=[df1.index]) 以指定数组的标签为生成标签
      • 添加式合并
        • df0.append([df1,df2],axis=0,ingore_index=True) 可添加dataframe 和series
    • 共标签聚合
      • 共标签合并
        • pd.merge(df1,df2,on='key') 多个数组都含有同一种标签，并且标签值全部相同，合并后该标签只留下一个
      • 共标签但值 不同的合并
        • pd.merge(df,df2,on='key',how='inner') 只考虑标签下相同值的行进行合并，值不同的舍弃 how（outer、inner、left、right）其他三个参数进行填充合并，可以多个key 进行合并
        • pd.merge(df,df2,on='key',how='inner'，indicator=True) ，显示合并的信息，也可以自定义
        • pd.merge(df,df2,left_index=True,right_index=True,how='inner') ，根据index合并，不存在用nan填充
        • pd.merge(df1,df2,on='key',suffixes=['_df1','_df2'],how='inner') ，合并后，分别给非公用标签的其他相同的标签名重新命名
      • 两个以上表格共标签合并
        • df1.join([df2,df3,df4,....],how='left') 默认以第一个标签为基准 how--inner交集，outer 并集，left 以右边为基本，right 以左边为基准
• 数据的运算操作
  • 列数据运算
    • 列分组运算
      • Cus_Amount = df3.groupby('CustomerID')['Amount'].sum()
    • 列数据频数统计
      • counts = df['列名'].value_counts()
  • 数值计算
    • 运算方式：np.sum(x,axis=0)，或 x.sum(axis=0)
    • 单列自运算
      • df['col']=df['col'] (+-*/%) n
      • 上下行错位计算
        • df['col1']=df['col'].diff(1),下一行与上一行相减
        • df['col1']=df['col'] (+-*/%) df['col'].shift(n) n表示错n行
    • 多列混合预算
      • df['newcol']=df['col1'] (+-*/%) df['col2']
      • 上下行错位计算
        • df['col1']=df['col'].diff(1),下一行与上一行相减
        • df['newcol']=df['col1'] (+-*/%) df['col2'].shift(n) n表示错n行
  • 数据统计
    • 统计性描述
      • df.describe()
    • 求和
      • x.sum(x)：求数组的总和，返回一个数值 x.sum(axis=0)：求每列的和，并返回一个数列 x.sum(axis=1)：求每行的和，并返回一个数列
    • 求平均
      • x.mean(x)：求数组的均值，返回一个数值 x.mean(axis=0)：求每列的均值，并返回一个数列 x.mean(axis=1)：求每行的均值，并返回一个数列
    • median:中值，max:最大值，min最小值，ptp:极值，std:标准差,mode():众数
  • 函数运算
    • apply方法 对列行或整个数组的每个都返回一个值
      • apply方法是一般性的“拆分-应用-合并”方法。它既可以得到一个经过广播的标量值，也可以得到一个相同大小的结果数组
      • df.apply(func,)
        • 应用在DataFrame的行或列中
      • applymap：应用在DataFrame的每个元素中；
      • map：应用在单独一列（Series）的每个元素中,特别是以编号匹配名称方面更有用
    • 聚合函数 一列或一行只返回一个值
      • 单聚合函数
        • mean(),sum(),median(),std(),unique(),size(),count(),max(),min(),mode(), ptp(),var(),prod(),first(),last(),自定义函数
      • 打包聚合函数
        • 方法一： df[['col1','col2','col3',...]].agg(['mean','sum','std',...]) 对前面每列进行agg中所有聚合函数计算，describe具有类似功能
        • 方法二： df.groupby('col').agg({'col1':'mean'，'col2':'sum','col3':['mean','std','sum']....}) df.agg({'col1':'mean'，'col2':[自定义函数],'col3':['mean','std','sum']....}) 对agg中对应的列进行对应聚合函数计算