蚂蚁学Python – 生命不止，探索不息，疯狂的蚂蚁

Python使用Faiss库实现ANN近邻搜索

Embedding的近邻搜索是当前图推荐系统非常重要的一种召回方式，通过item2vec、矩阵分解、双塔DNN等方式都能够产出训练好的user embedding、item embedding，对于embedding的使用非常的灵活：

输入user embedding，近邻搜索item embedding，可以给user推荐感兴趣的items
输入user embedding，近邻搜搜user embedding，可以给user推荐感兴趣的user
输入item embedding，近邻搜索item embedding，可以给item推荐相关的items

然而有一个工程问题，一旦user embedding、item embedding数据量达到一定的程度，对他们的近邻搜索将会变得非常慢，如果离线阶段提前搜索好在高速缓存比如redis存储好结果当然没问题，但是这种方式很不实时，如果能在线阶段上线几十MS的搜索当然效果最好。

Faiss是Facebook AI团队开源的针对聚类和相似性搜索库，为稠密向量提供高效相似度搜索和聚类，支持十亿级别向量的搜索，是目前最为成熟的近似近邻搜索库。

接下来通过jupyter notebook的代码，给大家演示下使用faiss的简单流程，内容包括：

读取训练好的Embedding数据
构建faiss索引，将待搜索的Embedding添加进去
取得目标Embedding，实现搜索得到ID列表
根据ID获取电影标题，返回结果

对于已经训练好的Embedding怎样实现高速近邻搜索是一个工程问题，facebook的faiss库可以构建多种embedding索引实现目标embedding的高速近邻搜索，能够满足在线使用的需要

安装命令：

conda install -c pytorch faiss-cpu

提前总结下faiss使用经验：
1. 为了支持自己的ID，可以用faiss.IndexIDMap包裹faiss.IndexFlatL2即可
2. embedding数据都需要转换成np.float32，包括索引中的embedding以及待搜索的embedding
3. ids需要转换成int64类型

1. 准备数据

import pandas as pd
import numpy as np

df = pd.read_csv("./datas/movielens_sparkals_item_embedding.csv")
df.head()

	id	features
0	10	[0.25866490602493286, 0.3560594320297241, 0.15…
1	20	[0.12449632585048676, -0.29282501339912415, -0…
2	30	[0.9557555317878723, 0.6764761805534363, 0.114…
3	40	[0.3184879720211029, 0.6365472078323364, 0.596…
4	50	[0.45523127913475037, 0.34402626752853394, -0….

构建ids

ids = df["id"].values.astype(np.int64)
type(ids), ids.shape

(numpy.ndarray, (3706,))

ids.dtype

dtype('int64')

ids_size = ids.shape[0]
ids_size

构建datas

import json
import numpy as np

datas = []

for x in df["features"]:
    datas.append(json.loads(x))

datas = np.array(datas).astype(np.float32)

datas.dtype

dtype('float32')

datas.shape

(3706, 10)

datas[0]

array([ 0.2586649 ,  0.35605943,  0.15589039, -0.7067125 , -0.07414215,
       -0.62500805, -0.0573845 ,  0.4533663 ,  0.26074877, -0.60799956],
      dtype=float32)

# 维度
dimension = datas.shape[1]
dimension

2. 建立索引

import faiss

index = faiss.IndexFlatL2(dimension)

index2 = faiss.IndexIDMap(index)

ids.dtype

dtype('int64')

index2.add_with_ids(datas, ids)

index.ntotal

4. 搜索近邻ID列表

df_user = pd.read_csv("./datas/movielens_sparkals_user_embedding.csv")
df_user.head()

	id	features
0	10	[0.5974288582801819, 0.17486965656280518, 0.04…
1	20	[1.3099910020828247, 0.5037978291511536, 0.260…
2	30	[-1.1886241436004639, -0.13511677086353302, 0….
3	40	[1.0809299945831299, 1.0048035383224487, 0.986…
4	50	[0.42388680577278137, 0.5294889807701111, -0.6…

user_embedding = np.array(json.loads(df_user[df_user["id"] == 10]["features"].iloc[0]))
user_embedding = np.expand_dims(user_embedding, axis=0).astype(np.float32)
user_embedding

array([[ 0.59742886,  0.17486966,  0.04345559, -1.3193961 ,  0.5313592 ,
        -0.6052168 , -0.19088413,  1.5307966 ,  0.09310367, -2.7573566 ]],
      dtype=float32)

user_embedding.shape

(1, 10)

user_embedding.dtype

dtype('float32')

topk = 30

D, I = index.search(user_embedding, topk)     # actual search

I.shape

(1, 30)

array([[3380, 2900, 1953,  121, 3285,  999,  617,  747, 2351,  601, 2347,
          42, 2383,  538, 1774,  980, 2165, 3049, 2664,  367, 3289, 2866,
        2452,  547, 1072, 2055, 3660, 3343, 3390, 3590]])

5. 根据电影ID取出电影信息

target_ids = pd.Series(I[0], name="MovieID")
target_ids.head()

0    3380
1    2900
2    1953
3     121
4    3285
Name: MovieID, dtype: int64

df_movie = pd.read_csv("./datas/ml-1m/movies.dat",
                     sep="::", header=None, engine="python",
                     names = "MovieID::Title::Genres".split("::"))
df_movie.head()

	MovieID	Title	Genres
0	1	Toy Story (1995)	Animation\|Children’s\|Comedy
1	2	Jumanji (1995)	Adventure\|Children’s\|Fantasy
2	3	Grumpier Old Men (1995)	Comedy\|Romance
3	4	Waiting to Exhale (1995)	Comedy\|Drama
4	5	Father of the Bride Part II (1995)	Comedy

df_result = pd.merge(target_ids, df_movie)
df_result.head()

	MovieID	Title	Genres
0	3380	Railroaded! (1947)	Film-Noir
1	2900	Monkey Shines (1988)	Horror\|Sci-Fi
2	1953	French Connection, The (1971)	Action\|Crime\|Drama\|Thriller
3	121	Boys of St. Vincent, The (1993)	Drama
4	3285	Beach, The (2000)	Adventure\|Drama

程序员-颈椎病-该练八段锦

自律使我自由

从来都没有完全的自由。

如果不加节制的放纵自己，大吃大喝、熬夜不睡、畅玩游戏，那么就会导致现在的状态，那就是肥胖、精神差、血脂高、颈椎病等等；

放纵，导致了恶果。

而如果想要身体轻盈、健康、精神饱满、激情四射，那就不能通过放纵来实现，而是节制。

如果做到了这些节制：
1. 不吃高糖、高脂、高油腻的食物；
2. 吃饭不吃过度饱；
3. 多次健康食物，比如粗粮、高蛋白；
4. 坐的时间长，就起来活动；
5. 经常做颈椎操，些许的锻炼；
6. 经常散散步走走路，可以尝试快走，做做下蹲和俯卧撑；
7. 少熬夜；
8. 减少趴着睡，伤颈椎，可以用冥想的方式休息；

那么逐步的，我会收获这些健康：
1. 身体的指标回归正常，比如高脂、肥胖；
2. 精神状态变得饱满和有活力；
3. 更加的高产、学习的更加快；

我很向往有一天，自己能身体轻盈、放松自在；

而这，需要节制来实现，而不是放纵；

放纵只能获得当前的满足、过后就是恶果和痛苦；

当前的节制，却能换来将来长期的健康和快乐。

自律使我自由；
当前的自律，带来长期的自由。

文章写的好，但是没人看，原来标题可以这么写

有一种方法，就是三段式标题。

三段式，来自百度百科：

地址：https://baike.baidu.com/item/%E4%B8%89%E6%AE%B5%E5%BC%8F/10868374?fr=aladdin

···
德国哲学家黑格尔用来说明发展过程公式。
认为一切发展都经历三个阶段，
即发展的起点（正题），
对立面的显现（反题），
对立面的统一（合题）。

反题否定正题，合题否定反题，合题是否定之否定。

黑格尔把三段式作为论证其客观唯心主义工具，却为事物从低级到高级发展的辩证法开辟了道路。
···

来自头条起标题的一个说明：

三段式是指用三个小分句组成标题的形式，是最容易出爆款的句式，因为它的套路比较清晰明了易模仿，标题中可以容纳更多的信息点，然后用递进、转折增加标题的争议。大数据显示，三段式的标题比两段式的标题更加吸引用户点击。

例子：

原标题：这样表达，你的听众才会被打动！
点击/展示：4338/112326=3.86%

优化标题：开会时，怎么发言最有水平？一个小技巧让领导对你刮目相看
点击/展示：107387/997934=10.76%

案例解析：原标题太过简略，没有具体场景，优化后的标题设置了“职场”场景，给用户强烈代入感，并且突出了实用价值“让领导对你刮目相看”。

另一个例子

Pandas怎样对每个分组应用apply函数?

知识：Pandas的GroupBy遵从split、apply、combine模式

这里的split指的是pandas的groupby，我们自己实现apply函数，apply返回的结果由pandas进行combine得到结果

GroupBy.apply(function)

function的第一个参数是dataframe
function的返回结果，可是dataframe、series、单个值，甚至和输入dataframe完全没关系

本次实例演示：

怎样对数值列按分组的归一化？
怎样取每个分组的TOPN数据？

实例1：怎样对数值列按分组的归一化？

将不同范围的数值列进行归一化，映射到[0,1]区间：
* 更容易做数据横向对比，比如价格字段是几百到几千，增幅字段是0到100
* 机器学习模型学的更快性能更好

归一化的公式：

演示：用户对电影评分的归一化

每个用户的评分不同，有的乐观派评分高，有的悲观派评分低，按用户做归一化

import pandas as pd

ratings = pd.read_csv(
    "./datas/movielens-1m/ratings.dat", 
    sep="::",
    engine='python', 
    names="UserID::MovieID::Rating::Timestamp".split("::")
)
ratings.head()

	UserID	MovieID	Rating	Timestamp
0	1	1193	5	978300760
1	1	661	3	978302109
2	1	914	3	978301968
3	1	3408	4	978300275
4	1	2355	5	978824291

# 实现按照用户ID分组，然后对其中一列归一化
def ratings_norm(df):
    """
    @param df：每个用户分组的dataframe
    """
    min_value = df["Rating"].min()
    max_value = df["Rating"].max()
    df["Rating_norm"] = df["Rating"].apply(
        lambda x: (x-min_value)/(max_value-min_value))
    return df

ratings = ratings.groupby("UserID").apply(ratings_norm)

ratings[ratings["UserID"]==1].head()

	UserID	MovieID	Rating	Timestamp	Rating_norm
0	1	1193	5	978300760	1.0
1	1	661	3	978302109	0.0
2	1	914	3	978301968	0.0
3	1	3408	4	978300275	0.5
4	1	2355	5	978824291	1.0

可以看到UserID==1这个用户，Rating==3是他的最低分，是个乐观派，我们归一化到0分；

实例2：怎样取每个分组的TOPN数据？

获取2018年每个月温度最高的2天数据

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['month'] = df['ymd'].str[:7]
df.head()

	ymd	bWendu	yWendu	tianqi	fengxiang	fengli	aqi	aqiInfo	aqiLevel	month
0	2018-01-01	3	-6	晴~多云	东北风	1-2级	59	良	2	2018-01
1	2018-01-02	2	-5	阴~多云	东北风	1-2级	49	优	1	2018-01
2	2018-01-03	2	-5	多云	北风	1-2级	28	优	1	2018-01
3	2018-01-04	0	-8	阴	东北风	1-2级	28	优	1	2018-01
4	2018-01-05	3	-6	多云~晴	西北风	1-2级	50	优	1	2018-01

def getWenduTopN(df, topn):
    """
    这里的df，是每个月份分组group的df
    """
    return df.sort_values(by="bWendu")[["ymd", "bWendu"]][-topn:]

df.groupby("month").apply(getWenduTopN, topn=1).head()

		ymd	bWendu
month
2018-01	18	2018-01-19	7
2018-02	56	2018-02-26	12
2018-03	85	2018-03-27	27
2018-04	118	2018-04-29	30
2018-05	150	2018-05-31	35

我们看到，grouby的apply函数返回的dataframe，其实和原来的dataframe其实可以完全不一样

视频地址在：
http://www.iqiyi.com/a_19rrhyyqix.html

怎样使用Pandas的map和apply函数？

数据转换函数对比：map、apply、applymap：
1. map：只用于Series，实现每个值->值的映射；
2. apply：用于Series实现每个值的处理，用于Dataframe实现某个轴的Series的处理；
3. applymap：只能用于DataFrame，用于处理该DataFrame的每个元素；

1. map用于Series值的转换

实例：将股票代码英文转换成中文名字

Series.map(dict) or Series.map(function)均可

import pandas as pd
stocks = pd.read_excel('./datas/stocks/互联网公司股票.xlsx')
stocks.head()

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅
0	2019-10-03	BIDU	104.32	102.35	104.73	101.15	2.24	0.02
1	2019-10-02	BIDU	102.62	100.85	103.24	99.50	2.69	0.01
2	2019-10-01	BIDU	102.00	102.80	103.26	101.00	1.78	-0.01
3	2019-10-03	BABA	169.48	166.65	170.18	165.00	10.39	0.02
4	2019-10-02	BABA	165.77	162.82	166.88	161.90	11.60	0.00

stocks["公司"].unique()

array(['BIDU', 'BABA', 'IQ', 'JD'], dtype=object)

# 公司股票代码到中文的映射，注意这里是小写
dict_company_names = {
    "bidu": "百度",
    "baba": "阿里巴巴",
    "iq": "爱奇艺", 
    "jd": "京东"
}

方法1：Series.map(dict)

stocks["公司中文1"] = stocks["公司"].str.lower().map(dict_company_names)

stocks.head()

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅	公司中文1
0	2019-10-03	BIDU	104.32	102.35	104.73	101.15	2.24	0.02	百度
1	2019-10-02	BIDU	102.62	100.85	103.24	99.50	2.69	0.01	百度
2	2019-10-01	BIDU	102.00	102.80	103.26	101.00	1.78	-0.01	百度
3	2019-10-03	BABA	169.48	166.65	170.18	165.00	10.39	0.02	阿里巴巴
4	2019-10-02	BABA	165.77	162.82	166.88	161.90	11.60	0.00	阿里巴巴

方法2：Series.map(function)

function的参数是Series的每个元素的值

stocks["公司中文2"] = stocks["公司"].map(lambda x : dict_company_names[x.lower()])

stocks.head()

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅	公司中文1	公司中文2
0	2019-10-03	BIDU	104.32	102.35	104.73	101.15	2.24	0.02	百度	百度
1	2019-10-02	BIDU	102.62	100.85	103.24	99.50	2.69	0.01	百度	百度
2	2019-10-01	BIDU	102.00	102.80	103.26	101.00	1.78	-0.01	百度	百度
3	2019-10-03	BABA	169.48	166.65	170.18	165.00	10.39	0.02	阿里巴巴	阿里巴巴
4	2019-10-02	BABA	165.77	162.82	166.88	161.90	11.60	0.00	阿里巴巴	阿里巴巴

2. apply用于Series和DataFrame的转换

Series.apply(function), 函数的参数是每个值
DataFrame.apply(function), 函数的参数是Series

Series.apply(function)

function的参数是Series的每个值

stocks["公司中文3"] = stocks["公司"].apply(
    lambda x : dict_company_names[x.lower()])

stocks.head()

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅	公司中文1	公司中文2	公司中文3
0	2019-10-03	BIDU	104.32	102.35	104.73	101.15	2.24	0.02	百度	百度	百度
1	2019-10-02	BIDU	102.62	100.85	103.24	99.50	2.69	0.01	百度	百度	百度
2	2019-10-01	BIDU	102.00	102.80	103.26	101.00	1.78	-0.01	百度	百度	百度
3	2019-10-03	BABA	169.48	166.65	170.18	165.00	10.39	0.02	阿里巴巴	阿里巴巴	阿里巴巴
4	2019-10-02	BABA	165.77	162.82	166.88	161.90	11.60	0.00	阿里巴巴	阿里巴巴	阿里巴巴

DataFrame.apply(function)

function的参数是对应轴的Series

stocks["公司中文4"] = stocks.apply(
    lambda x : dict_company_names[x["公司"].lower()], 
    axis=1)

注意这个代码：
1、apply是在stocks这个DataFrame上调用；
2、lambda x的x是一个Series，因为指定了axis=1所以Seires的key是列名，可以用x[‘公司’]获取

stocks.head()

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅	公司中文1	公司中文2	公司中文3	公司中文4
0	2019-10-03	BIDU	104.32	102.35	104.73	101.15	2.24	0.02	百度	百度	百度	百度
1	2019-10-02	BIDU	102.62	100.85	103.24	99.50	2.69	0.01	百度	百度	百度	百度
2	2019-10-01	BIDU	102.00	102.80	103.26	101.00	1.78	-0.01	百度	百度	百度	百度
3	2019-10-03	BABA	169.48	166.65	170.18	165.00	10.39	0.02	阿里巴巴	阿里巴巴	阿里巴巴	阿里巴巴
4	2019-10-02	BABA	165.77	162.82	166.88	161.90	11.60	0.00	阿里巴巴	阿里巴巴	阿里巴巴	阿里巴巴

3. applymap用于DataFrame所有值的转换

sub_df = stocks[['收盘', '开盘', '高', '低', '交易量']]

sub_df.head()

	收盘	开盘	高	低	交易量
0	104.32	102.35	104.73	101.15	2.24
1	102.62	100.85	103.24	99.50	2.69
2	102.00	102.80	103.26	101.00	1.78
3	169.48	166.65	170.18	165.00	10.39
4	165.77	162.82	166.88	161.90	11.60

# 将这些数字取整数，应用于所有元素
sub_df.applymap(lambda x : int(x))

	收盘	开盘	高	低	交易量
0	104	102	104	101	2
1	102	100	103	99	2
2	102	102	103	101	1
3	169	166	170	165	10
4	165	162	166	161	11
5	165	168	168	163	14
6	16	15	16	15	10
7	15	15	15	15	8
8	15	16	16	15	11
9	28	28	28	27	8
10	28	28	28	27	9
11	28	28	28	27	10

# 直接修改原df的这几列
stocks.loc[:, ['收盘', '开盘', '高', '低', '交易量']] = sub_df.applymap(lambda x : int(x))

stocks.head()

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅	公司中文1	公司中文2	公司中文3	公司中文4
0	2019-10-03	BIDU	104	102	104	101	2	0.02	百度	百度	百度	百度
1	2019-10-02	BIDU	102	100	103	99	2	0.01	百度	百度	百度	百度
2	2019-10-01	BIDU	102	102	103	101	1	-0.01	百度	百度	百度	百度
3	2019-10-03	BABA	169	166	170	165	10	0.02	阿里巴巴	阿里巴巴	阿里巴巴	阿里巴巴
4	2019-10-02	BABA	165	162	166	161	11	0.00	阿里巴巴	阿里巴巴	阿里巴巴	阿里巴巴

Pandas的分层索引MultiIndex怎样用？

Pandas的分层索引MultiIndex

为什么要学习分层索引MultiIndex？
* 分层索引：在一个轴向上拥有多个索引层级，可以表达更高维度数据的形式；
* 可以更方便的进行数据筛选，如果有序则性能更好；
* groupby等操作的结果，如果是多KEY，结果是分层索引，需要会使用
* 一般不需要自己创建分层索引(MultiIndex有构造函数但一般不用)

演示数据：百度、阿里巴巴、爱奇艺、京东四家公司的10天股票数据
数据来自：英为财经
https://cn.investing.com/

本次演示提纲：
一、Series的分层索引MultiIndex
二、Series有多层索引怎样筛选数据？
三、DataFrame的多层索引MultiIndex
四、DataFrame有多层索引怎样筛选数据？

import pandas as pd
%matplotlib inline

stocks = pd.read_excel('./datas/stocks/互联网公司股票.xlsx')

stocks.shape

(12, 8)

stocks.head(3)

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅
0	2019-10-03	BIDU	104.32	102.35	104.73	101.15	2.24	0.02
1	2019-10-02	BIDU	102.62	100.85	103.24	99.50	2.69	0.01
2	2019-10-01	BIDU	102.00	102.80	103.26	101.00	1.78	-0.01

stocks["公司"].unique()

array(['BIDU', 'BABA', 'IQ', 'JD'], dtype=object)

stocks.index

RangeIndex(start=0, stop=12, step=1)

stocks.groupby('公司')["收盘"].mean()

公司
BABA    166.80
BIDU    102.98
IQ       15.90
JD       28.35
Name: 收盘, dtype: float64

一、Series的分层索引MultiIndex

ser = stocks.groupby(['公司', '日期'])['收盘'].mean()
ser

公司    日期        
BABA  2019-10-01    165.15
      2019-10-02    165.77
      2019-10-03    169.48
BIDU  2019-10-01    102.00
      2019-10-02    102.62
      2019-10-03    104.32
IQ    2019-10-01     15.92
      2019-10-02     15.72
      2019-10-03     16.06
JD    2019-10-01     28.19
      2019-10-02     28.06
      2019-10-03     28.80
Name: 收盘, dtype: float64

多维索引中，空白的意思是：使用上面的值

ser.index

MultiIndex([('BABA', '2019-10-01'),
            ('BABA', '2019-10-02'),
            ('BABA', '2019-10-03'),
            ('BIDU', '2019-10-01'),
            ('BIDU', '2019-10-02'),
            ('BIDU', '2019-10-03'),
            (  'IQ', '2019-10-01'),
            (  'IQ', '2019-10-02'),
            (  'IQ', '2019-10-03'),
            (  'JD', '2019-10-01'),
            (  'JD', '2019-10-02'),
            (  'JD', '2019-10-03')],
           names=['公司', '日期'])

# unstack把二级索引变成列
ser.unstack()

日期	2019-10-01	2019-10-02	2019-10-03
公司
BABA	165.15	165.77	169.48
BIDU	102.00	102.62	104.32
IQ	15.92	15.72	16.06
JD	28.19	28.06	28.80

ser

公司    日期        
BABA  2019-10-01    165.15
      2019-10-02    165.77
      2019-10-03    169.48
BIDU  2019-10-01    102.00
      2019-10-02    102.62
      2019-10-03    104.32
IQ    2019-10-01     15.92
      2019-10-02     15.72
      2019-10-03     16.06
JD    2019-10-01     28.19
      2019-10-02     28.06
      2019-10-03     28.80
Name: 收盘, dtype: float64

ser.reset_index()

	公司	日期	收盘
0	BABA	2019-10-01	165.15
1	BABA	2019-10-02	165.77
2	BABA	2019-10-03	169.48
3	BIDU	2019-10-01	102.00
4	BIDU	2019-10-02	102.62
5	BIDU	2019-10-03	104.32
6	IQ	2019-10-01	15.92
7	IQ	2019-10-02	15.72
8	IQ	2019-10-03	16.06
9	JD	2019-10-01	28.19
10	JD	2019-10-02	28.06
11	JD	2019-10-03	28.80

二、Series有多层索引MultiIndex怎样筛选数据？

ser

公司    日期        
BABA  2019-10-01    165.15
      2019-10-02    165.77
      2019-10-03    169.48
BIDU  2019-10-01    102.00
      2019-10-02    102.62
      2019-10-03    104.32
IQ    2019-10-01     15.92
      2019-10-02     15.72
      2019-10-03     16.06
JD    2019-10-01     28.19
      2019-10-02     28.06
      2019-10-03     28.80
Name: 收盘, dtype: float64

ser.loc['BIDU']

日期
2019-10-01    102.00
2019-10-02    102.62
2019-10-03    104.32
Name: 收盘, dtype: float64

# 多层索引，可以用元组的形式筛选
ser.loc[('BIDU', '2019-10-02')]

102.62

ser.loc[:, '2019-10-02']

公司
BABA    165.77
BIDU    102.62
IQ       15.72
JD       28.06
Name: 收盘, dtype: float64

三、DataFrame的多层索引MultiIndex

stocks.head()

	日期	公司	收盘	开盘	高	低	交易量	涨跌幅
0	2019-10-03	BIDU	104.32	102.35	104.73	101.15	2.24	0.02
1	2019-10-02	BIDU	102.62	100.85	103.24	99.50	2.69	0.01
2	2019-10-01	BIDU	102.00	102.80	103.26	101.00	1.78	-0.01
3	2019-10-03	BABA	169.48	166.65	170.18	165.00	10.39	0.02
4	2019-10-02	BABA	165.77	162.82	166.88	161.90	11.60	0.00

stocks.set_index(['公司', '日期'], inplace=True)
stocks

		收盘	开盘	高	低	交易量	涨跌幅
公司	日期
BIDU	2019-10-03	104.32	102.35	104.73	101.15	2.24	0.02
	2019-10-02	102.62	100.85	103.24	99.50	2.69	0.01
	2019-10-01	102.00	102.80	103.26	101.00	1.78	-0.01
BABA	2019-10-03	169.48	166.65	170.18	165.00	10.39	0.02
	2019-10-02	165.77	162.82	166.88	161.90	11.60	0.00
	2019-10-01	165.15	168.01	168.23	163.64	14.19	-0.01
IQ	2019-10-03	16.06	15.71	16.38	15.32	10.08	0.02
	2019-10-02	15.72	15.85	15.87	15.12	8.10	-0.01
	2019-10-01	15.92	16.14	16.22	15.50	11.65	-0.01
JD	2019-10-03	28.80	28.11	28.97	27.82	8.77	0.03
	2019-10-02	28.06	28.00	28.22	27.53	9.53	0.00
	2019-10-01	28.19	28.22	28.57	27.97	10.64	0.00

stocks.index

MultiIndex([('BIDU', '2019-10-03'),
            ('BIDU', '2019-10-02'),
            ('BIDU', '2019-10-01'),
            ('BABA', '2019-10-03'),
            ('BABA', '2019-10-02'),
            ('BABA', '2019-10-01'),
            (  'IQ', '2019-10-03'),
            (  'IQ', '2019-10-02'),
            (  'IQ', '2019-10-01'),
            (  'JD', '2019-10-03'),
            (  'JD', '2019-10-02'),
            (  'JD', '2019-10-01')],
           names=['公司', '日期'])

stocks.sort_index(inplace=True)
stocks

		收盘	开盘	高	低	交易量	涨跌幅
公司	日期
BABA	2019-10-01	165.15	168.01	168.23	163.64	14.19	-0.01
	2019-10-02	165.77	162.82	166.88	161.90	11.60	0.00
	2019-10-03	169.48	166.65	170.18	165.00	10.39	0.02
BIDU	2019-10-01	102.00	102.80	103.26	101.00	1.78	-0.01
	2019-10-02	102.62	100.85	103.24	99.50	2.69	0.01
	2019-10-03	104.32	102.35	104.73	101.15	2.24	0.02
IQ	2019-10-01	15.92	16.14	16.22	15.50	11.65	-0.01
	2019-10-02	15.72	15.85	15.87	15.12	8.10	-0.01
	2019-10-03	16.06	15.71	16.38	15.32	10.08	0.02
JD	2019-10-01	28.19	28.22	28.57	27.97	10.64	0.00
	2019-10-02	28.06	28.00	28.22	27.53	9.53	0.00
	2019-10-03	28.80	28.11	28.97	27.82	8.77	0.03

四、DataFrame有多层索引MultiIndex怎样筛选数据？

【重要知识】在选择数据时：
* 元组(key1,key2)代表筛选多层索引，其中key1是索引第一级，key2是第二级，比如key1=JD, key2=2019-10-02
* 列表[key1,key2]代表同一层的多个KEY，其中key1和key2是并列的同级索引，比如key1=JD, key2=BIDU

stocks.loc['BIDU']

	收盘	开盘	高	低	交易量	涨跌幅
日期
2019-10-01	102.00	102.80	103.26	101.00	1.78	-0.01
2019-10-02	102.62	100.85	103.24	99.50	2.69	0.01
2019-10-03	104.32	102.35	104.73	101.15	2.24	0.02

stocks.loc[('BIDU', '2019-10-02'), :]

收盘     102.62
开盘     100.85
高      103.24
低       99.50
交易量      2.69
涨跌幅      0.01
Name: (BIDU, 2019-10-02), dtype: float64

stocks.loc[('BIDU', '2019-10-02'), '开盘']

100.85

stocks.loc[['BIDU', 'JD'], :]

		收盘	开盘	高	低	交易量	涨跌幅
公司	日期
BIDU	2019-10-01	102.00	102.80	103.26	101.00	1.78	-0.01
	2019-10-02	102.62	100.85	103.24	99.50	2.69	0.01
	2019-10-03	104.32	102.35	104.73	101.15	2.24	0.02
JD	2019-10-01	28.19	28.22	28.57	27.97	10.64	0.00
	2019-10-02	28.06	28.00	28.22	27.53	9.53	0.00
	2019-10-03	28.80	28.11	28.97	27.82	8.77	0.03

stocks.loc[(['BIDU', 'JD'], '2019-10-03'), :]

		收盘	开盘	高	低	交易量	涨跌幅
公司	日期
BIDU	2019-10-03	104.32	102.35	104.73	101.15	2.24	0.02
JD	2019-10-03	28.80	28.11	28.97	27.82	8.77	0.03

stocks.loc[(['BIDU', 'JD'], '2019-10-03'), '收盘']

公司    日期        
BIDU  2019-10-03    104.32
JD    2019-10-03     28.80
Name: 收盘, dtype: float64

stocks.loc[('BIDU', ['2019-10-02', '2019-10-03']), '收盘']

公司    日期        
BIDU  2019-10-02    102.62
      2019-10-03    104.32
Name: 收盘, dtype: float64

# slice(None)代表筛选这一索引的所有内容
stocks.loc[(slice(None), ['2019-10-02', '2019-10-03']), :]

		收盘	开盘	高	低	交易量	涨跌幅
公司	日期
BABA	2019-10-02	165.77	162.82	166.88	161.90	11.60	0.00
BABA	2019-10-03	169.48	166.65	170.18	165.00	10.39	0.02
BIDU	2019-10-02	102.62	100.85	103.24	99.50	2.69	0.01
BIDU	2019-10-03	104.32	102.35	104.73	101.15	2.24	0.02
IQ	2019-10-02	15.72	15.85	15.87	15.12	8.10	-0.01
IQ	2019-10-03	16.06	15.71	16.38	15.32	10.08	0.02
JD	2019-10-02	28.06	28.00	28.22	27.53	9.53	0.00
JD	2019-10-03	28.80	28.11	28.97	27.82	8.77	0.03

stocks.reset_index()

	公司	日期	收盘	开盘	高	低	交易量	涨跌幅
0	BABA	2019-10-01	165.15	168.01	168.23	163.64	14.19	-0.01
1	BABA	2019-10-02	165.77	162.82	166.88	161.90	11.60	0.00
2	BABA	2019-10-03	169.48	166.65	170.18	165.00	10.39	0.02
3	BIDU	2019-10-01	102.00	102.80	103.26	101.00	1.78	-0.01
4	BIDU	2019-10-02	102.62	100.85	103.24	99.50	2.69	0.01
5	BIDU	2019-10-03	104.32	102.35	104.73	101.15	2.24	0.02
6	IQ	2019-10-01	15.92	16.14	16.22	15.50	11.65	-0.01
7	IQ	2019-10-02	15.72	15.85	15.87	15.12	8.10	-0.01
8	IQ	2019-10-03	16.06	15.71	16.38	15.32	10.08	0.02
9	JD	2019-10-01	28.19	28.22	28.57	27.97	10.64	0.00
10	JD	2019-10-02	28.06	28.00	28.22	27.53	9.53	0.00
11	JD	2019-10-03	28.80	28.11	28.97	27.82	8.77	0.03

转载请注明链接： http://www.crazyant.net/2598.html

Pandas怎样实现对数据的分组统计？

Pandas怎样实现groupby分组统计

类似SQL：
select city,max(temperature) from city_weather group by city;

groupby：先对数据分组，然后在每个分组上应用聚合函数、转换函数

本次演示：
一、分组使用聚合函数做数据统计
二、遍历groupby的结果理解执行流程
三、实例分组探索天气数据

import pandas as pd
import numpy as np
# 加上这一句，能在jupyter notebook展示matplot图表
%matplotlib inline

df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
                   'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
                   'C': np.random.randn(8),
                   'D': np.random.randn(8)})
df

	A	B	C	D
0	foo	one	0.542903	0.788896
1	bar	one	-0.375789	-0.345869
2	foo	two	-0.903407	0.428031
3	bar	three	-1.564748	0.081163
4	foo	two	-1.093602	0.837348
5	bar	two	-0.202403	0.701301
6	foo	one	-0.665189	-1.505290
7	foo	three	-0.498339	0.534438

一、分组使用聚合函数做数据统计

1、单个列groupby，查询所有数据列的统计

df.groupby('A').sum()

	C	D
A
bar	-2.142940	0.436595
foo	-2.617633	1.083423

我们看到：
1. groupby中的’A’变成了数据的索引列
2. 因为要统计sum，但B列不是数字，所以被自动忽略掉

2、多个列groupby，查询所有数据列的统计

df.groupby(['A','B']).mean()

		C	D
A	B
bar	one	-0.375789	-0.345869
	three	-1.564748	0.081163
	two	-0.202403	0.701301
foo	one	-0.061143	-0.358197
	three	-0.498339	0.534438
	two	-0.998504	0.632690

我们看到：(‘A’,’B’)成对变成了二级索引

df.groupby(['A','B'], as_index=False).mean()

	A	B	C	D
0	bar	one	-0.375789	-0.345869
1	bar	three	-1.564748	0.081163
2	bar	two	-0.202403	0.701301
3	foo	one	-0.061143	-0.358197
4	foo	three	-0.498339	0.534438
5	foo	two	-0.998504	0.632690

3、同时查看多种数据统计

df.groupby('A').agg([np.sum, np.mean, np.std])

	C			D
	sum	mean	std	sum	mean	std
A
bar	-2.142940	-0.714313	0.741583	0.436595	0.145532	0.526544
foo	-2.617633	-0.523527	0.637822	1.083423	0.216685	0.977686

我们看到：列变成了多级索引

4、查看单列的结果数据统计

# 方法1：预过滤，性能更好
df.groupby('A')['C'].agg([np.sum, np.mean, np.std])

	sum	mean	std
A
bar	-2.142940	-0.714313	0.741583
foo	-2.617633	-0.523527	0.637822

# 方法2
df.groupby('A').agg([np.sum, np.mean, np.std])['C']

	sum	mean	std
A
bar	-2.142940	-0.714313	0.741583
foo	-2.617633	-0.523527	0.637822

5、不同列使用不同的聚合函数

df.groupby('A').agg({"C":np.sum, "D":np.mean})

	C	D
A
bar	-2.142940	0.145532
foo	-2.617633	0.216685

二、遍历groupby的结果理解执行流程

for循环可以直接遍历每个group

1、遍历单个列聚合的分组

g = df.groupby('A')
g

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x00000123B250E548>

for name,group in g:
    print(name)
    print(group)
    print()

bar
     A      B         C         D
1  bar    one -0.375789 -0.345869
3  bar  three -1.564748  0.081163
5  bar    two -0.202403  0.701301

foo
     A      B         C         D
0  foo    one  0.542903  0.788896
2  foo    two -0.903407  0.428031
4  foo    two -1.093602  0.837348
6  foo    one -0.665189 -1.505290
7  foo  three -0.498339  0.534438

可以获取单个分组的数据

g.get_group('bar')

	A	B	C	D
1	bar	one	-0.375789	-0.345869
3	bar	three	-1.564748	0.081163
5	bar	two	-0.202403	0.701301

2、遍历多个列聚合的分组

g = df.groupby(['A', 'B'])

for name,group in g:
    print(name)
    print(group)
    print()

('bar', 'one')
     A    B         C         D
1  bar  one -0.375789 -0.345869

('bar', 'three')
     A      B         C         D
3  bar  three -1.564748  0.081163

('bar', 'two')
     A    B         C         D
5  bar  two -0.202403  0.701301

('foo', 'one')
     A    B         C         D
0  foo  one  0.542903  0.788896
6  foo  one -0.665189 -1.505290

('foo', 'three')
     A      B         C         D
7  foo  three -0.498339  0.534438

('foo', 'two')
     A    B         C         D
2  foo  two -0.903407  0.428031
4  foo  two -1.093602  0.837348

可以看到，name是一个2个元素的tuple，代表不同的列

g.get_group(('foo', 'one'))

	A	B	C	D
0	foo	one	0.542903	0.788896
6	foo	one	-0.665189	-1.505290

可以直接查询group后的某几列，生成Series或者子DataFrame

g['C']

<pandas.core.groupby.generic.SeriesGroupBy object at 0x00000123C33F64C8>

for name, group in g['C']:
    print(name)
    print(group)
    print(type(group))
    print()

('bar', 'one')
1   -0.375789
Name: C, dtype: float64
<class 'pandas.core.series.Series'>

('bar', 'three')
3   -1.564748
Name: C, dtype: float64
<class 'pandas.core.series.Series'>

('bar', 'two')
5   -0.202403
Name: C, dtype: float64
<class 'pandas.core.series.Series'>

('foo', 'one')
0    0.542903
6   -0.665189
Name: C, dtype: float64
<class 'pandas.core.series.Series'>

('foo', 'three')
7   -0.498339
Name: C, dtype: float64
<class 'pandas.core.series.Series'>

('foo', 'two')
2   -0.903407
4   -1.093602
Name: C, dtype: float64
<class 'pandas.core.series.Series'>

其实所有的聚合统计，都是在dataframe和series上进行的；

三、实例分组探索天气数据

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()

	ymd	bWendu	yWendu	tianqi	fengxiang	fengli	aqi	aqiInfo	aqiLevel
0	2018-01-01	3	-6	晴~多云	东北风	1-2级	59	良	2
1	2018-01-02	2	-5	阴~多云	东北风	1-2级	49	优	1
2	2018-01-03	2	-5	多云	北风	1-2级	28	优	1
3	2018-01-04	0	-8	阴	东北风	1-2级	28	优	1
4	2018-01-05	3	-6	多云~晴	西北风	1-2级	50	优	1

# 新增一列为月份
df['month'] = df['ymd'].str[:7]
df.head()

	ymd	bWendu	yWendu	tianqi	fengxiang	fengli	aqi	aqiInfo	aqiLevel	month
0	2018-01-01	3	-6	晴~多云	东北风	1-2级	59	良	2	2018-01
1	2018-01-02	2	-5	阴~多云	东北风	1-2级	49	优	1	2018-01
2	2018-01-03	2	-5	多云	北风	1-2级	28	优	1	2018-01
3	2018-01-04	0	-8	阴	东北风	1-2级	28	优	1	2018-01
4	2018-01-05	3	-6	多云~晴	西北风	1-2级	50	优	1	2018-01

1、查看每个月的最高温度

data = df.groupby('month')['bWendu'].max()
data

month
2018-01     7
2018-02    12
2018-03    27
2018-04    30
2018-05    35
2018-06    38
2018-07    37
2018-08    36
2018-09    31
2018-10    25
2018-11    18
2018-12    10
Name: bWendu, dtype: int32

type(data)

pandas.core.series.Series

data.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x123c344b308>

2、查看每个月的最高温度、最低温度、平均空气质量指数

df.head()

	ymd	bWendu	yWendu	tianqi	fengxiang	fengli	aqi	aqiInfo	aqiLevel	month
0	2018-01-01	3	-6	晴~多云	东北风	1-2级	59	良	2	2018-01
1	2018-01-02	2	-5	阴~多云	东北风	1-2级	49	优	1	2018-01
2	2018-01-03	2	-5	多云	北风	1-2级	28	优	1	2018-01
3	2018-01-04	0	-8	阴	东北风	1-2级	28	优	1	2018-01
4	2018-01-05	3	-6	多云~晴	西北风	1-2级	50	优	1	2018-01

group_data = df.groupby('month').agg({"bWendu":np.max, "yWendu":np.min, "aqi":np.mean})
group_data

	bWendu	yWendu	aqi
month
2018-01	7	-12	60.677419
2018-02	12	-10	78.857143
2018-03	27	-4	130.322581
2018-04	30	1	102.866667
2018-05	35	10	99.064516
2018-06	38	17	82.300000
2018-07	37	22	72.677419
2018-08	36	20	59.516129
2018-09	31	11	50.433333
2018-10	25	1	67.096774
2018-11	18	-4	105.100000
2018-12	10	-12	77.354839

group_data.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x123c5502d48>

怎样使用Pandas批量拆分与合并Excel文件？

Pandas批量拆分Excel与合并Excel

实例演示：
1. 将一个大Excel等份拆成多个Excel
2. 将多个小Excel合并成一个大Excel并标记来源

work_dir="./course_datas/c15_excel_split_merge"
splits_dir=f"{work_dir}/splits"

import os
if not os.path.exists(splits_dir):
    os.mkdir(splits_dir)

0、读取源Excel到Pandas

import pandas as pd

df_source = pd.read_excel(f"{work_dir}/crazyant_blog_articles_source.xlsx")

df_source.head()

	id	title	tags
0	2585	Tensorflow怎样接收变长列表特征	python,tensorflow,特征工程
1	2583	Pandas实现数据的合并concat	pandas,python,数据分析
2	2574	Pandas的Index索引有什么用途？	pandas,python,数据分析
3	2564	机器学习常用数据集大全	python,机器学习
4	2561	一个数据科学家的修炼路径	数据分析

df_source.index

RangeIndex(start=0, stop=258, step=1)

df_source.shape

(258, 3)

total_row_count = df_source.shape[0]
total_row_count

一、将一个大Excel等份拆成多个Excel

使用df.iloc方法，将一个大的dataframe，拆分成多个小dataframe
将使用dataframe.to_excel保存每个小Excel

1、计算拆分后的每个excel的行数

# 这个大excel，会拆分给这几个人
user_names = ["xiao_shuai", "xiao_wang", "xiao_ming", "xiao_lei", "xiao_bo", "xiao_hong"]

# 每个人的任务数目
split_size = total_row_count // len(user_names)
if total_row_count % len(user_names) != 0:
    split_size += 1

split_size

2、拆分成多个dataframe

df_subs = []
for idx, user_name in enumerate(user_names):
    # iloc的开始索引
    begin = idx*split_size
    # iloc的结束索引
    end = begin+split_size
    # 实现df按照iloc拆分
    df_sub = df_source.iloc[begin:end]
    # 将每个子df存入列表
    df_subs.append((idx, user_name, df_sub))

3、将每个datafame存入excel

for idx, user_name, df_sub in df_subs:
    file_name = f"{splits_dir}/crazyant_blog_articles_{idx}_{user_name}.xlsx"
    df_sub.to_excel(file_name, index=False)

二、合并多个小Excel到一个大Excel

遍历文件夹，得到要合并的Excel文件列表
分别读取到dataframe，给每个df添加一列用于标记来源
使用pd.concat进行df批量合并
将合并后的dataframe输出到excel

1. 遍历文件夹，得到要合并的Excel名称列表

import os
excel_names = []
for excel_name in os.listdir(splits_dir):
    excel_names.append(excel_name)
excel_names

['crazyant_blog_articles_0_xiao_shuai.xlsx',
 'crazyant_blog_articles_1_xiao_wang.xlsx',
 'crazyant_blog_articles_2_xiao_ming.xlsx',
 'crazyant_blog_articles_3_xiao_lei.xlsx',
 'crazyant_blog_articles_4_xiao_bo.xlsx',
 'crazyant_blog_articles_5_xiao_hong.xlsx']

2. 分别读取到dataframe

df_list = []

for excel_name in excel_names:
    # 读取每个excel到df
    excel_path = f"{splits_dir}/{excel_name}"
    df_split = pd.read_excel(excel_path)
    # 得到username
    username = excel_name.replace("crazyant_blog_articles_", "").replace(".xlsx", "")[2:]
    print(excel_name, username)
    # 给每个df添加1列，即用户名字
    df_split["username"] = username

    df_list.append(df_split)

crazyant_blog_articles_0_xiao_shuai.xlsx xiao_shuai
crazyant_blog_articles_1_xiao_wang.xlsx xiao_wang
crazyant_blog_articles_2_xiao_ming.xlsx xiao_ming
crazyant_blog_articles_3_xiao_lei.xlsx xiao_lei
crazyant_blog_articles_4_xiao_bo.xlsx xiao_bo
crazyant_blog_articles_5_xiao_hong.xlsx xiao_hong

3. 使用pd.concat进行合并

df_merged = pd.concat(df_list)

df_merged.shape

(258, 4)

df_merged.head()

	id	title	tags	username
0	2585	Tensorflow怎样接收变长列表特征	python,tensorflow,特征工程	xiao_shuai
1	2583	Pandas实现数据的合并concat	pandas,python,数据分析	xiao_shuai
2	2574	Pandas的Index索引有什么用途？	pandas,python,数据分析	xiao_shuai
3	2564	机器学习常用数据集大全	python,机器学习	xiao_shuai
4	2561	一个数据科学家的修炼路径	数据分析	xiao_shuai

df_merged["username"].value_counts()

xiao_hong     43
xiao_bo       43
xiao_shuai    43
xiao_lei      43
xiao_wang     43
xiao_ming     43
Name: username, dtype: int64

4. 将合并后的dataframe输出到excel

df_merged.to_excel(f"{work_dir}/crazyant_blog_articles_merged.xlsx", index=False)

	收盘	开盘	高	低	交易量
0	104	102	104	101	2
1	102	100	103	99	2
2	102	102	103	101	1
3	169	166	170	165	10
4	165	162	166	161	11
5	165	168	168	163	14
6	16	15	16	15	10
7	15	15	15	15	8
8	15	16	16	15	11
9	28	28	28	27	8
10	28	28	28	27	9
11	28	28	28	27	10

	收盘	开盘	高	低	交易量
0	104	102	104	101	2
1	102	100	103	99	2
2	102	102	103	101	1
3	169	166	170	165	10
4	165	162	166	161	11
5	165	168	168	163	14
6	16	15	16	15	10
7	15	15	15	15	8
8	15	16	16	15	11
9	28	28	28	27	8
10	28	28	28	27	9
11	28	28	28	27	10

	收盘	开盘	高	低	交易量
0	104	102	104	101	2
1	102	100	103	99	2
2	102	102	103	101	1
3	169	166	170	165	10
4	165	162	166	161	11
5	165	168	168	163	14
6	16	15	16	15	10
7	15	15	15	15	8
8	15	16	16	15	11
9	28	28	28	27	8
10	28	28	28	27	9
11	28	28	28	27	10