資料基礎---《利用Python進行資料分析·第2版》第12章 pandas高階應用
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
前面的章節關注於不同型別的資料規整流程和NumPy、pandas與其它庫的特點。隨著時間的發展，pandas發展出了更多適合高階使用者的功能。本章就要深入學習pandas的高階功能。
12.1 分類資料
這一節介紹的是pandas的分類型別。我會向你展示通過使用它，提高效能和記憶體的使用率。我還會介紹一些在統計和機器學習中使用分類資料的工具。
背景和目的
表中的一列通常會有重複的包含不同值的小集合的情況。我們已經學過了unique和value_counts，它們可以從陣列提取出不同的值，並分別計算頻率：
import numpy as np; import pandas as pd
values = pd.Series(['apple', 'orange', 'apple','apple'] * 2)
values
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
dtype: object
pd.unique(values)
array(['apple', 'orange'], dtype=object)
pd.value_counts( apple 6
orange 2
dtype: int64
許多資料系統（資料倉庫、統計計算或其它應用）都發展出了特定的表徵重複值的方法，以進行高效的儲存和計算。在資料倉庫中，最好的方法是使用所謂的包含不同值的維表(Dimension Table)，將主要的引數儲存為引用維表整數鍵：
values = pd.Series([0, 1, 0, 0] * 2)
dim = pd.Series(['apple', 'orange'])
values
0 0 1 1 2 0 3 0 4 0 5 1 6 0 7 0 dtype: int64
dim
0 apple
1 orange
dtype: object
可以使用take方法儲存原始的字串Series：
dim.take(values)
0 apple
1 orange
0 apple
0 apple
0 apple
1 orange
0 apple
0 apple
dtype: object
這種用整數表示的方法稱為分類或字典編碼表示法。不同值得陣列稱為分類、字典或資料級。本書中，我們使用分類的說法。表示分類的整數值稱為分類編碼或簡單地稱為編碼。
分類表示可以在進行分析時大大的提高效能。你也可以在保持編碼不變的情況下，對分類進行轉換。一些相對簡單的轉變例子包括：
- 重新命名分類。
- 加入一個新的分類，不改變已經存在的分類的順序或位置。
pandas的分類型別
pandas有一個特殊的分類型別，用於儲存使用整數分類表示法的資料。看一個之前的Series例子：
fruits = ['apple', 'orange', 'apple', 'apple'] * 2
N = len(fruits)
df = pd.DataFrame({'fruit': fruits,'basket_id': np.arange(N),'count': np.random.randint(3, 15, size=N), 'weight': np.random.uniform(0, 4, size=N)},columns=['basket_id', 'fruit', 'count', 'weight'])
df
| basket_id | fruit | count | weight | |
|---|---|---|---|---|
| 0 | 0 | apple | 10 | 2.174428 |
| 1 | 1 | orange | 7 | 3.436793 |
| 2 | 2 | apple | 7 | 0.437228 |
| 3 | 3 | apple | 4 | 2.938516 |
| 4 | 4 | apple | 11 | 2.126538 |
| 5 | 5 | orange | 13 | 1.604507 |
| 6 | 6 | apple | 3 | 1.583122 |
| 7 | 7 | apple | 3 | 2.351318 |
這裡，df[‘fruit’]是一個Python字串物件的陣列。我們可以通過呼叫它，將它轉變為分類：
fruit_cat = df['fruit'].astype('category')
fruit_cat
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]
fruit_cat的值不是NumPy陣列，而是一個pandas.Categorical例項：
c = fruit_cat.values
c
[apple, orange, apple, apple, apple, orange, apple, apple]
Categories (2, object): [apple, orange]
type(c)
pandas.core.arrays.categorical.Categorical
分類物件有categories和codes屬性：
c.categories
Index(['apple', 'orange'], dtype='object')
c.codes
array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)
你可將DataFrame的列通過分配轉換結果，轉換為分類：
df['fruit'] = df['fruit'].astype('category')
df.fruit
0 apple
1 orange
2 apple
3 apple
4 apple
5 orange
6 apple
7 apple
Name: fruit, dtype: category
Categories (2, object): [apple, orange]
你還可以從其它Python序列直接建立pandas.Categorical：
my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
my_categories
[foo, bar, baz, foo, bar]
Categories (3, object): [bar, baz, foo]
如果你已經從其它源獲得了分類編碼，你還可以使用from_codes構造器：
categories = ['foo', 'bar', 'baz']
codes = [0, 1, 2, 0, 0, 1]
my_cats_2 =pd.Categorical.from_codes(codes,categories)
my_cats_2
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo, bar, baz]
#跟take()實現了相似的目的
pd.Series(categories).take(pd.Series(codes))
0 foo
1 bar
2 baz
0 foo
0 foo
1 bar
dtype: object
與顯示指定不同，分類變換不認定指定的分類順序。因此取決於輸入資料的順序，categories陣列的順序會不同。當使用from_codes或其它的構造器時，你可以指定分類一個有意義的順序：
ordered_cat=pd.Categorical.from_codes(codes,categories,ordered=True)
ordered_cat
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo < bar < baz]
輸出[foo < bar < baz]指明‘foo’位於‘bar’的前面，以此類推。無序的分類例項可以通過as_ordered排序：
my_cats_2.as_ordered()
[foo, bar, baz, foo, foo, bar]
Categories (3, object): [foo < bar < baz]
最後要注意，分類資料不需要字串，儘管我僅僅展示了字串的例子。分類陣列可以包括任意不可變型別。
用分類進行計算
與非編碼版本（比如字串陣列）相比，使用pandas的Categorical有些類似。某些pandas元件，比如groupby函式，更適合進行分類。還有一些函式可以使用有序標誌位。
來看一些隨機的數值資料，使用pandas.qcut面元函式。它會返回pandas.Categorical，我們之前使用過pandas.cut，但沒解釋分類是如何工作的：
np.random.seed(12345)
draws = np.random.randn(1000)
draws[:5]
array([-0.20470766, 0.47894334, -0.51943872, -0.5557303 , 1.96578057])
計算這個資料的分位面元，提取一些統計資訊：
bins = pd.qcut(draws,4)
bins
[(-0.684, -0.0101], (-0.0101, 0.63], (-0.684, -0.0101], (-0.684, -0.0101], (0.63, 3.928], ..., (-0.0101, 0.63], (-0.684, -0.0101], (-2.9499999999999997, -0.684], (-0.0101, 0.63], (0.63, 3.928]]
Length: 1000
Categories (4, interval[float64]): [(-2.9499999999999997, -0.684] < (-0.684, -0.0101] < (-0.0101, 0.63] < (0.63, 3.928]]
雖然有用，確切的樣本分位數與分位的名稱相比，不利於生成彙總。我們可以使用labels引數qcut，實現目的：
bins=pd.qcut(draws,4,labels=['Q1', 'Q2', 'Q3', 'Q4'])
bins
[Q2, Q3, Q2, Q2, Q4, ..., Q3, Q2, Q1, Q3, Q4]
Length: 1000
Categories (4, object): [Q1 < Q2 < Q3 < Q4]
bins.codes[:10]
array([1, 2, 1, 1, 3, 3, 2, 2, 3, 3], dtype=int8)
加上標籤的面元分類不包含資料面元邊界的資訊，因此可以使用groupby提取一些彙總資訊：
bins=pd.Series(bins,name='quartile')
results=pd.Series(draws).groupby(bins).agg(['count','min','max'])
results
| count | min | max | |
|---|---|---|---|
| quartile | |||
| Q1 | 250 | -2.949343 | -0.685484 |
| Q2 | 250 | -0.683066 | -0.010115 |
| Q3 | 250 | -0.010032 | 0.628894 |
| Q4 | 250 | 0.634238 | 3.927528 |
results=results.reset_index()
results
| quartile | count | min | max | |
|---|---|---|---|---|
| 0 | Q1 | 250 | -2.949343 | -0.685484 |
| 1 | Q2 | 250 | -0.683066 | -0.010115 |
| 2 | Q3 | 250 | -0.010032 | 0.628894 |
| 3 | Q4 | 250 | 0.634238 | 3.927528 |
分位數列儲存了原始的面元分類資訊，包括排序：
results.quartile
0 Q1
1 Q2
2 Q3
3 Q4
Name: quartile, dtype: category
Categories (4, object): [Q1 < Q2 < Q3 < Q4]
用分類提高效能
如果你是在一個特定資料集上做大量分析，將其轉換為分類可以極大地提高效率。DataFrame列的分類使用的記憶體通常少的多。來看一些包含一千萬元素的Series，和一些不同的分類：
N = 10000000
draws = pd.Series(np.random.randn(N))
labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4))
現在，將標籤轉換為分類：
categories = labels.astype('category')
這時，可以看到標籤使用的記憶體遠比分類多：
labels.memory_usage()
80000080
categories.memory_usage()
10000272
轉換為分類不是沒有代價的，但這是一次性的代價：
%time _ = labels.astype('category')
Wall time: 439 ms
GroupBy使用分類操作明顯更快，是因為底層的演算法使用整數編碼陣列，而不是字串陣列。
分類方法
包含分類資料的Series有一些特殊的方法，類似於Series.str字串方法。它還提供了方便的分類和編碼的使用方法。看下面的Series：
s=pd.Series(['a', 'b', 'c', 'd']*2)
cat_s=s.astype('category')
cat_s
0 a
1 b
2 c
3 d
4 a
5 b
6 c
7 d
dtype: category
Categories (4, object): [a, b, c, d]
特別的cat屬性提供了分類方法的入口：
cat_s.cat.codes
0 0
1 1
2 2
3 3
4 0
5 1
6 2
7 3
dtype: int8
cat_s.cat.categories
Index(['a', 'b', 'c', 'd'], dtype='object')
假設我們知道這個資料的實際分類集，超出了資料中的四個值。我們可以使用set_categories方法改變它們：
actual_categories = ['a', 'b', 'c', 'd', 'e']
cat_s2 = cat_s.cat.set_categories(actual_categories)
cat_s2
0 a
1 b
2 c
3 d
4 a
5 b
6 c
7 d
dtype: category
Categories (5, object): [a, b, c, d, e]
雖然資料看起來沒變，新的分類將反映在它們的操作中。例如，如果有的話，value_counts表示分類：
cat_s.value_counts()
d 2
c 2
b 2
a 2
dtype: int64
cat_s2.value_counts()
d 2
c 2
b 2
a 2
e 0
dtype: int64
在大資料集中，分類經常作為節省記憶體和高效能的便捷工具。過濾完大DataFrame或Series之後，許多分類可能不會出現在資料中。我們可以使用remove_unused_categories方法刪除沒看到的分類：
cat_s.isin(['a','b'])
0 True
1 True
2 False
3 False
4 True
5 True
6 False
7 False
dtype: bool
cat_s3 = cat_s[cat_s.isin(['a','b'])]
cat_s3
0 a
1 b
4 a
5 b
dtype: category
Categories (4, object): [a, b, c, d]
cat_s3.cat.remove_unused_categories()
0 a
1 b
4 a
5 b
dtype: category
Categories (2, object): [a, b]
表12-1列出了可用的分類方法。
為建模建立虛擬變數
當你使用統計或機器學習工具時，通常會將分類資料轉換為虛擬變數，也稱為one-hot編碼。這包括建立一個不同類別的列的DataFrame；這些列包含給定分類的1s，其它為0。
看前面的例子：
cat_s=pd.Series(['a', 'b', 'c', 'd'] * 2,dtype='category')
pd.get_dummies(cat_s)
| a | b | c | d | |
|---|---|---|---|---|
| 0 | 1 | 0 | 0 | 0 |
| 1 | 0 | 1 | 0 | 0 |
| 2 | 0 | 0 | 1 | 0 |
| 3 | 0 | 0 | 0 | 1 |
| 4 | 1 | 0 | 0 | 0 |
| 5 | 0 | 1 | 0 | 0 |
| 6 | 0 | 0 | 1 | 0 |
| 7 | 0 | 0 | 0 | 1 |
12.2 GroupBy高階應用
儘管我們在第10章已經深度學習了Series和DataFrame的Groupby方法，還有一些方法也是很有用的。
分組轉換和“解封”GroupBy
在第10章，我們在分組操作中學習了apply方法，進行轉換。還有另一個transform方法，它與apply很像，但是對使用的函式有一定限制：
- 它可以產生向分組形狀廣播標量值
- 它可以產生一個和輸入組形狀相同的物件
- 它不能修改輸入
來看一個簡單的例子：
df = pd.DataFrame({'key': ['a', 'b', 'c'] * 4, 'value': np.arange(12.)})
df
| key | value | |
|---|---|---|
| 0 | a | 0.0 |
| 1 | b | 1.0 |
| 2 | c | 2.0 |
| 3 | a | 3.0 |
| 4 | b | 4.0 |
| 5 | c | 5.0 |
| 6 | a | 6.0 |
| 7 | b | 7.0 |
| 8 | c | 8.0 |
| 9 | a | 9.0 |
| 10 | b | 10.0 |
| 11 | c | 11.0 |
按鍵進行分組：
g=df.groupby('key').value
g.mean()
key
a 4.5
b 5.5
c 6.5
Name: value, dtype: float64
假設我們想產生一個和df[‘value’]形狀相同的Series，但值替換為按鍵分組的平均值。我們可以傳遞函式lambda x: x.mean()進行轉換：
g.transform(lambda x:x.mean())
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
對於內建的聚合函式，我們可以傳遞一個字串假名作為GroupBy的agg方法：
g.transform('mean')
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
與apply類似，transform的函式會返回Series，但是結果必須與輸入大小相同。舉個例子，我們可以用lambda函式將每個分組乘以2：
g.transform(lambda x:x*2)
0 0.0
1 2.0
2 4.0
3 6.0
4 8.0
5 10.0
6 12.0
7 14.0
8 16.0
9 18.0
10 20.0
11 22.0
Name: value, dtype: float64
再舉一個複雜的例子，我們可以計算每個分組的降序排名：
g.transform(lambda x:x.rank(ascending=False))
0 4.0
1 4.0
2 4.0
3 3.0
4 3.0
5 3.0
6 2.0
7 2.0
8 2.0
9 1.0
10 1.0
11 1.0
Name: value, dtype: float64
看一個由簡單聚合構造的的分組轉換函式：
def normalize(x):
return (x-x.mean())/x.std()
我們用transform或apply可以獲得等價的結果：
g.transform(normalize)
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
g.apply(normalize)
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
內建的聚合函式，比如mean或sum，通常比apply函式快，也比transform快。這允許我們進行一個所謂的解封（unwrapped）分組操作：意思是儘量用內建的函式，而不要自己去定義函式
g.transform('mean')
0 4.5
1 5.5
2 6.5
3 4.5
4 5.5
5 6.5
6 4.5
7 5.5
8 6.5
9 4.5
10 5.5
11 6.5
Name: value, dtype: float64
normalized = (df['value']-g.transform('mean'))/g.transform('std')
normalized
0 -1.161895
1 -1.161895
2 -1.161895
3 -0.387298
4 -0.387298
5 -0.387298
6 0.387298
7 0.387298
8 0.387298
9 1.161895
10 1.161895
11 1.161895
Name: value, dtype: float64
解封分組操作可能包括多個分組聚合，但是向量化操作還是會帶來收益。
分組的時間重取樣
對於時間序列資料，resample方法從語義上是一個基於內在時間的分組操作。下面是一個示例表：
N = 15
times=pd.date_range('2017-05-20 00:00',periods=N,freq='1min')
df=pd.DataFrame({'times':times,'value':np.arange(N)})
df
| times | value | |
|---|---|---|
| 0 | 2017-05-20 00:00:00 | 0 |
| 1 | 2017-05-20 00:01:00 | 1 |
| 2 | 2017-05-20 00:02:00 | 2 |
| 3 | 2017-05-20 00:03:00 | 3 |
| 4 | 2017-05-20 00:04:00 | 4 |
| 5 | 2017-05-20 00:05:00 | 5 |
| 6 | 2017-05-20 00:06:00 | 6 |
| 7 | 2017-05-20 00:07:00 | 7 |
| 8 | 2017-05-20 00:08:00 | 8 |
| 9 | 2017-05-20 00:09:00 | 9 |
| 10 | 2017-05-20 00:10:00 | 10 |
| 11 | 2017-05-20 00:11:00 | 11 |
| 12 | 2017-05-20 00:12:00 | 12 |
| 13 | 2017-05-20 00:13:00 | 13 |
| 14 | 2017-05-20 00:14:00 | 14 |
這裡，我們可以用time作為索引，然後重取樣：
df.set_index('times').resample('5min').asfreq()
| value | |
|---|---|
| times | |
| 2017-05-20 00:00:00 | 0 |
| 2017-05-20 00:05:00 | 5 |
| 2017-05-20 00:10:00 | 10 |
df.set_index('times').resample('5min').count()
| value | |
|---|---|
| times | |
| 2017-05-20 00:00:00 | 5 |
| 2017-05-20 00:05:00 | 5 |
| 2017-05-20 00:10:00 | 5 |
假設DataFrame包含多個時間序列，用一個額外的分組鍵的列進行標記：
df2 = pd.DataFrame({'time': times.repeat(3),'key': np.tile(['a', 'b', 'c'], N),'value': np.arange(N * 3.)})
df2[:5]
| key | time | value | |
|---|---|---|---|
| 0 | a | 2017-05-20 00:00:00 | 0.0 |
| 1 | b | 2017-05-20 00:00:00 | 1.0 |
| 2 | c | 2017-05-20 00:00:00 | 2.0 |
| 3 | a | 2017-05-20 00:01:00 | 3.0 |
| 4 | b | 2017-05-20 00:01:00 | 4.0 |
要對每個key值進行相同的重取樣，我們引入pandas.TimeGrouper物件：
time_key = pd.TimeGrouper('5min')
c:\users\qingt\miniconda2\envs\python35\lib\site-packages\ipykernel_launcher.py:1: FutureWarning: pd.TimeGrouper is deprecated and will be removed; Please use pd.Grouper(freq=...)
"""Entry point for launching an IPython kernel.
我們然後設定時間索引，用key和time_key分組，然後聚合：
resampled =(df2.set_index('time').groupby(['key',time_key]).sum())
resampled
| value | ||
|---|---|---|
| key | time | |
| a | 2017-05-20 00:00:00 | 30.0 |
| 2017-05-20 00:05:00 | 105.0 | |
| 2017-05-20 00:10:00 | 180.0 | |
| b | 2017-05-20 00:00:00 | 35.0 |
| 2017-05-20 00:05:00 | 110.0 | |
| 2017-05-20 00:10:00 | 185.0 | |
| c | 2017-05-20 00:00:00 | 40.0 |
| 2017-05-20 00:05:00 | 115.0 | |
| 2017-05-20 00:10:00 | 190.0 |
resampled.reset_index()
| key | time | value | |
|---|---|---|---|
| 0 | a | 2017-05-20 00:00:00 | 30.0 |
| 1 | a | 2017-05-20 00:05:00 | 105.0 |
| 2 | a | 2017-05-20 00:10:00 | 180.0 |
| 3 | b | 2017-05-20 00:00:00 | 35.0 |
| 4 | b | 2017-05-20 00:05:00 | 110.0 |
| 5 | b | 2017-05-20 00:10:00 | 185.0 |
| 6 | c | 2017-05-20 00:00:00 | 40.0 |
| 7 | c | 2017-05-20 00:05:00 | 115.0 |
| 8 | c | 2017-05-20 00:10:00 | 190.0 |
使用TimeGrouper的限制是時間必須是Series或DataFrame的索引。
12.3 鏈式程式設計技術
當對資料集進行一系列變換時，你可能發現建立的多個臨時變數其實並沒有在分析中用到。看下面的例子：
df = load_data()
df2 = df[df['col2'] < 0]
df2['col1_demeaned'] = df2['col1'] - df2['col1'].mean()
result = df2.groupby('key').col1_demeaned.std()
雖然這裡沒有使用真實的資料，這個例子卻指出了一些新方法。首先，DataFrame.assign方法是一個df[k] = v形式的函式式的列分配方法。它不是就地修改物件，而是返回新的修改過的DataFrame。因此，下面的語句是等價的：
# Usual non-functional way
df2 = df.copy()
df2['k'] = v
# Functional assign way
df2 = df.assign(k=v)
就地分配可能會比assign快，但是assign可以方便地進行鏈式程式設計：
result = (df2.assign(col1_demeaned=df2.col1 - df2.col2.mean())
.groupby('key')
.col1_demeaned.std())
我使用外括號，這樣便於新增換行符。
使用鏈式程式設計時要注意，你可能會需要涉及臨時物件。在前面的例子中，我們不能使用load_data的結果，直到它被賦值給臨時變數df。為了這麼做，assign和許多其它pandas函式可以接收類似函式的引數，即可呼叫物件（callable）。為了展示可呼叫物件，看一個前面例子的片段：
df = load_data()
df2 = df[df['col2'] < 0]
它可以重寫為：
df = (load_data()
[lambda x: x['col2'] < 0])
這裡，load_data的結果沒有賦值給某個變數，因此傳遞到[ ]的函式在這一步被繫結到了物件。
我們可以把整個過程寫為一個單鏈表示式：
result = (load_data()
[lambda x: x.col2 < 0]
.assign(col1_demeaned=lambda x: x.col1 - x.col1.mean())
.groupby('key')
.col1_demeaned.std())
是否將程式碼寫成這種形式只是習慣而已，將它分開成若干步可以提高可讀性。
管道方法
你可以用Python內建的pandas函式和方法，用帶有可呼叫物件的鏈式程式設計做許多工作。但是，有時你需要使用自己的函式，或是第三方庫的函式。這時就要用到管道方法。
看下面的函式呼叫：
a = f(df, arg1=v1)
b = g(a, v2, arg3=v3)
c = h(b, arg4=v4)
當使用接收、返回Series或DataFrame物件的函式式，你可以呼叫pipe將其重寫：
result = (df.pipe(f, arg1=v1)
.pipe(g, v2, arg3=v3)
.pipe(h, arg4=v4))
f(df)和df.pipe(f)是等價的，但是pipe使得鏈式宣告更容易。
pipe的另一個有用的地方是提煉操作為可複用的函式。看一個從列減去分組方法的例子：
g = df.groupby(['key1', 'key2'])
df['col1'] = df['col1'] - g.transform('mean')
假設你想轉換多列，並修改分組的鍵。另外，你想用鏈式程式設計做這個轉換。下面就是一個方法：
def group_demean(df, by, cols):
result = df.copy()
g = df.groupby(by)
for c in cols:
result
相關推薦
資料基礎---《利用Python進行資料分析·第2版》第12章 pandas高階應用
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
前面的章節關注於不同型別的資料規整流程和NumPy、pandas與其它庫的特點。隨著時間的發展，pandas發展出了更多適
資料基礎---《利用Python進行資料分析·第2版》第6章 資料載入、儲存與檔案格式
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
訪問資料是使用本書所介紹的這些工具的第一步。我會著重介紹pandas的資料輸入與輸出，雖然別的庫中也有不少以此為目的的工具
資料基礎---《利用Python進行資料分析·第2版》第4章 NumPy基礎：陣列和向量計算
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
NumPy（Numerical Python的簡稱）是Python數值計算最重要的基礎包。大多數提供科學計算的包都是用Nu
資料基礎---《利用Python進行資料分析·第2版》第11章 時間序列
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
時間序列（time series）資料是一種重要的結構化資料形式，應用於多個領域，包括金融學、經濟學、生態學、神經科學、物
資料基礎---《利用Python進行資料分析·第2版》第10章 資料聚合與分組運算
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
對資料集進行分組並對各組應用一個函式（無論是聚合還是轉換），通常是資料分析工作中的重要環節。在將資料集載入、融合、準備好之
資料基礎---《利用Python進行資料分析·第2版》第8章 資料規整：聚合、合併和重塑
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
在許多應用中，資料可能分散在許多檔案或資料庫中，儲存的形式也不利於分析。本章關注可以聚合、合併、重塑資料的方法。
首先
資料基礎---《利用Python進行資料分析·第2版》第7章 資料清洗和準備
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
在資料分析和建模的過程中，相當多的時間要用在資料準備上：載入、清理、轉換以及重塑。這些工作會佔到分析師時間的80%或更多。
資料基礎---《利用Python進行資料分析·第2版》第5章 pandas入門
之前自己對於numpy和pandas是要用的時候東學一點西一點，直到看到《利用Python進行資料分析·第2版》，覺得只看這一篇就夠了。非常感謝原博主的翻譯和分享。
pandas是本書後續內容的首選庫。它含有使資料清洗和分析工作變得更快更簡單的資料結構和操作工具。pandas經常和其它工
利用Python進行資料分析之第七章 記錄2 資料規整化:清理、轉換、合併、重塑
索引上的合併
DataFrame中傳入引數left_index=True或者right_index=True（或者兩個都傳入）,表示DataFrame的index（索引）被用作兩個DataFrame連線的連線鍵，如下：
dataframe1 = DataFrame({'key':
利用Python進行資料分析之第七章記錄 資料規整化:清理、轉換、合併、重塑
合併資料集：
pandas物件中的資料可以通過一些內建的方式進行合併：
pandas.merge可根據一個或多個鍵將不同DataFrame中的行連線起來。SQL或其它關係型資料庫的使用者對此應該會比較熟悉，因為它實現的就是資料庫的連線操作。
pandas.concat可以沿著一條軸將多個
➢《利用Python進行資料分析》（原書第2版）｜書籍分享
《利用Python進行資料分析》（原書第2版）
英： Python for Data Analysis: Data Wrangling with Pand
適讀人群 ：適合剛學Python的資料分析師或剛學資料科學以及科學計算的Python程式設計者。
閱
【利用python進行資料分析——基礎篇】利用Python處理和分析Excel表中資料實戰
作為一個學習用Python進行資料分析的新手來說，通過本文來記錄分享一些我在用Python中的pandas、numpy來分析Excel表中資料的資料清洗和整理的工作，目的是熟悉numpy以及pandas基礎操作，所有操作利用Excel均可以方便實現。備註：本文中使用的是ipy
2018最新Python資料分析實戰教程視訊 python資料分析班視訊 Python資料分析基礎教程 利用Python進行資料分析
系列一：《python資料分析基礎與實踐》章節1Python概況課時2Python簡介章節2Python安裝課時3安裝Anaconda課時4使用Anaconda章節3資料準備課時5資料型別 – 布林型課時6資料型別 – 數值型課時7資料型別 – 字元型課時8資料結構 – List課時9資料結構 – Tuple
初入資料分析2（《利用Python進行資料分析·第2版》筆記）
初入資料分析2
遍歷
seq=[(1,2,3),(4,5,6),(7,8,9)]
for a,b,c in seq:
print("a==",a,"b==",b,"c==",c)
a== 1 b== 2 c== 3
a== 4 b== 5 c== 6
a==
Numpy基礎 --陣列和向量計算 利用Python進行資料分析讀書筆記
Numpy 陣列和向量計算
程式碼下載
import numpy as np
#ndarray物件 陣列 NumPy陣列
建立ndarray
data1=[6,7.5,8,0,1]
arr1=np.array(data1)
a
利用Python進行資料分析(15) pandas基礎: 字串操作
字串物件方法
split()方法拆分字串：
strip()方法去掉空白符和換行符：
split()結合strip()使用：
"+"符號可以將多個字串連線起來：
join()方法也是連線字串，比較它和"+"符號的區別：
in關鍵字判斷一個字串是否包含在另一個字串中：
index()方法
資料集合與分組運算 《利用python進行資料分析》筆記，第9章
pandas的groupby功能，可以計算 分組統計和生成透視表，可對資料集進行靈活的切片、切塊、摘要等操作
GroupBy技術
“split-apply-comebine”（拆分-應用-合併）
import numpy as np
from pand
《利用python進行資料分析》 第10章 時間序列
第十章、時間序列
時間戳timestamp：特定的時刻
固定時期period：2017年1月或2017年全年
時間間隔interval：時期是間隔的特例
實驗或過程時間：每一個時間點都是對特定起始實踐的一個獨立那個。例如，從放入烤箱起，每秒鐘餅乾的直徑。
1
《利用python進行資料分析.第三版》 第七章 資料清洗和準備
7.1 處理缺失資料
缺失資料在pandas中呈現的方式有些不完美，但對於大多數使用者可以保證功能正常。對於數值資料，pandas使用浮點值NaN（Not a Number）表示缺失資料。我們稱其為哨兵值，可以方便的檢測出來。
處理缺失資料有以下幾個方
《利用Python進行資料分析》第7章 合併資料集
合併資料集
資料分析和建模方面的大量程式設計工作都是用在資料準備上的：載入、清理、轉換以及重塑。有時候，存放在檔案或資料庫中的資料並不能滿足你的資料處理應用的要求。pandas物件中的資料可以通過一些內建的方式進行合併：
pandas.merge可根據一個或