Pandas之旅(四) : 可能是社区内最实用的Pandas技巧

摘要：不为人知的七大实用技巧大家好，我今天勤快地回来了，这一期主要是和大家分享一些的实用技巧，会在日常生活中大大提升效率，希望可以帮助到大家还是老样子，先给大家奉上这一期的章节目录自定义选项，设置实用中模块构建测试数据巧用访问器合并其他列拼接使用

大家好，我今天勤快地回来了，这一期主要是和大家分享一些pandas的实用技巧，会在日常生活中大大提升效率，希望可以帮助到大家,还是老样子，先给大家奉上这一期的章节目录:

自定义pandas选项，设置

实用pandas中testing模块构建测试数据

巧用accessor访问器

合并其他列拼接DatetimeIndex

使用分类数据（Categorical Data）节省时间和空间

利用Mapping巧妙实现映射

压缩pandas对象

源码及GitHub地址

好啦，话不多说，让我们一个个看吧

首先，大家可能不知道，pandas里面有一个方法pd.set_option()，利用它我们可以改变一些pandas中默认的核心设置，
从而适应我们自身的需要，开始前还是老样子，让我们先导入numpy和pandas包

import numpy as np
import pandas as pd
f"Using {pd.__name__}, Version {pd.__version__}"

"Using pandas, Version 0.23.0"

现在让我们编写一个start方法来实现自定义pandas设置

def start():
    options = {
        "display": {
            "max_columns": None,
            "max_colwidth": 25,
            "expand_frame_repr": False,  # Don"t wrap to multiple pages
            "max_rows": 14,
            "max_seq_items": 50,         # Max length of printed sequence
            "precision": 4,
            "show_dimensions": False
        },
        "mode": {
            "chained_assignment": None   # Controls SettingWithCopyWarning
        }
    }

    for category, option in options.items():
        for op, value in option.items():
            pd.set_option(f"{category}.{op}", value)  # Python 3.6+

if __name__ == "__main__":
    start()
    del start  # Clean up namespace in the interpreter

大家可以发现，我们在方法的最后调用了pandas的set_option方法，直接利用我们自定义的参数替代了原有的pandas参数，现在让我们测试一下：

pd.get_option("display.max_rows")
Out:14

可以发现max_rows 已经被替换成了我们设置的14，现在用一个真实的例子，我们利用一组公开的鲍鱼各项指标的数据来实验，数据源来自机器学习平台的公开数据

url = ("https://archive.ics.uci.edu/ml/"
       "machine-learning-databases/abalone/abalone.data")
cols = ["sex", "length", "diam", "height", "weight", "rings"]
abalone = pd.read_csv(url, usecols=[0, 1, 2, 3, 4, 8], names=cols)
abalone

我们可以看到，数据截断为14行，保留了小数点后4位小数作为精度，和我们刚刚设置的precision=4是一样的

通过pandas.util.testing提供的方法，我们可以很容易的通过几行代码就构建出一个简单的测试数据类型，比如我们现在构建一个DataTime类型的数据，
时间间隔为月：

import pandas.util.testing as tm
tm.N, tm.K = 15, 3         # 规定行和列

import numpy as np
np.random.seed(444)

tm.makeTimeDataFrame(freq="M").head() # 设置时间间隔为月
# tm.makeTimeDataFrame(freq="D").head()  设置时间间隔为天

瞎生成一组乱七八糟的数据：

tm.makeDataFrame().head()

关于可以随机生成的数据类型, 一共大概有30多种，大家如果感兴趣可以多试试：

[i for i in dir(tm) if i.startswith("make")]

["makeBoolIndex",
 "makeCategoricalIndex",
 "makeCustomDataframe",
 "makeCustomIndex",
 "makeDataFrame",
 "makeDateIndex",
 "makeFloatIndex",
 "makeFloatSeries",
 "makeIntIndex",
 "makeIntervalIndex",
 "makeMissingCustomDataframe",
 "makeMissingDataframe",
 "makeMixedDataFrame",
 "makeMultiIndex",
 "makeObjectSeries",
 "makePanel",
 "makePeriodFrame",
 "makePeriodIndex",
 "makePeriodPanel",
 "makePeriodSeries",
 "makeRangeIndex",
 "makeStringIndex",
 "makeStringSeries",
 "makeTimeDataFrame",
 "makeTimeSeries",
 "makeTimedeltaIndex",
 "makeUIntIndex",
 "makeUnicodeIndex"]

这样我们如果有测试的需求，会很容易地构建相对应的假数据来测试。

accessor（访问器） 具体就是类似getter和setter，当然，Python里面不提倡存在setter和getter方法，但是这样可以便于大家理解，pandas Series类型有3类accessor：

pd.Series._accessors

Out:{"cat", "dt", "str"}

.cat用于分类数据，

.str用于字符串（对象）数据，

.dt用于类似日期时间的数据。

让我们从.str开始看：假设现在我们有一些原始的城市/州/ 邮编数据作为Dataframe的一个字段：

addr = pd.Series([
    "Washington, D.C. 20003",
    "Brooklyn, NY 11211-1755",
    "Omaha, NE 68154",
    "Pittsburgh, PA 15211"
])

addr.str.upper()  # 因为字符串方法是矢量化的，这意味着它们在没有显式for循环的情况下对整个数组进行操作

0     WASHINGTON, D.C. 20003
1    BROOKLYN, NY 11211-1755
2            OMAHA, NE 68154
3       PITTSBURGH, PA 15211
dtype: object

addr.str.count(r"d")  # 查看邮编有几位

0    5
1    9
2    5
3    5
dtype: int64

如果我们想把每一行分成城市，州，邮编分开，可以用正则；

regex = (r"(?P[A-Za-z ]+), "      # One or more letters
         r"(?P[A-Z]{2}) "      # 2 capital letters
         r"(?Pd{5}(?:-d{4})?)")  # Optional 4-digit extension

addr.str.replace(".", "").str.extract(regex)

第二个访问器.dt用于类似日期时间的数据。它其实属于Pandas的DatetimeIndex，如果在Series上调用，它首先转换为DatetimeIndex

daterng = pd.Series(pd.date_range("2018", periods=9, freq="Q"))  # 时间间隔为季度
daterng

0   2018-03-31
1   2018-06-30
2   2018-09-30
3   2018-12-31
4   2019-03-31
5   2019-06-30
6   2019-09-30
7   2019-12-31
8   2020-03-31
dtype: datetime64[ns]

daterng.dt.day_name()

0    Saturday
1    Saturday
2      Sunday
3      Monday
4      Sunday
5      Sunday
6      Monday
7     Tuesday
8     Tuesday
dtype: object

daterng[daterng.dt.quarter > 2]  # 查看2019年第3季度和第4季度

2   2018-09-30
3   2018-12-31
6   2019-09-30
7   2019-12-31
dtype: datetime64[ns]

daterng[daterng.dt.is_year_end]  #查看年末的一天

3   2018-12-31
7   2019-12-31
dtype: datetime64[ns]

最后有关.cat访问器我们会在第5个技巧中提到

现在先让我们构建一个包含时间类型数据的Dataframe：

from itertools import product
datecols = ["year", "month", "day"]

df = pd.DataFrame(list(product([2017, 2016], [1, 2], [1, 2, 3])),
                  columns=datecols)
df["data"] = np.random.randn(len(df))
df

我们可以发现year，month，day是分开的三列，我们如果想要把它们合并为完整的时间并作为df的索引，可以这么做:

df.index = pd.to_datetime(df[datecols])
df.head()

我们可以扔掉没用的列并把这个df压缩为Series：

df = df.drop(datecols, axis=1).squeeze()
df.head()

2017-01-01   -0.0767
2017-01-02   -1.2798
2017-01-03    0.4032
2017-02-01    1.2377
2017-02-02   -0.2060
Name: data, dtype: float64

type(df)

pandas.core.series.Series

df.index.dtype_str

"datetime64[ns]"

刚刚我们在第3个技巧的时候提到了访问器，现在让我们来看最后一个.cat

pandas中Categorical这个数据类型非常强大，通过类型转换可以让我们节省变量在内存占用的空间，提高运算速度，不过有关具体的pandas加速实战，我会在
下一期说，现在让我们来看一个小栗子：

colors = pd.Series([
    "periwinkle",
    "mint green",
    "burnt orange",
    "periwinkle",
    "burnt orange",
    "rose",
    "rose",
    "mint green",
    "rose",
    "navy"
])

import sys
colors.apply(sys.getsizeof)

0    59
1    59
2    61
3    59
4    61
5    53
6    53
7    59
8    53
9    53
dtype: int64

我们首先创建了一个Series，填充了各种颜色，接着查看了每个地址对应的颜色所占内存的大小

注意这里我们使用sys.getsizeof()来获取占内存大小，但是实际上空格也是占内存的，sys.getsizeof("")返回的是49bytes

接下来我们想把每种颜色用占内存更少的数字来表示（机器学习种非常常见），这样可以减少占用的内存，首先让我们创建一个mapper字典，给每一种颜色指定
一个数字

mapper = {v: k for k, v in enumerate(colors.unique())}
mapper

{"periwinkle": 0, "mint green": 1, "burnt orange": 2, "rose": 3, "navy": 4}

接着我们把刚才的colors数组转化为int类型：

# 也可以通过 pd.factorize(colors)[0] 实现
as_int = colors.map(mapper)
as_int

0    0
1    1
2    2
3    0
4    2
5    3
6    3
7    1
8    3
9    4
dtype: int64

再让我们看一下占用的内存：

as_int.apply(sys.getsizeof)

0    24
1    28
2    28
3    24
4    28
5    28
6    28
7    28
8    28
9    28
dtype: int64

现在可以观察到我们的内存占用的空间几乎是之前的一半，其实，刚刚我们做的正是模拟Categorical Data的转化原理。现在让我们直接调用一下：

colors.memory_usage(index=False, deep=True)

Out:650

colors.astype("category").memory_usage(index=False, deep=True)

Out: 495

大家可能感觉节省的空间并不是非常大对不对？ 因为目前我们这个数据根本不是真实场景，我们仅仅把数据容量增加10倍，现在再让我们看看效果：

manycolors = colors.repeat(10)
len(manycolors) / manycolors.nunique()  # Much greater than 2.0x 

Out:20.0

f"Not using category : { manycolors.memory_usage(index=False, deep=True)}"

"Not using category : 6500"

f"Using category : { manycolors.astype("category").memory_usage(index=False, deep=True)}"

"Using category : 585"

这回内存的占用量差距明显就出来了，现在让我们用.cat来简化一下刚刚的工作：

new_colors = colors.astype("category")
new_colors

0      periwinkle
1      mint green
2    burnt orange
3      periwinkle
4    burnt orange
5            rose
6            rose
7      mint green
8            rose
9            navy
dtype: category
Categories (5, object): [burnt orange, mint green, navy, periwinkle, rose]

new_colors.cat.categories   # 可以使用.cat.categories查看代表的颜色

Index(["burnt orange", "mint green", "navy", "periwinkle", "rose"], dtype="object")

现在让我们查看把颜色代表的数字：

new_colors.cat.codes

0    3
1    1
2    0
3    3
4    0
5    4
6    4
7    1
8    4
9    2
dtype: int8

我们如果不满意顺序也可以从新排序：

new_colors.cat.reorder_categories(mapper).cat.codes

0    0
1    1
2    2
3    0
4    2
5    3
6    3
7    1
8    3
9    4
dtype: int8

有关cat其他的方法，我们还是可以通过遍历dir来查看：

[i for i in dir(new_colors.cat) if not i.startswith("_")]

["add_categories",
 "as_ordered",
 "as_unordered",
 "categories",
 "codes",
 "ordered",
 "remove_categories",
 "remove_unused_categories",
 "rename_categories",
 "reorder_categories",
 "set_categories"]

Categorical 数据通常不太灵活，比如我们不能直接在new_colors上新增一个新的颜色，要首先通过
.add_categories来添加

ccolors.iloc[5] = "a new color"

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

NameError                                 Traceback (most recent call last)

 in ()
----> 1 ccolors.iloc[5] = "a new color"


NameError: name "ccolors" is not defined

new_colors = new_colors.cat.add_categories(["a new color"])

new_colors.iloc[5] = "a new color"  # 不会报错

new_colors.values  # 成功添加

假设现在我们有存贮国家的一组数据，和一组用来映射国家所对应的大洲的数据：

countries = pd.Series([
    "United States",
    "Canada",
    "Mexico",
    "Belgium",
    "United Kingdom",
    "Thailand"
])

groups = {
    "North America": ("United States", "Canada", "Mexico", "Greenland"),
    "Europe": ("France", "Germany", "United Kingdom", "Belgium")
}

我们可以通过下面的方法来实现简单的映射：

from typing import Any

def membership_map(s: pd.Series, groups: dict,
                   fillvalue: Any=-1) -> pd.Series:
    # Reverse & expand the dictionary key-value pairs
    groups = {x: k for k, v in groups.items() for x in v}
    return s.map(groups).fillna(fillvalue)

 membership_map(countries, groups, fillvalue="other")

很简单对不对，现在让我们看一下最关键的一行代码，groups = {x: k for k, v in groups.items() for x in v}，这个是我之前提到过的字典推导式：

test = dict(enumerate(("ab", "cd", "xyz")))
{x: k for k, v in test.items() for x in v}

如果你的pandas版本大于0.21.0，那么都可以直接把pandas用压缩形式写入，常见的类型有gzip, bz2, zip，这里我们直接用刚才鲍鱼的数据集：

abalone.to_json("df.json.gz", orient="records",lines=True, compression="gzip")  # 压缩为gz类型
abalone.to_json("df.json", orient="records", lines=True)                        #压缩为json

import os.path
os.path.getsize("df.json") / os.path.getsize("df.json.gz")  #压缩大小差了10倍，还是gz更厉害

这一期为大家总结了很多pandas实用的小技巧，希望大家喜欢

我把这一期的ipynb文件和py文件放到了Github上，大家如果想要下载可以点击下面的链接：

Github仓库地址： https://github.com/yaozeliang/pandas_share

这一期就到这里啦，希望大家能够继续支持我，完结，撒花