Pandas常用操作总结

Myth丶恋晨 2022-01-14 14:39 1371阅读 0赞

### 文章目录 ###

*  前言
 *  1、DF常用的两种创建方式
 *   *  方式一：通过np来生成
     *  方式二：通过字典来生成
 *  2、pandas常用的属性及方法
 *  3、Pandas Select(数据选择)
 *  4、Pandas Set\_values设置值
 *  5、Pandas Nan处理缺失值
 *   *  方法一：剔除缺失值所在的行或列
     *  方法二：填充Nan值
     *  方法三：显示Nan值的位置，做进一步处理
 *  6、Pandas导入导出数据
 *  7、pandas合并操作（重点）
 *   *  1、concat
     *  2、merge(更常用的操作)
 *  其他Demo
 *   *  1、从某行读取数据
     *  2、判断某列是否含有某值
     *  3、练手的Demo

# 前言 #

pandas：是一个数据分析包，灵活处理缺失值、类SQL操作，能处理多种类型的数据。  
DataFrame：表格型的数据结构，含有一组有序的列，每列的值的类型不同。可以看做是Series组成的字典（key为列名，value为Series）  
Series:类map的数据结构，区别是左边是一个index值，右边是value值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70]

# 1、DF常用的两种创建方式 #

两种方式：通过numpy和字典创建

## 方式一：通过np来生成 ##

#生成时间序列
    dates = pd.date_range('20160101', periods=6)
    #index相当于索引参考数据库中的索引，即行。生成DataFrame的第一种方式：通过np来生成
    df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=['A','B','C','D'])
    
    #方法1.1、通过数组创建
    arr = [0, 1, 2, 3, 4]
    df = pd.Series(arr) # 如果不指定索引，则默认从 0 开始

## 方式二：通过字典来生成 ##

#生成DataFrame的第二种方式：通过字典生成
    df2 =pd.DataFrame({'A' : 1.,
                       'B' : pd.Timestamp('20130102'),
                        'C' : pd.Series(1,index=list(range(4)),dtype='float32'),
                        'D' : np.array([3] * 4,dtype='int32'),
                        'E' : pd.Categorical(["test","train","test","train"]),
                        'F' : 'foo'})

# 2、pandas常用的属性及方法 #

df2.dtypes  
df.index：索引即行  
df.columns：列  
df.T：转置  
**df.describe()：描述df的一些常用的数学值即均值、方差等。基于列来统计的**  
df.sort\_index(axis=1, ascending=False)：按行排序  
df.sort\_values(by=‘B’)：按某一列进行排序

# 3、Pandas Select(数据选择) #

#df['A']与df.A选择列是等效的
    print(df['A'], df.A)#选中列名
    
    #选择行也是等效的。注意[0:3)是左闭(包含)右开（开除）
    print(df[0:3], df['20130102':'20130104'])#选中行号

**选择数据的四种方法：**  
**方法一：\#通过lab（列或行标签）来选择数据**

# select by label: loc
    print(df.loc[:,["A","B"]])
    #方法二
    print(df[["A", "C"]])

**方法二：\#通过位置来选择数据**

# select by position: iloc
    #前三行数据
    print(df.iloc[0:3])
    # 方法二
    #df.head(3)

**方法三：混合选择**

#结合前面两种选择数据的方法：即按标签和位置选择数据
    # mixed selection: ix
    #第1-3行、A和C列的数据
    print(df.ix[:3, ['A', 'C']])

**方法四：\#通过判断选择部分数据**

# Boolean indexing
    #选择df中A列表大于0的所有的行数据
    print(df[df["A"] > 0])

# 4、Pandas Set\_values设置值 #

设置值的操作直接把选择值的操作移植过来添加想要设置的值即可  
特别注意的一点是：添加数据的时候直接声明要添加的数据的标签和值即可

#添加数据
    df['F'] = np.nan

# 5、Pandas Nan处理缺失值 #

**pandas处理缺失值的三种方法：**

## 方法一：剔除缺失值所在的行或列 ##

#剔除df中有Nan的行(也可单独对某一列进行处理)
    print(df.dropna(axis=0, how='any')) 
    # how={'any', 'all'}：any有一个Nan即剔除；all全部为Nan即剔除。

## 方法二：填充Nan值 ##

#将Nan值填充为0
    print(df.fillna(value=0))

## 方法三：显示Nan值的位置，做进一步处理 ##

#显示出pd的A列中值是否为Nan；是为True否为False
    print(df["A"].isnull())
    #进一步处理
    #判断pd中是否有nan，有的话返回True，没有的话返回False。any：只要包含一个true则返回true
    print(np.any(pd.isnull(df))==True)

# 6、Pandas导入导出数据 #

读取、保存数据的方法：

# read from
    data = pd.read_csv('student.csv')
    # save to
    data.to_pickle('student.pickle')

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 1]

# 7、pandas合并操作（重点） #

## 1、concat ##

#将三个df进行合并，按行合并，ignore_index：忽略三个df之前的索引
    res = pd.concat([df1, df2, df3], axis=0, ignore_index=True)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 2]

#参考SQL的join操作：outer join
    res = pd.concat([df1, df2], axis=1, join='outer')
    
    #inner join：理解为将两个df的index作为连接条件进行join，所以只保留的2和3
    res = pd.concat([df1, df2], axis=1, join='inner')
    
    #默认向下追加数据
    res = df1.append(df2, ignore_index=True)

**concat：不需要指定对应的链接条件，按轴进行合并！  
merge：必须指定对应的链接条件即链接的字段！**

## 2、merge(更常用的操作) ##

**知道merge的核心思想也就是SQL的join操作**  
注意以下几点：  
1、注意连接条件：**一个或多个key；还可以通过对比index来连接**  
2、注意连接方式：**\[‘left’, ‘right’, ‘outer’, ‘inner’\]**

# merging two df by key/keys. (may be used in database)
    res = pd.merge(left, right, on='key')
    # consider two keys
    # default for how='inner'：即取共用的key
    # how = ['left', 'right', 'outer', 'inner']
    res = pd.merge(left, right, on=['key1', 'key2'], how='inner') 
    # indicator：将join的具体信息显示出来即怎么进行merge。
    res = pd.merge(df1, df2, on='col1', how='outer', indicator=True)
    #通过对比index来进行join操作
    # left_index and right_index
    res = pd.merge(left, right, left_index=True, right_index=True, how='outer')

# 其他Demo #

## 1、从某行读取数据 ##

（heard=None：列名为None;=0则代表列名为第0行数据），并筛选出其中的几列数据并自定义列名

all_user_data = pd.read_csv("tf_bank_cus.csv",header=None,skiprows=int(record_number_row),encoding="utf-8")
    all_user_data=all_user_data[[1,3,4,10,14,24]]
    all_user_data.columns=['applyno','customername','certid','paydate','partnercode','contactno']

## 2、判断某列是否含有某值 ##

pause_call_number_row_index = all_user_data[all_user_data['contactno'].isin([pause_call_number])]
    #df[df['列名'].isin([相应的值])]返回值为一整行的数据。通过index获得索引值

## 3、练手的Demo ##

**基本操作**
    
    import numpy as np
    
    data = {'animal': ['cat', 'cat', 'snake', 'dog', 'dog', 'cat', 'snake', 'cat', 'dog', 'dog'],
            'age': [2.5, 3, 0.5, np.nan, 5, 2, 4.5, np.nan, 7, 3],
            'visits': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],
            'priority': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}
    
    labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
    
    df = pd.DataFrame(data, index=labels)
    
    1、计算每个不同种类animal的age的平均数
    df.groupby('animal')['age'].mean()
    2、计算df中每个种类animal的数量
    df['animal'].value_counts()
    3、先按age降序排列，后按visits升序排列
    df.sort_values(by=['age', 'visits'], ascending=[False, True])
    4、将priority列中的yes, no替换为布尔值True, False
    df['priority'] = df['priority'].map({'yes': True, 'no': False})
    5、将animal列中的snake替换为python
    df['animal'] = df['animal'].replace('snake', 'python')
    
    6、对每种animal的每种不同数量visits，计算平均age，即，返回一个表格，行是aniaml种类，列是visits数量，表格值是行动物种类列访客数量的平均年龄
    df.pivot_table(index='animal', columns='visits', values='age', aggfunc='mean')
    
    **进阶操作**
    
    7、有一列整数列A的DatraFrame，删除数值重复的行
    #判断是否有重复项
    用duplicated()函数判断  
    #有重复项，则可以用drop_duplicates()移除重复项
    df1 = df.drop_duplicates(subset='A')
    print(df1)
    
    8、一个全数值DatraFrame，每个数字减去该行的平均数
    df = pd.DataFrame(np.random.random(size=(5, 3)))
    print(df)
    df1 = df.sub(df.mean(axis=1), axis=0)
    print(df1)
    
    9、一个有5列的DataFrame，求哪一列的和最小
    df = pd.DataFrame(np.random.random(size=(5, 5)), columns=list('abcde'))
    print(df)
    df.sum().idxmin()
    
    10、给定DataFrame，求A列每个值的前3大的B的和
    df = pd.DataFrame({'A': list('aaabbcaabcccbbc'), 
                       'B': [12,345,3,1,45,14,4,52,54,23,235,21,57,3,87]})
    print(df)
    df1 = df.groupby('A')['B'].nlargest(3).sum(level=0)
    print(df1)
    
    11、给定DataFrame，有列A, B，A的值在1-100（含），对A列每10步长，求对应的B的和
    df = pd.DataFrame({'A': [1,2,11,11,33,34,35,40,79,99], 
                       'B': [1,2,11,11,33,34,35,40,79,99]})
    print(df)
    df1 = df.groupby(pd.cut(df['A'], np.arange(0, 101, 10)))['B'].sum()
    print(df1)
    
    12、给定DataFrame，计算每个元素至左边最近的0（或者至开头）的距离，生成新列y
    df = pd.DataFrame({'X': [7, 2, 0, 3, 4, 2, 5, 0, 3, 4]})
    
    izero = np.r_[-1, (df['X'] == 0).to_numpy().nonzero()[0]] # 标记0的位置
    idx = np.arange(len(df))
    df['Y'] = idx - izero[np.searchsorted(izero - 1, idx) - 1]
    print(df)
    
    # 方法二
    # x = (df['X'] != 0).cumsum()
    # y = x != x.shift()
    # df['Y'] = y.groupby((y != y.shift()).cumsum()).cumsum()
    
    # 方法三
    # df['Y'] = df.groupby((df['X'] == 0).cumsum()).cumcount()
    #first_zero_idx = (df['X'] == 0).idxmax()
    # df['Y'].iloc[0:first_zero_idx] += 1
    
    13、一个全数值的DataFrame，返回最大3值的坐标
    df = pd.DataFrame(np.random.random(size=(5, 3)))
    print(df)
    df.unstack().sort_values()[-3:].index.tolist()
    
    14、给定DataFrame，将负值代替为同组的平均值
    df = pd.DataFrame({'grps': list('aaabbcaabcccbbc'), 
                       'vals': [-12,345,3,1,45,14,4,-52,54,23,-235,21,57,3,87]})
    print(df)
    
    def replace(group):
        mask = group<0
        group[mask] = group[~mask].mean()
        return group
    
    df['vals'] = df.groupby(['grps'])['vals'].transform(replace)
    print(df)
    
    15、计算3位滑动窗口的平均值，忽略NAN
    df = pd.DataFrame({'group': list('aabbabbbabab'),
                        'value': [1, 2, 3, np.nan, 2, 3, np.nan, 1, 7, 3, np.nan, 8]})
    print(df)
    
    g1 = df.groupby(['group'])['value']
    g2 = df.fillna(0).groupby(['group'])['value'] 
    
    s = g2.rolling(3, min_periods=1).sum() / g1.rolling(3, min_periods=1).count()
    
    s.reset_index(level=0, drop=True).sort_index()
    
    
    **Series 和 Datetime索引**
    
    16、创建Series s，将2015所有工作日作为随机值的索引
    dti = pd.date_range(start='2015-01-01', end='2015-12-31', freq='B') 
    s = pd.Series(np.random.rand(len(dti)), index=dti)
    s.head(10)
    
    17、所有礼拜三的值求和
    s[s.index.weekday == 2].sum() 
    18、求每个自然月的平均数
    s.resample('M').mean()
    19、每连续4个月为一组，求最大值所在的日期
    s.groupby(pd.Grouper(freq='4M')).idxmax()
    20、创建2015-2016每月第三个星期四的序列
    pd.date_range('2015-01-01', '2016-12-31', freq='WOM-3THU')
    
    **数据清洗**
    
    df = pd.DataFrame({'From_To': ['LoNDon_paris', 'MAdrid_miLAN', 'londON_StockhOlm', 
                                   'Budapest_PaRis', 'Brussels_londOn'],
                  'FlightNumber': [10045, np.nan, 10065, np.nan, 10085],
                  'RecentDelays': [[23, 47], [], [24, 43, 87], [13], [67, 32]],
                       'Airline': ['KLM(!)', '<Air France> (12)', '(British Airways. )', 
                                   '12. Air France', '"Swiss Air"']})
    df
    21、FlightNumber列中有些值缺失了，他们本来应该是每一行增加10，填充缺失的数值，并且令数据类型为整数
    df['FlightNumber'] = df['FlightNumber'].interpolate().astype(int)
    df
    22、将From_To列从_分开，分成From, To两列，并删除原始列
    temp = df.From_To.str.split('_', expand=True)
    temp.columns = ['From', 'To']
    df = df.join(temp)
    df = df.drop('From_To', axis=1)
    df
    23、将From, To大小写统一
    df['From'] = df['From'].str.capitalize()
    df['To'] = df['To'].str.capitalize()
    df
    24、Airline列，有一些多余的标点符号，需要提取出正确的航司名称。举例：'(British Airways. )' 应该改为 'British Airways'.
    df['Airline'] = df['Airline'].str.extract('([a-zA-Z\s]+)', expand=False).str.strip()
    df
    25、Airline列，数据被以列表的形式录入，但是我们希望每个数字被录入成单独一列，delay_1, delay_2, …没有的用NAN替代。
    delays = df['RecentDelays'].apply(pd.Series)
    delays.columns = ['delay_{}'.format(n) for n in range(1, len(delays.columns)+1)]
    df = df.drop('RecentDelays', axis=1).join(delays)
    
    df
    
    **层次化索引**
    
    26、用 letters = ['A', 'B', 'C'] 和 numbers = list(range(10))的组合作为系列随机值的层次化索引
    letters = ['A', 'B', 'C']
    numbers = list(range(4))
    
    mi = pd.MultiIndex.from_product([letters, numbers])
    s = pd.Series(np.random.rand(12), index=mi)
    s
    27、检查s是否是字典顺序排序的
    s.index.is_lexsorted()
    # 方法二
    # s.index.lexsort_depth == s.index.nlevels
    28、选择二级索引为1, 3的行
    s.loc[:, [1, 3]]
    29、对s进行切片操作，取一级索引从头至B，二级索引从2开始到最后
    s.loc[pd.IndexSlice[:'B', 2:]]
    # 方法二
    # s.loc[slice(None, 'B'), slice(2, None)]
    30、计算每个一级索引的和（A, B, C每一个的和）
    s.sum(level=0)
    #方法二
    #s.unstack().sum(axis=0)
    31、交换索引等级，新的Series是字典顺序吗？不是的话请排序
    new_s = s.swaplevel(0, 1)
    print(new_s)
    print(new_s.index.is_lexsorted())
    new_s = new_s.sort_index()
    print(new_s)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70]: /images/20220114/e88a537e72c64e98a5cc635e6b6c3094.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 1]: /images/20220114/dd0f1af6f892464d97a3770452db5591.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2NjMzNDA1_size_16_color_FFFFFF_t_70 2]: /images/20220114/9fc93c0b12b94efdb1abc65d529a6513.png