如果Pandas只是能把一些數據變成 dataframe 這樣優美的格式，那麼Pandas絕不會成為叱吒風雲的數據分析中心組件。因為在數據分析過程中，描述數據是通過一些列的統計指標實現的，分析結果也需要由具體的分組行為，對各組橫向縱向對比。

GroupBy 就是這樣的一個有力武器。事實上，SQL語言在Pandas出現的幾十年前就成為了高級數據分析人員的標準工具，很大一部分原因正是因為它有標準的SELECT xx FROM xx WHERE condition GROUP BY xx HAVING condition 範式。

感謝 Wes Mckinney及其團隊，除了SQL之外，我們多了一個更靈活、適應性更強的工具，而非困在SQL Shell或Python里步履沉重。

【示例】將一段SQL語句用Pandas表達

SQL

SELECT Column1, Column2, mean(Column3), sum(Column4)
FROM SomeTable
WHERE Condition 1
GROUP BY Column1, Column2
HAVING Condition2

Pandas

df [Condition1].groupby([Column1, Column2], as_index=False).agg({Column3: “mean”, Column4: “sum”}).filter(Condition2)

Group By: split – apply – combine

GroupBy可以分解為三個步驟：

• Splitting: 把數據按主鍵劃分為很多個小組
• Applying: 對每個小組獨立地使用函數
• Combining: 把所得到的結果組合

那麼，這一套行雲流水的動作是如何完成的呢？

• Splitting 由 groupby 實現
• Applying 由 agg、apply、transform、filter實現具體的操作
• Combining 由 concat 等實現

其中，在apply這一步，通常由以下四類操作：

• Aggregation:做一些統計性的計算
• Apply：做一些數據轉換
• Transformation:做一些數據處理方面的變換
• Filtration:做一些組級別的過濾

注意，這裏討論的apply,agg,transform,filter方法都是限制在 pandas.core.groupby.DataFrameGroupBy裏面，不能跟 pandas.core.groupby.DataFrame混淆。

先導入需要用到的模塊

import numpy as np
import pandas as pd
import sys, traceback
from itertools import chain

Part 1: Groupby 詳解

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

df_0

	A	B	C	D
0	foo	one	1.145852	0.210586
1	bar	one	-1.343518	-2.064735
2	foo	two	0.544624	1.125505
3	bar	three	1.090288	-0.296160
4	foo	two	-1.854274	1.348597
5	bar	two	-0.246072	-0.598949
6	foo	one	0.348484	0.429300
7	bar	three	1.477379	0.917027

Talk 1：創建一個Groupby對象時應注意的問題

Good Practice

df_01 = df_0.copy()
df_01.groupby(["A", "B"], as_index=False, sort=False).agg({"C": "sum", "D": "mean"})

	A	B	C	D
0	foo	one	1.494336	0.319943
1	bar	one	-1.343518	-2.064735
2	foo	two	-1.309649	1.237051
3	bar	three	2.567667	0.310433
4	bar	two	-0.246072	-0.598949

Poor Practice

df_02 = df_0.copy()
df_02.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"}).reset_index()

	A	B	C	D
0	bar	one	-1.343518	-2.064735
1	bar	three	2.567667	0.310433
2	bar	two	-0.246072	-0.598949
3	foo	one	1.494336	0.319943
4	foo	two	-1.309649	1.237051

• 直接使用 as_index=False 參數是一個好的習慣，因為如果dataframe非常巨大（比如達到GB以上規模）時，先生成一個Groupby對象，然後再調用reset_index()會有額外的時間消耗。
• 在任何涉及數據的操作中，排序都是非常”奢侈的”。如果只是單純的分組，不關心順序，在創建Groupby對象的時候應當關閉排序功能，因為這個功能默認是開啟的。尤其當你在較大的大數據集上作業時更當注意這個問題。
• 值得注意的是：groupby會按照數據在原始數據框內的順序安排它們在每個新組內的順序。這與是否指定排序無關。

如果要得到一個多層索引的數據框，使用默認的as_index=True即可，例如下面的例子：

df_03 = df_0.copy()
df_03.groupby(["A", "B"]).agg({"C": "sum", "D": "mean"})

		C	D
A	B
bar	one	-1.343518	-2.064735
	three	2.567667	0.310433
	two	-0.246072	-0.598949
foo	one	1.494336	0.319943
	two	-1.309649	1.237051

注意，as_index僅當做aggregation操作時有效，如果是其他操作，例如transform，指定這個參數是無效的

df_04 = df_0.copy()
df_04.groupby(["A", "B"], as_index=True).transform(lambda x: x * x)

	C	D
0	1.312976	0.044347
1	1.805040	4.263130
2	0.296616	1.266761
3	1.188727	0.087711
4	3.438331	1.818714
5	0.060552	0.358740
6	0.121441	0.184298
7	2.182650	0.840938

可以看到，我們得到了一個和df_0一樣長度的新dataframe，同時我們還希望A,B能成為索引，但這並沒有生效。

Talk 2：使用 pd.Grouper

pd.Grouper 比 groupby更強大、更靈活，它不僅支持普通的分組，還支持按照時間進行升採樣或降採樣分組

df_1 = pd.read_excel("dataset\sample-salesv3.xlsx")
df_1["date"] = pd.to_datetime(df_1["date"])

df_1.head()

	account number	name	sku	quantity	unit price	ext price	date
0	740150	Barton LLC	B1-20000	39	86.69	3380.91	2014-01-01 07:21:51
1	714466	Trantow-Barrows	S2-77896	-1	63.16	-63.16	2014-01-01 10:00:47
2	218895	Kulas Inc	B1-69924	23	90.70	2086.10	2014-01-01 13:24:58
3	307599	Kassulke, Ondricka and Metz	S1-65481	41	21.05	863.05	2014-01-01 15:05:22
4	412290	Jerde-Hilpert	S2-34077	6	83.21	499.26	2014-01-01 23:26:55

【例子】計算每個月的ext price總和

df_1.set_index("date").resample("M")["ext price"].sum()

date
2014-01-31    185361.66
2014-02-28    146211.62
2014-03-31    203921.38
2014-04-30    174574.11
2014-05-31    165418.55
2014-06-30    174089.33
2014-07-31    191662.11
2014-08-31    153778.59
2014-09-30    168443.17
2014-10-31    171495.32
2014-11-30    119961.22
2014-12-31    163867.26
Freq: M, Name: ext price, dtype: float64

df_1.groupby(pd.Grouper(key="date", freq="M"))["ext price"].sum()

date
2014-01-31    185361.66
2014-02-28    146211.62
2014-03-31    203921.38
2014-04-30    174574.11
2014-05-31    165418.55
2014-06-30    174089.33
2014-07-31    191662.11
2014-08-31    153778.59
2014-09-30    168443.17
2014-10-31    171495.32
2014-11-30    119961.22
2014-12-31    163867.26
Freq: M, Name: ext price, dtype: float64

兩種寫法都得到了相同的結果，並且看上去第二種寫法似乎有點兒難以理解。再看一個例子

【例子】計算每個客戶每個月的ext price總和

df_1.set_index("date").groupby("name")["ext price"].resample("M").sum().head(20)

name                             date      
Barton LLC                       2014-01-31     6177.57
                                 2014-02-28    12218.03
                                 2014-03-31     3513.53
                                 2014-04-30    11474.20
                                 2014-05-31    10220.17
                                 2014-06-30    10463.73
                                 2014-07-31     6750.48
                                 2014-08-31    17541.46
                                 2014-09-30    14053.61
                                 2014-10-31     9351.68
                                 2014-11-30     4901.14
                                 2014-12-31     2772.90
Cronin, Oberbrunner and Spencer  2014-01-31     1141.75
                                 2014-02-28    13976.26
                                 2014-03-31    11691.62
                                 2014-04-30     3685.44
                                 2014-05-31     6760.11
                                 2014-06-30     5379.67
                                 2014-07-31     6020.30
                                 2014-08-31     5399.58
Name: ext price, dtype: float64

df_1.groupby(["name", pd.Grouper(key="date",freq="M")])["ext price"].sum().head(20)

name                             date      
Barton LLC                       2014-01-31     6177.57
                                 2014-02-28    12218.03
                                 2014-03-31     3513.53
                                 2014-04-30    11474.20
                                 2014-05-31    10220.17
                                 2014-06-30    10463.73
                                 2014-07-31     6750.48
                                 2014-08-31    17541.46
                                 2014-09-30    14053.61
                                 2014-10-31     9351.68
                                 2014-11-30     4901.14
                                 2014-12-31     2772.90
Cronin, Oberbrunner and Spencer  2014-01-31     1141.75
                                 2014-02-28    13976.26
                                 2014-03-31    11691.62
                                 2014-04-30     3685.44
                                 2014-05-31     6760.11
                                 2014-06-30     5379.67
                                 2014-07-31     6020.30
                                 2014-08-31     5399.58
Name: ext price, dtype: float64

這次，第二種寫法遠比第一種寫法清爽、便於理解。這種按照特定字段和時間採樣的混合分組，請優先考慮用pd.Grouper

Talk 3: 如何訪問組

如果只是做完拆分動作，沒有做後續的apply，得到的是一個groupby對象。這裏討論下如何訪問拆分出來的組
主要方法為：

• groups
• get_group
• 迭代遍歷

df_2 = pd.DataFrame({'X': ['A', 'B', 'A', 'B'], 'Y': [1, 4, 3, 2]})
df_2

	X	Y
0	A	1
1	B	4
2	A	3
3	B	2

1. 使用 groups方法可以看到所有的組

df_2.groupby("X").groups

{'A': Int64Index([0, 2], dtype='int64'),
 'B': Int64Index([1, 3], dtype='int64')}

1. 使用get_group方法可以訪問到指定的組

df_2.groupby("X", as_index=True).get_group(name="A")

	X	Y
0	A	1
2	A	3

注意，get_group方法中，name參數只能傳遞單個str，不可以傳入list，儘管Pandas中的其他地方常常能看到這類傳參。如果是多列做主鍵的拆分，可以傳入tuple。

1. 迭代遍歷

for name, group in df_2.groupby("X"):
    print(name)
    print(group,"\n")

A
   X  Y
0  A  1
2  A  3 

B
   X  Y
1  B  4
3  B  2 

​

這裏介紹一個小技巧，如果你得到一個<pandas.core.groupby.groupby.DataFrameGroupBy object對象，想要將它還原成其原本的 dataframe ，有一個非常簡便的方法值得一提:

gropbyed_object.apply(lambda x: x)

囿於篇幅，就不對API逐個解釋了，這裏僅指出最容易忽視也最容易出錯的三個參數

參數	注意事項
level	僅作用於層次化索引的數據框時有效
as_index	僅對數據框做 agg 操作時有效，
group_keys	僅在調用 apply 時有效

Part 2: Apply 階段詳解

拆分完成后，可以對各個組做一些的操作，總體說來可以分為以下四類：

• aggregation
• apply
• transform
• filter

先總括地對比下這四類操作

1. 任何能將一個Series壓縮成一個標量值的都是agg操作，例如求和、求均值、求極值等統計計算
2. 對數據框或者groupby對象做變換，得到子集或一個新的數據框的操作是apply或transform
3. 對聚合結果按標準過濾的操作是filter

apply 和 transform有那麼一點相似，下文會重點剖析二者

Talk 4：agg VS apply

agg和apply都可以對特定列的數據傳入函數，並且依照函數進行計算。但是區別在於，agg更加靈活高效，可以一次完成操作。而apply需要輾轉多次才能完成相同操作。

df_3 = pd.DataFrame({"name":["Foo", "Bar", "Foo", "Bar"], "score":[80,80,95,70]})
df_3

	name	score
0	Foo	80
1	Bar	80
2	Foo	95
3	Bar	70

我們需要計算出每個人的總分、最高分、最低分

（1）使用apply方法

df_3.groupby("name", sort=False).score.apply(lambda x: x.sum())

name
Foo    175
Bar    150
Name: score, dtype: int64

df_3.groupby("name", sort=False).score.apply(lambda x: x.max())

name
Foo    95
Bar    80
Name: score, dtype: int64

df_3.groupby("name", sort=False).score.apply(lambda x: x.min())

name
Foo    80
Bar    70
Name: score, dtype: int64

顯然，我們輾轉操作了3次，並且還需要額外一次操作（將所得到的三個值粘合起來）

（2）使用agg方法

df_3.groupby("name", sort=False).agg({"score": [np.sum, np.max, np.min]})

	score
	sum	amax	amin
name
Foo	175	95	80
Bar	150	80	70

小結 agg一次可以對多個列獨立地調用不同的函數，而apply一次只能對多個列調用相同的一個函數。

Talk 5：transform VS agg

transform作用於數據框自身，並且返回變換后的值。返回的對象和原對象擁有相同數目的行，但可以擴展列。注意返回的對象不是就地修改了原對象，而是創建了一個新對象。也就是說原對象沒變。

df_4 = pd.DataFrame({'A': range(3), 'B': range(1, 4)})
df_4

	A	B
0	0	1
1	1	2
2	2	3

df_4.transform(lambda x: x + 1)

	A	B
0	1	2
1	2	3
2	3	4

可以對數據框先分組，然後對各組賦予一個變換，例如元素自增1。下面這個例子意義不大，可以直接做變換。

df_2.groupby("X").transform(lambda x: x + 1)

	Y
0	2
1	5
2	4
3	3

下面舉一個更實際的例子

df_5 = pd.read_csv(r"dataset\tips.csv")
df_5.head()

	total_bill	tip	sex	smoker	day	time	size
0	16.99	1.01	Female	No	Sun	Dinner	2
1	10.34	1.66	Male	No	Sun	Dinner	3
2	21.01	3.50	Male	No	Sun	Dinner	3
3	23.68	3.31	Male	No	Sun	Dinner	2
4	24.59	3.61	Female	No	Sun	Dinner	4

現在我們想知道每天，各數值列的均值
對比以下 agg 和 transform 兩種操作

df_5.groupby("day").aggregate("mean")

	total_bill	tip	size
day
Fri	17.151579	2.734737	2.105263
Sat	20.441379	2.993103	2.517241
Sun	21.410000	3.255132	2.842105
Thur	17.682742	2.771452	2.451613

df_5.groupby('day').transform(lambda x : x.mean()).total_bill.unique()

array([21.41      , 20.44137931, 17.68274194, 17.15157895])

觀察得知，兩種操作是相同的，都是對各個小組求均值。所不同的是，agg方法僅返回4行（即壓縮后的統計值），而transform返回一個和原數據框同樣長度的新數據框。

Talk 6：transform VS apply

transform 和 apply 的不同主要體現在兩方面：

1. apply 對於每個組，都是同時在所有列上面調用函數；而 transform 是對每個組，依次在每一列上調用函數
2. 由上面的工作方法決定了：apply 可以返回標量、Series、dataframe——取決於你在什麼上面調用了apply 方法；而 transform 只能返回一個類似於數組的序列，例如一維的 Series、array、list，並且最重要的是，要和原始組有同樣的長度，否則會引發錯誤。

【例子】通過打印對象的類型來對比兩種方法的工作對象

df_6 = pd.DataFrame({'State':['Texas', 'Texas', 'Florida', 'Florida'], 
                   'a':[4,5,1,3], 'b':[6,10,3,11]})
df_6

	State	a	b
0	Texas	4	6
1	Texas	5	10
2	Florida	1	3
3	Florida	3	11

def inspect(x):
    print(type(x))
    print(x)

df_6.groupby("State").apply(inspect)

<class 'pandas.core.frame.DataFrame'>
     State  a   b
2  Florida  1   3
3  Florida  3  11
<class 'pandas.core.frame.DataFrame'>
     State  a   b
2  Florida  1   3
3  Florida  3  11
<class 'pandas.core.frame.DataFrame'>
   State  a   b
0  Texas  4   6
1  Texas  5  10

從打印結果我們清晰地看到兩點：apply 每次作用的對象是一個 dataframe，其次第一個組被計算了兩次，這是因為pandas會通過這種機制來對比是否有更快的方式完成後面剩下組的計算。

df_6.groupby("State").transform(inspect)

<class 'pandas.core.series.Series'>
2    1
3    3
Name: a, dtype: int64
<class 'pandas.core.series.Series'>
2     3
3    11
Name: b, dtype: int64
<class 'pandas.core.frame.DataFrame'>
   a   b
2  1   3
3  3  11
<class 'pandas.core.series.Series'>
0    4
1    5
Name: a, dtype: int64
<class 'pandas.core.series.Series'>
0     6
1    10
Name: b, dtype: int64

從打印結果我們也清晰地看到兩點：transform每次只計算一列；會出現計算了一個組整體的情況，這有點令人費解，待研究。

從上面的對比，我們直接得到了一個有用的警示：不要傳一個同時涉及到多列的函數給transform方法，因為那麼做只會得到錯誤。例如下面的代碼所示：

def subtract(x):
    return x["a"] - x["b"]

try:
    df_6.groupby("State").transform(subtract)
except Exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[-1])

KeyError: ('a', 'occurred at index a')

另一個警示則是：在使用 transform 方法的時候，不要去試圖修改返回結果的長度，那樣不僅會引發錯誤，而且traceback的信息非常隱晦，很可能你需要花很長時間才能真正意識到錯誤所在。

def return_more(x):
    return  np.arange(3)

try:
    df_6.groupby("State").transform(return_more)
except Exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[-1])

ValueError: Length mismatch: Expected axis has 6 elements, new values have 4 elements

這個報錯信息有點彆扭，期待返回6個元素，但是返回的結果只有4個元素；其實，應該說預期的返回為4個元素，但是現在卻返回6個元素，這樣比較容易理解錯誤所在。

最後，讓我們以一條有用的經驗結束這個talk：如果你確信自己想要的操作時同時作用於多列，並且速度最好還很快，請不要用transform方法，Talk9有一個這方面的好例子。

Talk 7：agg 用法總結

（1）一次對所有列調用多個函數

df_0.groupby("A").agg([np.sum, np.mean, np.min])

	C			D
	sum	mean	amin	sum	mean	amin
A
bar	0.978077	0.244519	-1.343518	-2.042817	-0.510704	-2.064735
foo	0.184686	0.046172	-1.854274	3.113988	0.778497	0.210586

（2）一次對特定列調用多個函數

df_0.groupby("A")["C"].agg([np.sum, np.mean, np.min])

	sum	mean	amin
A
bar	0.978077	0.244519	-1.343518
foo	0.184686	0.046172	-1.854274

（3）對不同列調用不同函數

df_0.groupby("A").agg({"C": [np.sum, np.mean], "D": [np.max, np.min]})

	C		D
	sum	mean	amax	amin
A
bar	0.978077	0.244519	0.917027	-2.064735
foo	0.184686	0.046172	1.348597	0.210586

df_0.groupby("A").agg({"C": "sum", "D": "min"})

	C	D
A
bar	0.978077	-2.064735
foo	0.184686	0.210586

（4）對同一列調用不同函數，並且直接重命名

df_0.groupby("A")["C"].agg([("Largest", "max"), ("Smallest", "min")])

	Largest	Smallest
A
bar	1.477379	-1.343518
foo	1.145852	-1.854274

（5）對多個列調用同一個函數

agg_keys = {}.fromkeys(["C", "D"], "sum")
df_0.groupby("A").agg(agg_keys)

	C	D
A
bar	0.978077	-2.042817
foo	0.184686	3.113988

（6）注意agg會忽略缺失值，這在計數時需要加以注意

df_7 = pd.DataFrame({"ID":["A","A","A","B","B"], "Num": [1,np.nan, 1,1,1]})
df_7

	ID	Num
0	A	1.0
1	A	NaN
2	A	1.0
3	B	1.0
4	B	1.0

df_7.groupby("ID").agg({"Num":"count"})

	Num
ID
A	2
B	2

注意：Pandas 中的 count,sum,mean,median,std,var,min,max等函數都用C語言優化過。所以，還是那句話，如果你在大數據集上使用agg，最好使用這些函數而非從numpy那裡借用np.sum等方法，一個緩慢的程序是由每一步的緩慢積累而成的。

Talk 8：Filtration 易錯點剖析

通常，在對一個 dataframe 分組並且完成既定的操作之後，可以直接返回結果，也可以視需求對結果作一層過濾。這個過濾一般都是指 filter 操作，但是務必要理解清楚自己到底需要對組作過濾還是對組內的每一行作過濾。這個Talk就來討論過濾這個話題。

【例子】找出每門課程考試分數低於這門課程平均分的學生

df_8 = pd.DataFrame({"Subject": list(chain(*[["Math"]*3,["Computer"]*3])),
                    "Student": list(chain(*[["Chan", "Ida", "Ada"]*2])),
                    "Score": [80,90,85,90,85,95]})

df_8

	Subject	Student	Score
0	Math	Chan	80
1	Math	Ida	90
2	Math	Ada	85
3	Computer	Chan	90
4	Computer	Ida	85
5	Computer	Ada	95

這樣一個需求是否適合用 filter 來處理呢？我們試試看：

try:
    df_8.groupby("Subject").filter(lambda x: x["Score"] < x["Score"].mean())
except Exception:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[-1])

TypeError: filter function returned a Series, but expected a scalar bool

顯然不行，因為 filter 實際上做的事情是要麼留下這個組，要麼過濾掉這個組。我們在這裏弄混淆的東西，和我們初學 SQL時弄混 WHERE 和 HAVING 是一回事。就像需要記住 HAVING 是一個組內語法一樣，請記住 filter 是一個組內方法。

我們先解決這個例子，正確的做法如下:

df_8.groupby("Subject").apply(lambda g: g[g.Score < g.Score.mean()])

		Subject	Student	Score
Subject
Computer	4	Computer	Ida	85
Math	0	Math	Chan	80

而關於 filter，我們援引官方文檔上的例子作為對比

df_9 = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar',
                          'foo', 'bar'],
                    'B' : [1, 2, 3, 4, 5, 6],
                    'C' : [2.0, 5., 8., 1., 2., 9.]})
df_9

	A	B	C
0	foo	1	2.0
1	bar	2	5.0
2	foo	3	8.0
3	bar	4	1.0
4	foo	5	2.0
5	bar	6	9.0

df_9.groupby('A').filter(lambda x: x['B'].mean() > 3.)

	A	B	C
1	bar	2	5.0
3	bar	4	1.0
5	bar	6	9.0

Part 3：groupby 應用舉例

Talk 9：組內缺失值填充

df_10 = pd.DataFrame({"ID":["A","A","A","B","B","B"], "Num": [100,np.nan,300,np.nan,500,600]})
df_10

	ID	Num
0	A	100.0
1	A	NaN
2	A	300.0
3	B	NaN
4	B	500.0
5	B	600.0

df_10.groupby("ID", as_index=False).Num.transform(lambda x: x.fillna(method="ffill")).transform(lambda x: x.fillna(method="bfill"))

	Num
0	100.0
1	100.0
2	300.0
3	500.0
4	500.0
5	600.0

如果dataframe比較大（超過1GB）,transform + lambda方法會比較慢，可以用下面這個方法，速度約比上面的組合快100倍。

df_10.groupby("ID",as_index=False).ffill().groupby("ID",as_index=False).bfill()

	ID	Num
0	A	100.0
1	A	100.0
2	A	300.0
3	B	500.0
4	B	500.0
5	B	600.0

參考資料：

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

Scrapy 是一個使用 Python 語言開發，為了爬取網站數據，提取結構性數據而編寫的應用框架，它用途廣泛，比如：數據挖掘、監測和自動化測試。安裝使用終端命令 pip install Scrapy 即可。

Scrapy 比較吸引人的地方是：我們可以根據需求對其進行修改，它提供了多種類型的爬蟲基類，如：BaseSpider、sitemap 爬蟲等，新版本提供了對 web2.0 爬蟲的支持。

1 Scrapy 介紹

1.1 組成

• Scrapy Engine(引擎)：負責 Spider、ItemPipeline、Downloader、Scheduler 中間的通訊，信號、數據傳遞等。

• Scheduler(調度器)：負責接受引擎發送過來的 Request 請求，並按照一定的方式進行整理排列、入隊，當引擎需要時，交還給引擎。

• Downloader（下載器）：負責下載 Scrapy Engine(引擎) 發送的所有 Requests 請求，並將其獲取到的 Responses 交還給 Scrapy Engine(引擎)，由引擎交給 Spider 來處理。

• Spider（爬蟲）：負責處理所有 Responses，從中解析提取數據，獲取 Item 字段需要的數據，並將需要跟進的 URL 提交給引擎，再次進入 Scheduler(調度器)。

• Item Pipeline(管道)：負責處理 Spider 中獲取到的 Item，並進行後期處理，如：詳細解析、過濾、存儲等。

• Downloader Middlewares（下載中間件）：一個可以自定義擴展下載功能的組件，如：設置代理、設置請求頭等。

• Spider Middlewares（Spider 中間件）：一個可以自定擴展和操作引擎和 Spider 中間通信的功能組件，如：自定義 request 請求、過濾 response 等。

總的來說就是：Spider 和 Item Pipeline 需要我們自己實現，Downloader Middlewares 和 Spider Middlewares 我們可以根據需求自定義。

1.2 流程梳理

1）Spider 將需要發送請求的 URL 交給 Scrapy Engine 交給調度器；

2）Scrapy Engine 將請求 URL 轉給 Scheduler；

3）Scheduler 對請求進行排序整理等處理后返回給 Scrapy Engine；

4）Scrapy Engine 拿到請求后通過 Middlewares 發送給 Downloader；

5）Downloader 向互聯網發送請求，在獲取到響應后，又經過 Middlewares 發送給 Scrapy Engine。

6）Scrapy Engine 獲取到響應后，返回給 Spider，Spider 處理響應，並從中解析提取數據；

7）Spider 將解析的數據經 Scrapy Engine 交給 Item Pipeline， Item Pipeline 對數據進行後期處理；

8）提取 URL 重新經 Scrapy Engine 交給Scheduler 進行下一個循環，直到無 URL 請求結束。

1.3 Scrapy 去重機制

Scrapy 提供了對 request 的去重處理，去重類 RFPDupeFilter 在 dupefilters.py 文件中，路徑為：Python安裝目錄\Lib\site-packages\scrapy ，該類裏面有個方法 request_seen 方法，源碼如下：

def request_seen(self, request):
    # 計算 request 的指紋
    fp = self.request_fingerprint(request)
    # 判斷指紋是否已經存在
    if fp in self.fingerprints:
        # 存在
        return True
    # 不存在，加入到指紋集合中
    self.fingerprints.add(fp)
    if self.file:
        self.file.write(fp + os.linesep)

它在 Scheduler 接受請求的時候被調用，進而調用 request_fingerprint 方法（為 request 生成一個指紋），源碼如下：

def request_fingerprint(request, include_headers=None):
    if include_headers:
        include_headers = tuple(to_bytes(h.lower())
                                 for h in sorted(include_headers))
    cache = _fingerprint_cache.setdefault(request, {})
    if include_headers not in cache:
        fp = hashlib.sha1()
        fp.update(to_bytes(request.method))
        fp.update(to_bytes(canonicalize_url(request.url)))
        fp.update(request.body or b'')
        if include_headers:
            for hdr in include_headers:
                if hdr in request.headers:
                    fp.update(hdr)
                    for v in request.headers.getlist(hdr):
                        fp.update(v)
        cache[include_headers] = fp.hexdigest()
    return cache[include_headers]

在上面代碼中我們可以看到

fp = hashlib.sha1()
...
cache[include_headers] = fp.hexdigest()

它為每一個傳遞過來的 URL 生成一個固定長度的唯一的哈希值。再看一下 __init__ 方法，源碼如下：

def __init__(self, path=None, debug=False):
    self.file = None
    self.fingerprints = set()
    self.logdupes = True
    self.debug = debug
    self.logger = logging.getLogger(__name__)
    if path:
        self.file = open(os.path.join(path, 'requests.seen'), 'a+')
        self.file.seek(0)
        self.fingerprints.update(x.rstrip() for x in self.file)

我們可以看到裏面有 self.fingerprints = set() 這段代碼，就是通過 set 集合的特點（set 不允許有重複值）進行去重。

去重通過 dont_filter 參數設置，如圖所示

dont_filter 為 False 開啟去重，為 True 不去重。

2 實現過程

製作 Scrapy 爬蟲需如下四步：

• 創建項目 ：創建一個爬蟲項目
• 明確目標 ：明確你想要抓取的目標（編寫 items.py）
• 製作爬蟲 ：製作爬蟲開始爬取網頁（編寫 xxspider.py）
• 存儲內容 ：設計管道存儲爬取內容（編寫pipelines.py）

我們以爬取去哪兒網北京景區信息為例，如圖所示：

2.1 創建項目

在我們需要新建項目的目錄，使用終端命令 scrapy startproject 項目名 創建項目，我創建的目錄結構如圖所示：

• spiders 存放爬蟲的文件
• items.py 定義數據類型
• middleware.py 存放中間件
• piplines.py 存放數據的有關操作
• settings.py 配置文件
• scrapy.cfg 總的控制文件

2.2 定義 Item

Item 是保存爬取數據的容器，使用的方法和字典差不多。我們計劃提取的信息包括：area（區域）、sight（景點）、level（等級）、price（價格），在 items.py 定義信息，源碼如下：

import scrapy

class TicketspiderItem(scrapy.Item):
    area = scrapy.Field()
    sight = scrapy.Field()
    level = scrapy.Field()
    price = scrapy.Field()
    pass

2.3 爬蟲實現

在 spiders 目錄下使用終端命令 scrapy genspider 文件名 要爬取的網址 創建爬蟲文件，然後對其修改及編寫爬取的具體實現，源碼如下：

import scrapy
from ticketSpider.items import TicketspiderItem

class QunarSpider(scrapy.Spider):
    name = 'qunar'
    allowed_domains = ['piao.qunar.com']
    start_urls = ['https://piao.qunar.com/ticket/list.htm?keyword=%E5%8C%97%E4%BA%AC&region=&from=mpl_search_suggest']

    def parse(self, response):
        sight_items = response.css('#search-list .sight_item')
        for sight_item in sight_items:
            item = TicketspiderItem()
            item['area'] = sight_item.css('::attr(data-districts)').extract_first()
            item['sight'] = sight_item.css('::attr(data-sight-name)').extract_first()
            item['level'] = sight_item.css('.level::text').extract_first()
            item['price'] = sight_item.css('.sight_item_price em::text').extract_first()
            yield item
        # 翻頁
        next_url = response.css('.next::attr(href)').extract_first()
        if next_url:
            next_url = "https://piao.qunar.com" + next_url
            yield scrapy.Request(
                next_url,
                callback=self.parse
            )

簡單介紹一下：

• name：爬蟲名
• allowed_domains：允許爬取的域名
• atart_urls：爬取網站初始請求的 url（可定義多個）
• parse 方法：解析網頁的方法
• response 參數：請求網頁后返回的內容

yield

在上面的代碼中我們看到有個 yield，簡單說一下，yield 是一個關鍵字，作用和 return 差不多，差別在於 yield 返回的是一個生成器（在 Python 中，一邊循環一邊計算的機制，稱為生成器），它的作用是：有利於減小服務器資源，在列表中所有數據存入內存，而生成器相當於一種方法而不是具體的信息，佔用內存小。

爬蟲偽裝

通常需要對爬蟲進行一些偽裝，關於爬蟲偽裝可通過【】做一下簡單了解，這裏我們使用一個最簡單的方法處理一下。

• 使用終端命令 pip install scrapy-fake-useragent 安裝
• 在 settings.py 文件中添加如下代碼：

DOWNLOADER_MIDDLEWARES = {
    # 關閉默認方法
    'scrapy.downloadermiddlewares.useragent.UserAgentMiddleware': None, 
    # 開啟
    'scrapy_fake_useragent.middleware.RandomUserAgentMiddleware': 400, 
}

2.4 保存數據

我們將數據保存到本地的 csv 文件中，csv 具體操作可以參考：，下面看一下具體實現。

首先，在 pipelines.py 中編寫實現，源碼如下：

import csv

class TicketspiderPipeline(object):
    def __init__(self):
        self.f = open('ticker.csv', 'w', encoding='utf-8', newline='')
        self.fieldnames = ['area', 'sight', 'level', 'price']
        self.writer = csv.DictWriter(self.f, fieldnames=self.fieldnames)
        self.writer.writeheader()
    def process_item(self, item, spider):
        self.writer.writerow(item)
        return item

    def close(self, spider):
        self.f.close()

然後，將 settings.py 文件中如下代碼：

ITEM_PIPELINES = {
    'ticketSpider.pipelines.TicketspiderPipeline': 300,
}

放開即可。

2.5 運行

我們在 settings.py 的同級目錄下創建運行文件，名字自定義，放入如下代碼：

from scrapy.cmdline import execute
execute('scrapy crawl 爬蟲名'.split())

這個爬蟲名就是我們之前在爬蟲文件中的 name 屬性值，最後在 Pycharm 運行該文件即可。

參考：

完整代碼請關注文末公眾號，後台回復 qs 獲取。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想要讓你的商品成為最夯、最多人討論的話題?網頁設計公司讓你強力曝光

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!