小白的Python学习笔记（十七）数据挖掘经常使用包- Pandas（4）

时间  2019-11-07
标签 白的 python 学习 笔记 十七 数据挖掘 经常 使用 pandas 栏目 Python 繁體版
原文   原文链接

Pandas鲜为人知的八大实用技巧

这一期主要是和你们分享一些pandas的实用技巧，会在平常使用中大大提高效率，但愿能够帮助到你们,仍是老样子， 先给你们奉上这一期的章节目录:python

  1. 自定义pandas选项，设置
  2. 实用pandas中testing模块构建测试数据
  3. 巧用accessor接口方法
  4. 合并其余列拼接DatetimeIndex
  5. 使用分类数据（Categorical Data）节省时间和空间
  6. 利用Mapping巧妙实现映射
  7. 压缩pandas对象
  8. 源码及GitHub地址

好啦，话很少说，让咱们一个个看吧git

1. 自定义pandas选项，设置

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

import numpy as np
import pandas as pd
f'Using {pd.__name__}, Version {pd.__version__}'
复制代码
'Using pandas, Version 0.23.0'
复制代码

如今让咱们编写一个start方法来实现自定义pandas设置json

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参数，如今让咱们测试一下：api

pd.get_option('display.max_rows')
复制代码
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
复制代码
sex length diam height weight rings
0 M 0.455 0.365 0.095 0.5140 15
1 M 0.350 0.265 0.090 0.2255 7
2 F 0.530 0.420 0.135 0.6770 9
3 M 0.440 0.365 0.125 0.5160 10
4 I 0.330 0.255 0.080 0.2050 7
5 I 0.425 0.300 0.095 0.3515 8
6 F 0.530 0.415 0.150 0.7775 20
... ... ... ... ... ... ...
4170 M 0.550 0.430 0.130 0.8395 10
4171 M 0.560 0.430 0.155 0.8675 8
4172 F 0.565 0.450 0.165 0.8870 11
4173 M 0.590 0.440 0.135 0.9660 10
4174 M 0.600 0.475 0.205 1.1760 9
4175 F 0.625 0.485 0.150 1.0945 10
4176 M 0.710 0.555 0.195 1.9485 12

咱们能够看到，数据截断为14行，保留了小数点后4位小数做为精度，和咱们刚刚设置的precision=4是同样的app

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

经过pandas.util.testing提供的方法，咱们能够很容易的经过几行代码就构建出一个简单的测试数据类型，好比咱们如今构建一个DataTime类型的数据， 时间间隔为月：dom

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() 设置时间间隔为天
复制代码
A B C
2000-01-31 0.3574 -0.8804 0.2669
2000-02-29 0.3775 0.1526 -0.4803
2000-03-31 1.3823 0.2503 0.3008
2000-04-30 1.1755 0.0785 -0.1791
2000-05-31 -0.9393 -0.9039 1.1837

瞎生成一组乱七八糟的数据：机器学习

tm.makeDataFrame().head()
复制代码
A B C
nTLGGTiRHF -0.6228 0.6459 0.1251
WPBRn9jtsR -0.3187 -0.8091 1.1501
7B3wWfvuDA -1.9872 -1.0795 0.2987
yJ0BTjehH1 0.8802 0.7403 -1.2154
0luaYUYvy1 -0.9320 1.2912 -0.2907

关于能够随机生成的数据类型, 一共大概有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']
复制代码

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

3. 巧用accessor接口方法

accessor（访问器） 具体就是相似getter和setter，固然，Python里面不提倡存在setter和getter方法，可是这样能够便于你们理解，pandas Series类型有3类accessor：

pd.Series._accessors
复制代码
{'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<city>[A-Za-z ]+), '      # One or more letters
         r'(?P<state>[A-Z]{2}) '      # 2 capital letters
         r'(?P<zip>\d{5}(?:-\d{4})?)')  # Optional 4-digit extension

addr.str.replace('.', '').str.extract(regex)
复制代码
city state zip
0 Washington DC 20003
1 Brooklyn NY 11211-1755
2 Omaha NE 68154
3 Pittsburgh PA 15211

第二个访问器.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个技巧中提到

4. 合并其余列拼接DatetimeIndex

如今先让咱们构建一个包含时间类型数据的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 data
0 2017 1 1 -0.0767
1 2017 1 2 -1.2798
2 2017 1 3 0.4032
3 2017 2 1 1.2377
4 2017 2 2 -0.2060
5 2017 2 3 0.6187
6 2016 1 1 2.3786
7 2016 1 2 -0.4730
8 2016 1 3 -2.1505
9 2016 2 1 -0.6340
10 2016 2 2 0.7964
11 2016 2 3 0.0005

咱们能够发现year，month，day是分开的三列，咱们若是想要把它们合并为完整的时间并做为df的索引，能够这么作:

df.index = pd.to_datetime(df[datecols])
df.head()
复制代码
year month day data
2017-01-01 2017 1 1 -0.0767
2017-01-02 2017 1 2 -1.2798
2017-01-03 2017 1 3 0.4032
2017-02-01 2017 2 1 1.2377
2017-02-02 2017 2 2 -0.2060

咱们能够扔掉没用的列并把这个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]'
复制代码

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

刚刚咱们在第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)

<ipython-input-36-1766a795336d> in <module>()
----> 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  # 成功添加
复制代码

6. 利用Mapping巧妙实现映射

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

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}
复制代码

7. 压缩pandas对象

若是你的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更厉害
复制代码

8. 源码及GitHub地址

这一期家总结了不少pandas实用的小技巧，但愿你们喜欢

我把这一期的ipynb文件和py文件放到了Github上，你们若是想要下载能够点击下面的连接：

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程