蚂蚁学Python

使用场景：

批量合并相同格式的Excel、给DataFrame添加行、给DataFrame添加列

一句话说明concat语法：

• 使用某种合并方式(inner/outer)
• 沿着某个轴向(axis=0/1)
• 把多个Pandas对象(DataFrame/Series)合并成一个。

concat语法：pandas.concat(objs, axis=0, join=’outer’, ignore_index=False)

• objs：一个列表，内容可以是DataFrame或者Series，可以混合
• axis：默认是0代表按行合并，如果等于1代表按列合并
• join：合并的时候索引的对齐方式，默认是outer join，也可以是inner join
• ignore_index：是否忽略掉原来的数据索引

append语法：DataFrame.append(other, ignore_index=False)

append只有按行合并，没有按列合并，相当于concat按行的简写形式
* other：单个dataframe、series、dict，或者列表
* ignore_index：是否忽略掉原来的数据索引

参考文档：

• pandas.concat的api文档：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.concat.html
• pandas.concat的教程：https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html
• pandas.append的api文档：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.append.html

import pandas as pd

import warnings
warnings.filterwarnings('ignore')

一、使用pandas.concat合并数据

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3'],
                    'E': ['E0', 'E1', 'E2', 'E3']
                   })
df1

df2 = pd.DataFrame({ 'A': ['A4', 'A5', 'A6', 'A7'],
                     'B': ['B4', 'B5', 'B6', 'B7'],
                     'C': ['C4', 'C5', 'C6', 'C7'],
                     'D': ['D4', 'D5', 'D6', 'D7'],
                     'F': ['F4', 'F5', 'F6', 'F7']
                   })
df2

1、默认的concat，参数为axis=0、join=outer、ignore_index=False

pd.concat([df1,df2])

2、使用ignore_index=True可以忽略原来的索引

pd.concat([df1,df2], ignore_index=True)

3、使用join=inner过滤掉不匹配的列

pd.concat([df1,df2], ignore_index=True, join="inner")

4、使用axis=1相当于添加新列

df1

A：添加一列Series

s1 = pd.Series(list(range(4)), name="F")
pd.concat([df1,s1], axis=1)

B：添加多列Series

s2 = df1.apply(lambda x:x["A"]+"_GG", axis=1)

s2

0    A0_GG
1    A1_GG
2    A2_GG
3    A3_GG
dtype: object

s2.name="G"

pd.concat([df1,s1,s2], axis=1)

# 列表可以只有Series
pd.concat([s1,s2], axis=1)

# 列表是可以混合顺序的
pd.concat([s1,df1,s2], axis=1)

二、使用DataFrame.append按行合并数据

df1 = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
df1

df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
df2

1、给1个dataframe添加另一个dataframe

df1.append(df2)

2、忽略原来的索引ignore_index=True

df1.append(df2, ignore_index=True)

3、可以一行一行的给DataFrame添加数据

# 一个空的df
df = pd.DataFrame(columns=['A'])
df

A：低性能版本

for i in range(5):
    # 注意这里每次都在复制
    df = df.append({'A': i}, ignore_index=True)
df

B：性能好的版本

# 第一个入参是一个列表，避免了多次复制
pd.concat(
    [pd.DataFrame([i], columns=['A']) for i in range(5)],
    ignore_index=True
)

把数据存储于普通的column列也能用于数据查询，那使用index有什么好处？

index的用途总结：
1. 更方便的数据查询；
2. 使用index可以获得性能提升；
3. 自动的数据对齐功能；
4. 更多更强大的数据结构支持；

import pandas as pd

df = pd.read_csv("./datas/ml-latest-small/ratings.csv")

df.head()

df.count()

userId       100836
movieId      100836
rating       100836
timestamp    100836
dtype: int64

1、使用index查询数据

# drop==False，让索引列还保持在column
df.set_index("userId", inplace=True, drop=False)

df.head()

df.index

Int64Index([  1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
            ...
            610, 610, 610, 610, 610, 610, 610, 610, 610, 610],
           dtype='int64', name='userId', length=100836)

# 使用index的查询方法
df.loc[500].head(5)

# 使用column的condition查询方法
df.loc[df["userId"] == 500].head()

2. 使用index会提升查询性能

• 如果index是唯一的，Pandas会使用哈希表优化，查询性能为O(1);
• 如果index不是唯一的，但是有序，Pandas会使用二分查找算法，查询性能为O(logN);
• 如果index是完全随机的，那么每次查询都要扫描全表，查询性能为O(N);

实验1：完全随机的顺序查询

# 将数据随机打散
from sklearn.utils import shuffle
df_shuffle = shuffle(df)

df_shuffle.head()

# 索引是否是递增的
df_shuffle.index.is_monotonic_increasing

False

df_shuffle.index.is_unique

False

# 计时，查询id==500数据性能
%timeit df_shuffle.loc[500]

376 µs ± 52.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

实验2：将index排序后的查询

df_sorted = df_shuffle.sort_index()

df_sorted.head()

# 索引是否是递增的
df_sorted.index.is_monotonic_increasing

True

df_sorted.index.is_unique

False

%timeit df_sorted.loc[500]

203 µs ± 20.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

3. 使用index能自动对齐数据

包括series和dataframe

s1 = pd.Series([1,2,3], index=list("abc"))

s1

a    1
b    2
c    3
dtype: int64

s2 = pd.Series([2,3,4], index=list("bcd"))

s2

b    2
c    3
d    4
dtype: int64

s1+s2

a    NaN
b    4.0
c    6.0
d    NaN
dtype: float64

4. 使用index更多更强大的数据结构支持

很多强大的索引数据结构
* CategoricalIndex，基于分类数据的Index，提升性能；
* MultiIndex，多维索引，用于groupby多维聚合后结果等；
* DatetimeIndex，时间类型索引，强大的日期和时间的方法支持；

axis参数非常的让人困惑难以理解，本视频我会用形象化的方式讲解一下这个参数，核心要诀就是axis那个轴会消失！

• axis=0或者”index”：
  • 如果是单行操作，就指的是某一行
  • 如果是聚合操作，指的是跨行cross rows
• axis=1或者”columns”：
  • 如果是单列操作，就指的是某一列
  • 如果是聚合操作，指的是跨列cross columns

按哪个axis，就是这个axis要动起来(类似被for遍历)，其它的axis保持不动

import pandas as pd
import numpy as np

df = pd.DataFrame(
    np.arange(12).reshape(3,4),
    columns=['A', 'B', 'C', 'D']
)

df

1、单列drop，就是删除某一列

# 代表的就是删除某列
df.drop("A", axis=1)

2、单行drop，就是删除某一行

df

# 代表的就是删除某行
df.drop(1, axis=0)

3、按axis=0/index执行mean聚合操作

反直觉：输出的不是每行的结果，而是每列的结果

df

# axis=0 or axis=index
df.mean(axis=0)

A    4.0
B    5.0
C    6.0
D    7.0
dtype: float64

指定了按哪个axis，就是这个axis要动起来(类似被for遍历)，其它的axis保持不动

4、按axis=1/columns执行mean聚合操作

反直觉：输出的不是每行的结果，而是每列的结果

df

# axis=1 or axis=columns
df.mean(axis=1)

0    1.5
1    5.5
2    9.5
dtype: float64

指定了按哪个axis，就是这个axis要动起来(类似被for遍历)，其它的axis保持不动

5、再次举例，加深理解

def get_sum_value(x):
    return x["A"] + x["B"] + x["C"] + x["D"]

df["sum_value"] = df.apply(get_sum_value, axis=1)

df

指定了按哪个axis，就是这个axis要动起来(类似被for遍历)，其它的axis保持不动

本文地址：http://www.crazyant.net/2546.html
转载请注明来源

前面我们已经使用了字符串的处理函数：
df[“bWendu”].str.replace(“℃”, “”).astype(‘int32’)

Pandas的字符串处理：
1. 使用方法：先获取Series的str属性，然后在属性上调用函数；
2. 只能在字符串列上使用，不能数字列上使用；
3. Dataframe上没有str属性和处理方法
4. Series.str并不是Python原生字符串，而是自己的一套方法，不过大部分和原生str很相似；

Series.str字符串方法列表参考文档:
https://pandas.pydata.org/pandas-docs/stable/reference/series.html#string-handling

本节演示内容：
1. 获取Series的str属性，然后使用各种字符串处理函数
2. 使用str的startswith、contains等bool类Series可以做条件查询
3. 需要多次str处理的链式操作
4. 使用正则表达式的处理

0、读取北京2018年天气数据

import pandas as pd

fpath = "./datas/beijing_tianqi/beijing_tianqi_2018.csv"
df = pd.read_csv(fpath)

df.head()

df.dtypes

ymd          object
bWendu       object
yWendu       object
tianqi       object
fengxiang    object
fengli       object
aqi           int64
aqiInfo      object
aqiLevel      int64
dtype: object

1、获取Series的str属性，使用各种字符串处理函数

df["bWendu"].str

<pandas.core.strings.StringMethods at 0x1af21871808>

# 字符串替换函数
df["bWendu"].str.replace("℃", "")

0       3
1       2
2       2
3       0
4       3
       ..
360    -5
361    -3
362    -3
363    -2
364    -2
Name: bWendu, Length: 365, dtype: object

# 判断是不是数字
df["bWendu"].str.isnumeric()

0      False
1      False
2      False
3      False
4      False
       ...  
360    False
361    False
362    False
363    False
364    False
Name: bWendu, Length: 365, dtype: bool

df["aqi"].str.len()

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-8-12cdcbdb6f81> in <module>
----> 1 df["aqi"].str.len()


d:\appdata\python37\lib\site-packages\pandas\core\generic.py in __getattr__(self, name)
   5173             or name in self._accessors
   5174         ):
-> 5175             return object.__getattribute__(self, name)
   5176         else:
   5177             if self._info_axis._can_hold_identifiers_and_holds_name(name):


d:\appdata\python37\lib\site-packages\pandas\core\accessor.py in __get__(self, obj, cls)
    173             # we're accessing the attribute of the class, i.e., Dataset.geo
    174             return self._accessor
--> 175         accessor_obj = self._accessor(obj)
    176         # Replace the property with the accessor object. Inspired by:
    177         # http://www.pydanny.com/cached-property.html


d:\appdata\python37\lib\site-packages\pandas\core\strings.py in __init__(self, data)
   1915 
   1916     def __init__(self, data):
-> 1917         self._inferred_dtype = self._validate(data)
   1918         self._is_categorical = is_categorical_dtype(data)
   1919 


d:\appdata\python37\lib\site-packages\pandas\core\strings.py in _validate(data)
   1965 
   1966         if inferred_dtype not in allowed_types:
-> 1967             raise AttributeError("Can only use .str accessor with string " "values!")
   1968         return inferred_dtype
   1969 


AttributeError: Can only use .str accessor with string values!

2、使用str的startswith、contains等得到bool的Series可以做条件查询

condition = df["ymd"].str.startswith("2018-03")

condition

0      False
1      False
2      False
3      False
4      False
       ...  
360    False
361    False
362    False
363    False
364    False
Name: ymd, Length: 365, dtype: bool

df[condition].head()

3、需要多次str处理的链式操作

怎样提取201803这样的数字月份？
1、先将日期2018-03-31替换成20180331的形式
2、提取月份字符串201803

df["ymd"].str.replace("-", "")

0      20180101
1      20180102
2      20180103
3      20180104
4      20180105
         ...   
360    20181227
361    20181228
362    20181229
363    20181230
364    20181231
Name: ymd, Length: 365, dtype: object

# 每次调用函数，都返回一个新Series
df["ymd"].str.replace("-", "").slice(0, 6)

---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-13-ae278fb12255> in <module>
      1 # 每次调用函数，都返回一个新Series
----> 2 df["ymd"].str.replace("-", "").slice(0, 6)


d:\appdata\python37\lib\site-packages\pandas\core\generic.py in __getattr__(self, name)
   5177             if self._info_axis._can_hold_identifiers_and_holds_name(name):
   5178                 return self[name]
-> 5179             return object.__getattribute__(self, name)
   5180 
   5181     def __setattr__(self, name, value):


AttributeError: 'Series' object has no attribute 'slice'

df["ymd"].str.replace("-", "").str.slice(0, 6)

0      201801
1      201801
2      201801
3      201801
4      201801
        ...  
360    201812
361    201812
362    201812
363    201812
364    201812
Name: ymd, Length: 365, dtype: object

# slice就是切片语法，可以直接用
df["ymd"].str.replace("-", "").str[0:6]

0      201801
1      201801
2      201801
3      201801
4      201801
        ...  
360    201812
361    201812
362    201812
363    201812
364    201812
Name: ymd, Length: 365, dtype: object

4. 使用正则表达式的处理

# 添加新列
def get_nianyueri(x):
    year,month,day = x["ymd"].split("-")
    return f"{year}年{month}月{day}日"
df["中文日期"] = df.apply(get_nianyueri, axis=1)

df["中文日期"]

0      2018年01月01日
1      2018年01月02日
2      2018年01月03日
3      2018年01月04日
4      2018年01月05日
          ...     
360    2018年12月27日
361    2018年12月28日
362    2018年12月29日
363    2018年12月30日
364    2018年12月31日
Name: 中文日期, Length: 365, dtype: object

问题：怎样将“2018年12月31日”中的年、月、日三个中文字符去除？

# 方法1：链式replace
df["中文日期"].str.replace("年", "").str.replace("月","").str.replace("日", "")

0      20180101
1      20180102
2      20180103
3      20180104
4      20180105
         ...   
360    20181227
361    20181228
362    20181229
363    20181230
364    20181231
Name: 中文日期, Length: 365, dtype: object

Series.str默认就开启了正则表达式模式

# 方法2：正则表达式替换
df["中文日期"].str.replace("[年月日]", "")

0      20180101
1      20180102
2      20180103
3      20180104
4      20180105
         ...   
360    20181227
361    20181228
362    20181229
363    20181230
364    20181231
Name: 中文日期, Length: 365, dtype: object

Series的排序：
Series.sort_values(ascending=True, inplace=False)
参数说明：
* ascending：默认为True升序排序，为False降序排序
* inplace：是否修改原始Series

DataFrame的排序：
DataFrame.sort_values(by, ascending=True, inplace=False)
参数说明：
* by：字符串或者List<字符串>，单列排序或者多列排序
* ascending：bool或者List，升序还是降序，如果是list对应by的多列
* inplace：是否修改原始DataFrame

import pandas as pd

0、读取数据

fpath = "./datas/beijing_tianqi/beijing_tianqi_2018.csv"
df = pd.read_csv(fpath)

# 替换掉温度的后缀℃
df.loc[:, "bWendu"] = df["bWendu"].str.replace("℃", "").astype('int32')
df.loc[:, "yWendu"] = df["yWendu"].str.replace("℃", "").astype('int32')

df.head()

1、Series的排序

df["aqi"].sort_values()

271     21
281     21
249     22
272     22
301     22
      ... 
317    266
71     287
91     287
72     293
86     387
Name: aqi, Length: 365, dtype: int64

df["aqi"].sort_values(ascending=False)

86     387
72     293
91     287
71     287
317    266
      ... 
301     22
272     22
249     22
281     21
271     21
Name: aqi, Length: 365, dtype: int64

df["tianqi"].sort_values()

225     中雨~小雨
230     中雨~小雨
197    中雨~雷阵雨
196    中雨~雷阵雨
112        多云
        ...  
191    雷阵雨~大雨
219     雷阵雨~阴
335      雾~多云
353         霾
348         霾
Name: tianqi, Length: 365, dtype: object

2、DataFrame的排序

2.1 单列排序

df.sort_values(by="aqi")

df.sort_values(by="aqi", ascending=False)

2.2 多列排序

# 按空气质量等级、最高温度排序，默认升序
df.sort_values(by=["aqiLevel", "bWendu"])

# 两个字段都是降序
df.sort_values(by=["aqiLevel", "bWendu"], ascending=False)

# 分别指定升序和降序
df.sort_values(by=["aqiLevel", "bWendu"], ascending=[True, False])

本文章有配套视频讲解，关注公众号：蚂蚁学Python，查看视频、获取源码

Pandas使用这些函数处理缺失值：
* isnull和notnull：检测是否是空值，可用于df和series
* dropna：丢弃、删除缺失值
– axis : 删除行还是列，{0 or ‘index’, 1 or ‘columns’}, default 0
– how : 如果等于any则任何值为空都删除，如果等于all则所有值都为空才删除
– inplace : 如果为True则修改当前df，否则返回新的df
* fillna：填充空值
– value：用于填充的值，可以是单个值，或者字典（key是列名，value是值）
– method : 等于ffill使用前一个不为空的值填充forword fill；等于bfill使用后一个不为空的值填充backword fill
– axis : 按行还是列填充，{0 or ‘index’, 1 or ‘columns’}
– inplace : 如果为True则修改当前df，否则返回新的df

import pandas as pd

实例：特殊Excel的读取、清洗、处理

步骤1：读取excel的时候，忽略前几个空行

studf = pd.read_excel("./datas/student_excel/student_excel.xlsx", skiprows=2)

studf

步骤2：检测空值

studf.isnull()

studf["分数"].isnull()

0     False
1     False
2     False
3      True
4     False
5      True
6     False
7      True
8     False
9     False
10    False
Name: 分数, dtype: bool

studf["分数"].notnull()

0      True
1      True
2      True
3     False
4      True
5     False
6      True
7     False
8      True
9      True
10     True
Name: 分数, dtype: bool

# 筛选没有空分数的所有行
studf.loc[studf["分数"].notnull(), :]

步骤3：删除掉全是空值的列

studf.dropna(axis="columns", how='all', inplace=True)

studf

步骤4：删除掉全是空值的行

studf.dropna(axis="index", how='all', inplace=True)

studf

步骤5：将分数列为空的填充为0分

studf.fillna({"分数":0})

# 等同于
studf.loc[:, '分数'] = studf['分数'].fillna(0)

studf

步骤6：将姓名的缺失值填充

使用前面的有效值填充，用ffill：forward fill

studf.loc[:, '姓名'] = studf['姓名'].fillna(method="ffill")

studf

步骤7：将清洗好的excel保存

studf.to_excel("./datas/student_excel/student_excel_clean.xlsx", index=False)

本文章有配套视频讲解，关注公众号：蚂蚁学Python获取