序言：
????Pandas第三部分
【課程2.13】 數(shù)值計(jì)算和統(tǒng)計(jì)基礎(chǔ)
????常用數(shù)學(xué)、統(tǒng)計(jì)方法
基本參數(shù)：axis、skipna
# 基本參數(shù)：axis、skipna
import numpy as np
import pandas as pd
df = pd.DataFrame({"key1": [4,5,3,np.nan,2],
"key2": [1,2,np.nan,4,5],
"key3": [1,2,3,"j","k"]},
index = list("abcde"))
print(df)
print(df["key1"].dtype, df["key2"].dtype, df["key3"].dtype)
print("--------")
m1 = df.mean()
print(m1, type(m1))
print("單獨(dú)統(tǒng)計(jì)一列：", df["key2"].mean())
print("------")
# np.nan：空直
# .mean()計(jì)算均值
# 只統(tǒng)計(jì)數(shù)字列
# 可以通過索引單獨(dú)統(tǒng)計(jì)一列
m2 = df.mean(axis = 1)
print(m2)
print("------------")
# axis參數(shù)：默認(rèn)為0，以列來計(jì)算，axis=1,以行來計(jì)算，這里就按照行來匯總了
m3 = df.mean(skipna=False)
print(m3)
print("----------")
# skipna參數(shù)：是否忽略NaN，默認(rèn)True，例如False，有Nan的列統(tǒng)計(jì)結(jié)果仍為NaN
主要數(shù)學(xué)計(jì)算方法，可用于Series和DataFrame (1)
# 主要數(shù)學(xué)計(jì)算方法，可用于Series和DataFrame (1)
df = pd.DataFrame({"key1": np.arange(10),
"key2": np.random.rand(10)*10})
print(df)
print("------------")
print(df.count(), "→ count統(tǒng)計(jì)非Na值的數(shù)量\n")
print(df.min(), '→ min統(tǒng)計(jì)最小值\n', df["key2"].max(), '→ max統(tǒng)計(jì)最大值\n')
print(df.quantile(q=0.75),'→ quantile統(tǒng)計(jì)分位數(shù)，參數(shù)q確定位置\n')
print(df.sum(),'→ sum求和\n')
print(df.mean(),'→ mean求平均值\n')
print(df.median(),'→ median求算數(shù)中位數(shù)，50%分位數(shù)\n')
print(df.std(), '\n',df.var(),'→ std,var分別求標(biāo)準(zhǔn)差，方差\n')
print(df.skew(),'→ skew樣本的偏度\n')
print(df.kurt(),'→ kurt樣本的峰度\n')
主要數(shù)學(xué)計(jì)算方法，可用于Series和DataFrame (2)
# 主要數(shù)學(xué)計(jì)算方法，可用于Series和DataFrame (2)
df["key1_s"] = df["key1"].cumsum()
df["key2_s"] = df["key2"].cumsum()
print(df,'→ cumsum樣本的累計(jì)和\n')
df["key1_p"] = df["key1"].cumprod()
df["key2_p"] = df["key2"].cumprod()
print(df,'→ cumprod樣本的累計(jì)積\n')
print(df.cummax(), "\n", df.cummin(),'→ cummax,cummin分別求累計(jì)最大值，累計(jì)最小值\n')
# 會(huì)填充key1，和key2的值
唯一值：.unique()
# 唯一值：.unique()
s = pd.Series(list("asdvasdcfgg"))
sq = s.unique()
print(s, type(s))
print(sq, type(sq))
print(pd.Series(sq))
# 得到一個(gè)唯一值數(shù)組
# 通過pd.Series重新變成新的Series
sq.sort()
print(sq)
# 重新排序
值計(jì)數(shù)：.value_counts()
# 值計(jì)數(shù)：.value_counts()
sc = s.value_counts(sort = False) # 也可以這樣寫：pd.value_counts(s, sort = False)
print(sc)
# 得到一個(gè)新的Serires，計(jì)算出不同值出現(xiàn)的頻率
# sort參數(shù)：排序，默認(rèn)為True
成員資格：.isin()
# 成員資格：.isin()
s = pd.Series(np.arange(10,15))
df = pd.DataFrame({"key1": list("asdcbvasd"),
"key2": np.arange(4,13)})
print(s)
print(df)
print("---------")
print(s.isin([5,14]))
print(df.isin(["a", "bc", "10", 8]))
# 用[]表示
# 得到一個(gè)布爾值的Series或者Dataframe
【課程2.14】 文本數(shù)據(jù)
????Pandas針對字符串配備的一套方法，使其易于對數(shù)組的每個(gè)元素進(jìn)行操作
通過str訪問，且自動(dòng)排除丟失 / NA值
# 通過str訪問，且自動(dòng)排除丟失 / NA值
s = pd.Series(["A", "b", "c", "bbhello", "1", np.nan, "hj"])
df = pd.DataFrame({"key1": list("abcdef"),
"key2": ["hee", "fv", "w", "hija", "123", np.nan]})
print(s)
print(df)
print("--------")
print(s.str.count("b"))
print(df["key2"].str.upper())
print("-------")
# 直接通過.str調(diào)用字符串方法
# 可以對series、Dataframe使用
# 自動(dòng)過濾NaN值
df.columns = df.columns.str.upper()
print(df)
# df.columns是一個(gè)Index對象，也可使用.str
字符串常用方法（1） - lower, upper, len, startswith, endswith
# 字符串常用方法（1） - lower, upper, len, startswith, endswith
s = pd.Series(["A", "b", "c", "bbhello", "1", np.nan])
print(s.str.lower(), '→ lower小寫\n')
print(s.str.upper(),'→ upper大寫\n')
print(s.str.len(), '→ len字符長度\n')
print(s.str.startswith("b"),'→ 判斷起始是否為b \n')
print(s.str.endswith("3"),'→ 判斷結(jié)束是否為3 \n')
字符串常用方法（2）- Strip
# 字符串常用方法（2）- Strip
s = pd.Series([" jack", "jill", " jesse ", "frank"])
df = pd.DataFrame(np.random.rand(3,2), columns = [" Column A ", " Column B "],
index = range(3))
print(s)
print(df)
print("-----------")
print(s.str.strip()) # 去除字符串中的空格
print(s.str.lstrip()) # 去除字符串中的左空格
print(s.str.rstrip()) # 去除字符串中的右空格
df.columns = df.columns.str.strip()
print(df)
# 這里去掉了columns的前后空格，但沒有去掉中間空格
字符串常用方法（3） - replace
# 字符串常用方法（3） - replace
df = pd.DataFrame(np.random.randn(3,2), columns = [" Column A ", " Column B "],
index = range(3))
df.columns = df.columns.str.replace(" ","-")
print(df)
# 替換
df.columns = df.columns.str.replace("-","hehe", n = 1)
print(df)
# n：替換個(gè)數(shù)
字符串常用方法（4）- split、rsplit
# 字符串常用方法（4）- split、rsplit
s = pd.Series(["a,b,c", "1,2,3", ["a,,,c"], np.nan])
print(s.str.split(","))
print("---------")
# 類似字符串的split
print(s.str.split(",")[0])
print("---------")
# 直接索引得到一個(gè)list
print(s.str.split(",").str[0])
print(s.str.split(",").str.get(1))
print("----------")
# 可以使用get或[]符號(hào)訪問拆分列表中的元素
print(s.str.split(",", expand=True))
print(s.str.split(",", expand=True, n = 1))
print(s.str.rsplit(",", expand=True, n = 1))
print("----------")
# 可以使用expand可以輕松擴(kuò)展此操作以返回DataFrame
# n參數(shù)限制分割數(shù)
# rsplit類似于split，反向工作，即從字符串的末尾到字符串的開頭
df = pd.DataFrame({"key1": ["a,b,c", "1,2,3", [":,., "]],
"key2": ["a-b-c", "1-2-3", [":-.- "]]})
print(df["key2"].str.split("-"))
# DataFrame使用split
字符串索引
# 字符串索引
s = pd.Series(["A", "b", "C", "bbhello", "123", np.nan, "hj"])
df = pd.DataFrame({"key1": list("abcdef"),
"key2": ["hee", "fv", "w", "hija", "123", np.nan]})
print(s.str[0]) # 取第一個(gè)字符串
print(s.str[:2]) # 取前兩個(gè)字符串
print(df["key2"].str[0])
# str之后和字符串本身索引方式相同
【課程2.15】 合并 merge、joinDatetimeIndex
????Pandas具有全功能的，高性能內(nèi)存中連接操作，與SQL等關(guān)系數(shù)據(jù)庫非常相似
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,
left_index=False, right_index=False, sort=True,
suffixes=('_x', '_y'), copy=True, indicator=False)
merge合并 -> 類似excel的vlookup
# merge合并 -> 類似excel的vlookup
df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
df3 = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
'key2': ['K0', 'K1', 'K0', 'K1'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
df4 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
'key2': ['K0', 'K0', 'K0', 'K0'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
print(pd.merge(df1, df2, on = "key"))
print('------')
# left：第一個(gè)df
# right：第二個(gè)df
# on：參考鍵
print(df3, "\n", df4)
print(pd.merge(df3, df4, on=['key1','key2']))
# 多個(gè)鏈接鍵
# 參數(shù)how -> 合并方式
print(pd.merge(df3, df4, on = ["key1", "key2"], how = "inner"))
print('------')
# inner：默認(rèn)，取交集
print(pd.merge(df3, df4, on=['key1','key2'], how = 'outer'))
print('------')
# outer：取并集，數(shù)據(jù)缺失范圍NaN
print(pd.merge(df3, df4, on=['key1','key2'], how = 'left'))
print('------')
# left：按照df3為參考合并，數(shù)據(jù)缺失范圍NaN
print(pd.merge(df3, df4, on=['key1','key2'], how = 'right'))
# right：按照df4為參考合并，數(shù)據(jù)缺失范圍NaN
參數(shù) left_on, right_on, left_index, right_index → 當(dāng)鍵不為一個(gè)列時(shí)，可以單獨(dú)設(shè)置左鍵與右鍵
# 參數(shù) left_on, right_on, left_index, right_index → 當(dāng)鍵不為一個(gè)列時(shí)，可以單獨(dú)設(shè)置左鍵與右鍵
df1 = pd.DataFrame({"lkey": list("bbacaab"),
"data1": range(7)})
df2 = pd.DataFrame({"rkey": list("abd"),
"data2": range(3)})
print(pd.merge(df1, df2, left_on = "lkey", right_on = "rkey"))
print("----------")
# df1以‘lkey’為鍵，df2以‘rkey’為鍵
df1 = pd.DataFrame({'key': list('abcdfeg'),
'data1': range(7)})
df2 = pd.DataFrame({'date2': range(100,105)},
index = list('abcde'))
print(df1, "####\n", df2)
print(pd.merge(df1, df2, left_on='key', right_index=True))
# df1以‘key’為鍵，df2以index為鍵
# left_index：為True時(shí)，第一個(gè)df以index為鍵，默認(rèn)False
# right_index：為True時(shí)，第二個(gè)df以index為鍵，默認(rèn)False
# 所以left_on, right_on, left_index, right_index可以相互組合：
# left_on + right_on, left_on + right_index, left_index + right_on, left_index + right_index
參數(shù) sort
# 參數(shù) sort
df1 = pd.DataFrame({"key": list("bbacaab"),
"data1": [1,3,2,4,5,9,7]})
df2 = pd.DataFrame({"key": list("abd"),
"data2": [11,2,33]})
x1 = pd.merge(df1, df2, on = "key", how = "outer")
x2 = pd.merge(df1, df2, on = "key", sort=True, how = "outer")
print(x1)
print(x2)
print('------')
# sort：按照字典順序通過 連接鍵 對結(jié)果DataFrame進(jìn)行排序。默認(rèn)為False，設(shè)置為False會(huì)大幅提高性能
print(x2.sort_values('data1'))
# 也可直接用Dataframe的排序方法：sort_values，sort_index
pd.join() -> 直接通過索引鏈接
# pd.join() -> 直接通過索引鏈接
left = pd.DataFrame({"A": ["A0", "A1", "A2"],
"B": ["B0", "B1", "B2"]},
index = ["K0", "K1", "K2"])
right = pd.DataFrame({"C": ["C0", "C1", "C2"],
"D": ["D0", "D1", "D2"]},
index = ["K0", "K1", "K2"])
print(left)
print(right)
print(left.join(right))
print(left.join(right, how = "outer"))
print('-----')
# 等價(jià)于：pd.merge(left, right, left_index=True, right_index=True, how='outer')
df1 = pd.DataFrame({"key": list("bbacaab"),
"data1": [1,3,2,4,5,9,7]})
df2 = pd.DataFrame({"key": list("abc"),
"date2": [11,2,33]})
print(df1)
print(df2)
print(pd.merge(df1, df2, left_index=True, right_index=True, suffixes=('_1', '_2')))
print(df1.join(df2['date2']))
# suffixes=('_x', '_y')默認(rèn)
left = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3'],
'key': ['K0', 'K1', 'K0', 'K1']})
right = pd.DataFrame({'C': ['C0', 'C1'],
'D': ['D0', 'D1']},
index=['K0', 'K1'])
print(left)
print(right)
print(left.join(right, on = 'key'))
# 等價(jià)于pd.merge(left, right, left_on='key', right_index=True, how='left', sort=False);
# left的‘key’和right的index
【【課程2.16】 連接與修補(bǔ) concat、combine_first
????連接 - 沿軸執(zhí)行連接操作
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
keys=None, levels=None, names=None, verify_integrity=False,
copy=True)
連接：concat
# 連接：concat
s1 = pd.Series([1,2,3])
s2 = pd.Series([2,3,4])
s3 = pd.Series([1,2,3],index = ['a','c','h'])
s4 = pd.Series([2,3,4],index = ['b','e','d'])
print(pd.concat([s1,s2]))
print(pd.concat([s3,s4]).sort_index())
print('-----')
# 默認(rèn)axis=0，行+行
print(pd.concat([s3,s4], axis=1))
print('-----')
# axis=1,列+列，成為一個(gè)Dataframe
連接方式：join，join_axes
# 連接方式：join，join_axes
s5 = pd.Series([1,2,3],index = ['a','b','c'])
s6 = pd.Series([2,3,4],index = ['b','c','d'])
print(pd.concat([s5,s6], axis= 1))
print(pd.concat([s5,s6], axis= 1, join='inner'))
print(pd.concat([s5,s6], axis= 1, join_axes=[['a','b','d']]))
# join：{'inner'，'outer'}，默認(rèn)為“outer”。如何處理其他軸上的索引。outer為聯(lián)合和inner為交集。
# join_axes：指定聯(lián)合的index
覆蓋列名
# 覆蓋列名
sre = pd.concat([s5,s6], keys = ['one','two'])
print(sre,type(sre))
print(sre.index)
print('-----')
# keys：序列，默認(rèn)值無。使用傳遞的鍵作為最外層構(gòu)建層次索引
sre = pd.concat([s5,s6], axis=1, keys = ['one','two'])
print(sre,type(sre))
# axis = 1, 覆蓋列名
修補(bǔ) pd.combine_first()
# 修補(bǔ) pd.combine_first()
df1 = pd.DataFrame([[np.nan, 3., 5.], [-4.6, np.nan, np.nan],[np.nan, 7., np.nan]])
df2 = pd.DataFrame([[-42.6, np.nan, -8.2], [-5., 1.6, 4]],index=[1, 2])
print(df1)
print(df2)
print(df1.combine_first(df2))
print('-----')
# 根據(jù)index，df1的空值被df2替代
# 如果df2的index多于df1，則更新到df1上，比如index=['a',1]
df1.update(df2)
print(df1)
# update，直接df2覆蓋df1，相同index位置
【課程2.17】 去重及替換
????.duplicated / .replace
去重 .duplicated
# 去重 .duplicated
s = pd.Series([1,1,1,1,2,2,2,3,4,5,5,5,5])
print(s.duplicated())
print(s[s.duplicated() == False])
print('-----')
# 判斷是否重復(fù)
# 通過布爾判斷，得到不重復(fù)的值
s_re = s.drop_duplicates()
print(s_re)
print('-----')
# drop.duplicates移除重復(fù)
# inplace參數(shù)：是否替換原值，默認(rèn)False
df = pd.DataFrame({'key1':['a','a',3,4,5],
'key2':['a','a','b','b','c']})
print(df.duplicated())
print(df['key2'].duplicated())
# Dataframe中使用duplicated
替換 .replace
# 替換 .replace
s = pd.Series(list('ascaazsd'))
print(s.replace('a', np.nan))
print(s.replace(['a','s'] ,np.nan))
print(s.replace({'a':'hello world!','s':123}))
# 可一次性替換一個(gè)值或多個(gè)值
# 可傳入列表或字典
【課程2.18】 數(shù)據(jù)分組
????分組統(tǒng)計(jì) - groupby功能
① 根據(jù)某些條件將數(shù)據(jù)拆分成組
② 對每個(gè)組獨(dú)立應(yīng)用函數(shù)
③ 將結(jié)果合并到一個(gè)數(shù)據(jù)結(jié)構(gòu)中
Dataframe在行（axis=0）或列（axis=1）上進(jìn)行分組，將一個(gè)函數(shù)應(yīng)用到各個(gè)分組并產(chǎn)生一個(gè)新值，然后函數(shù)執(zhí)行結(jié)果被合并到最終的結(jié)果對象中。
df.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)
分組
# 分組
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.rand(8)})
print(df)
print("----------")
print(df.groupby("A"), type(df.groupby("A")))
print("----------")
# 直接分組得到一個(gè)groupby對象，是一個(gè)中間數(shù)據(jù)，沒有進(jìn)行計(jì)算
a = df.groupby("A").mean()
b = df.groupby(["A", "B"]).mean()
c = df.groupby(["A"])["D"].mean() # 以A分組，算D的平均值
print(a, type(a), "\n", a.columns)
print(b, type(b), "\n", b.columns)
print(c, type(c))
# 通過分組后的計(jì)算，得到一個(gè)新的dataframe
# 默認(rèn)axis = 0，以行來分組
# 可單個(gè)或多個(gè)（[]）列分組
分組 - 可迭代對象
# 分組 - 可迭代對象
df = pd.DataFrame({"X": ["A", "B", "A", "B"],
"Y": [1, 4, 3, 2]})
print(df)
print(df.groupby("X"), type(df.groupby("X")))
print("-----------------")
print(list(df.groupby("X")), '→ 可迭代對象，直接生成list\n')
print(list(df.groupby("X"))[0], '→ 以元祖形式顯示\n')
for n,g in df.groupby("X"):
print(n)
print(g)
print("###")
print("-----------------")
# n是組名，g是分組后的Dataframe
print(df.groupby(["X"]).get_group("A"), "\n")
print(df.groupby(["X"]).get_group("B"), "\n")
print('-----')
# .get_group()提取分組后的組
grouped = df.groupby(["X"])
print(grouped.groups)
print(grouped.groups["A"]) # 也可寫：df.groupby("X").groups["A"]
print('-----')
# .groups：將分組后的groups轉(zhuǎn)為dict
# 可以字典索引方法來查看groups里的元素
sz = grouped.size()
print(sz, type(sz))
print('-----')
# .size()：查看分組后的長度
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)})
grouped = df.groupby(["A", "B"]).groups
print(df)
print(grouped)
print(grouped[("foo", "three")])
# 按照兩個(gè)列進(jìn)行分組
其他軸上的分組
# 其他軸上的分組
df = pd.DataFrame({"data1": np.random.rand(2),
"data2": np.random.rand(2),
"key1": ["a", "b"],
"key2": ["one", "two"]})
print(df)
print(df.dtypes)
print('-----')
for n,p in df.groupby(df.dtypes, axis = 1):
print(n)
print(p)
print("###")
# 按照值類型分列
通過字典或者Series分組
# 通過字典或者Series分組
df = pd.DataFrame(np.arange(16).reshape(4,4),
columns = ["a", "b", "c", "d"])
print(df)
print("--------")
mapping = {"a": "one", "b": "one", "c": "two", "d": "two", "e": "three"}
by_colum = df.groupby(mapping, axis = 1)
print(by_colum.sum())
print("---------")
# mapping中，a、b列對應(yīng)的為one，c、d列對應(yīng)的為two，以字典來分組
s = pd.Series(mapping)
print(s, "\n")
print(s.groupby(s).count())
s中，index中a、b對應(yīng)的為one，c、d對應(yīng)的為two，以Series來分組
通過函數(shù)分組
# 通過函數(shù)分組
df = pd.DataFrame(np.arange(16).reshape(4,4),
columns = ["a", "b", "c", "d"],
index = ["abc", "bcd", "aa", "b"])
print(df, "\n")
print(df.groupby(len).sum())
分組計(jì)算函數(shù)方法
# 分組計(jì)算函數(shù)方法
s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
grouped = s.groupby(level=0) # 唯一索引用.groupby(level=0)，將同一個(gè)index的分為一組
print(grouped)
print(grouped.first(),'→ first：非NaN的第一個(gè)值\n')
print(grouped.last(),'→ last：非NaN的最后一個(gè)值\n')
print(grouped.sum(),'→ sum：非NaN的和\n')
print(grouped.mean(),'→ mean：非NaN的平均值\n')
print(grouped.median(),'→ median：非NaN的算術(shù)中位數(shù)\n')
print(grouped.count(),'→ count：非NaN的值\n')
print(grouped.min(),'→ min、max：非NaN的最小值、最大值\n')
print(grouped.std(),'→ std，var：非NaN的標(biāo)準(zhǔn)差和方差\n')
print(grouped.prod(),'→ prod：非NaN的積\n')
多函數(shù)計(jì)算：agg()
# 多函數(shù)計(jì)算：agg()
df = pd.DataFrame({"a": [1,1,2,2],
"b": np.random.rand(4),
"c": np.random.rand(4),
"d": np.random.rand(4)})
print(df)
print(df.groupby("a").agg(["mean", np.sum]))
print(df.groupby("a")["b"].agg({"result1": np.mean,
"result2": np.sum}))
# 函數(shù)寫法可以用str，或者np.方法
# 可以通過list，dict傳入，當(dāng)用dict時(shí)，key名為columns
【課程2.19】 分組轉(zhuǎn)換及一般性“拆分-應(yīng)用-合并”
????transform / apply
數(shù)據(jù)分組轉(zhuǎn)換，transform
# 數(shù)據(jù)分組轉(zhuǎn)換，transform
df = pd.DataFrame({"data1": np.random.rand(5),
"data2": np.random.rand(5),
"key1": list("aabba"),
"key2": ["one", "two", "one", "two", "one"]})
k_mean = df.groupby("key1").mean()
print(df)
print(k_mean)
print(pd.merge(df, k_mean, left_on = "key1", right_index = True).add_prefix("mean_"))
# .add_prefix('mean_')：添加前綴
print("-------")
# 通過分組、合并，得到一個(gè)包含均值的Dataframe
print(df.groupby("key2").mean()) # 按照key2分組求平均值
print(df.groupby("key2").transform(np.mean))
# data1、data2每個(gè)位置元素取對應(yīng)分組列的均值
# 字符串不能進(jìn)行計(jì)算
一般化Groupby方法：apply
# 一般化Groupby方法：apply
df = pd.DataFrame({'data1':np.random.rand(5),
'data2':np.random.rand(5),
'key1':list('aabba'),
'key2':['one','two','one','two','one']})
print(df.groupby("key1").apply(lambda x: x.describe()))
# apply直接運(yùn)行其中的函數(shù)
# 這里為匿名函數(shù)，直接描述分組后的統(tǒng)計(jì)量
def f_df1(d,n):
return(d.sort_index()[:n])
def f_df2(d,k1):
return(d[k1])
print(df.groupby("key1").apply(f_df1,2), "\n")
print(df.groupby('key1').apply(f_df2,'data2'))
print(type(df.groupby('key1').apply(f_df2,'data2')))
# f_df1函數(shù)：返回排序后的前n行數(shù)據(jù)
# f_df2函數(shù)：返回分組后表的k1列，結(jié)果為Series，層次化索引
# 直接運(yùn)行f_df函數(shù)
# 參數(shù)直接寫在后面，也可以為.apply(f_df,n = 2))
【課程2.20】 透視表及交叉表
????類似excel數(shù)據(jù)透視 - pivot table / crosstab
透視表：pivot_table
# 透視表：pivot_table
# pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
date = ['2017-5-1','2017-5-2','2017-5-3']*3
rng = pd.to_datetime(date)
df = pd.DataFrame({'date':rng,
'key':list('abcdabcda'),
'values':np.random.rand(9)*10})
print(df)
print('-----')
print(pd.pivot_table(df, values = 'values', index = 'date', columns = 'key', aggfunc=np.sum)) # 也可以寫 aggfunc='sum'
print('-----')
# data：DataFrame對象
# values：要聚合的列或列的列表
# index：數(shù)據(jù)透視表的index，從原數(shù)據(jù)的列中篩選
# columns：數(shù)據(jù)透視表的columns，從原數(shù)據(jù)的列中篩選
# aggfunc：用于聚合的函數(shù)，默認(rèn)為numpy.mean，支持numpy計(jì)算方法
print(pd.pivot_table(df, values = 'values', index = ['date','key'], aggfunc=len))
print('-----')
# 這里就分別以date、key共同做數(shù)據(jù)透視，值為values：統(tǒng)計(jì)不同（date，key）情況下values的平均值
# aggfunc=len(或者count)：計(jì)數(shù)
交叉表：crosstab
# 交叉表：crosstab
# 默認(rèn)情況下，crosstab計(jì)算因子的頻率表，比如用于str的數(shù)據(jù)透視分析
# pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, dropna=True, normalize=False)
df = pd.DataFrame({'A': [1, 2, 2, 2, 2],
'B': [3, 3, 4, 4, 4],
'C': [1, 1, np.nan, 1, 1]})
print(df)
print('-----')
print(pd.crosstab(df['A'],df['B']))
print('-----')
# 如果crosstab只接收兩個(gè)Series，它將提供一個(gè)頻率表。
# 用A的唯一值，統(tǒng)計(jì)B唯一值的出現(xiàn)次數(shù)
print(pd.crosstab(df['A'],df['B'],normalize=True))
print('-----')
# normalize：默認(rèn)False，將所有值除以值的總和進(jìn)行歸一化 → 為True時(shí)候顯示百分比
print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum))
print('-----')
# values：可選，根據(jù)因子聚合的值數(shù)組
# aggfunc：可選，如果未傳遞values數(shù)組，則計(jì)算頻率表，如果傳遞數(shù)組，則按照指定計(jì)算
# 這里相當(dāng)于以A和B界定分組，計(jì)算出每組中第三個(gè)系列C的值
print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum, margins=True))
print('-----')
# margins：布爾值，默認(rèn)值False，添加行/列邊距（小計(jì)）
【課程2.21】 數(shù)據(jù)讀取
????核心：read_table, read_csv, read_excel
讀取普通分隔數(shù)據(jù)：read_table
# 讀取普通分隔數(shù)據(jù)：read_table
# 可以讀取txt，csv
import os
os.chdir('/Users/zorn/Desktop/')
data1 = pd.read_table('data1.txt', delimiter=',',header = 0, index_col=1)
print(data1)
# delimiter：用于拆分的字符，也可以用sep：sep = ','
# header：用做列名的序號(hào)，默認(rèn)為0（第一行）
# index_col：指定某列為行索引，否則自動(dòng)索引0, 1, .....
# read_table主要用于讀取簡單的數(shù)據(jù)，txt/csv
讀取csv數(shù)據(jù)：read_csv
# 讀取csv數(shù)據(jù)：read_csv
# 先熟悉一下excel怎么導(dǎo)出csv
data2 = pd.read_csv('data3.csv',engine = 'python')
print(data2.head())
# engine：使用的分析引擎?？梢赃x擇C或者是python。C引擎快但是Python引擎功能更加完備。
# encoding：指定字符集類型，即編碼，通常指定為'utf-8'
# 大多數(shù)情況先將excel導(dǎo)出csv，再讀取
