Pythonデータ分析ツール:Pandas_Part 3

25483 ワード

はじめに
第3部
【カリキュラム2.13】数値計算と統計の基礎
常用数学、統計方法
基本パラメータ:axis、skipna

#     ：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("      ：", df["key2"].mean())
print("------")
# np.nan：  
# .mean()    
#       
#             

m2 = df.mean(axis = 1) 
print(m2)
print("------------")
# axis  ：   0，     ，axis=1,     ，          

m3 = df.mean(skipna=False)
print(m3)
print("----------")
# skipna  ：    NaN，  True，  False， Nan        NaN

SeriesとDataFrame(1)に使用できる主な数学計算方法

#         ，   Series DataFrame (1)

df = pd.DataFrame({"key1": np.arange(10),
                  "key2": np.random.rand(10)*10})
print(df)
print("------------")

print(df.count(), "→ count   Na    
")
print(df.min(), '→ min     
', df["key2"].max(), '→ max     
')
print(df.quantile(q=0.75),'→ quantile     ，  q    
')
print(df.sum(),'→ sum  
')
print(df.mean(),'→ mean    
')
print(df.median(),'→ median      ，50%   
')
print(df.std(), '
',df.var(),'→ std,var      ，  
')
print(df.skew(),'→ skew     
')
print(df.kurt(),'→ kurt     
')

SeriesとDataFrame(2)に使用できる主な数学計算方法

#         ，   Series DataFrame (2)

df["key1_s"] = df["key1"].cumsum()
df["key2_s"] = df["key2"].cumsum()
print(df,'→ cumsum      
')

df["key1_p"] = df["key1"].cumprod()
df["key2_p"] = df["key2"].cumprod()
print(df,'→ cumprod      
')

print(df.cummax(), "
", df.cummin(),'→ cummax,cummin        ，     
')
#    key1， key2

一意の値:.unique()

#    ：.unique()

s = pd.Series(list("asdvasdcfgg"))
sq = s.unique()
print(s, type(s))
print(sq, type(sq))
print(pd.Series(sq))
#          
#   pd.Series      Series

sq.sort()
print(sq)
#

値のカウント:.value_counts()

#    ：.value_counts()

sc = s.value_counts(sort = False) #       ：pd.value_counts(s, sort = False)
print(sc)
#       Serires，           
# sort  ：  ，   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]))
#  []  
#         Series  Dataframe

【レッスン2.14】テキストデータ
配列の各要素を容易に操作できるように、文字列に対するメソッドのセット
strでアクセスし、損失/NA値を自動的に排除

#   str  ，        / 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       
#    series、Dataframe  
#     NaN 

df.columns = df.columns.str.upper()
print(df)
# df.columns   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  
')
print(s.str.upper(),'→ upper  
')
print(s.str.len(), '→ len    
')
print(s.str.startswith("b"),'→        b 
')
print(s.str.endswith("3"),'→        3 
')

文字列共通メソッド(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：

文字列の一般的なメソッド(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("---------")
#         list

print(s.str.split(",").str[0])
print(s.str.split(",").str.get(1))
print("----------")
#     get []            

print(s.str.split(",", expand=True))
print(s.str.split(",", expand=True, n = 1))
print(s.str.rsplit(",", expand=True, n = 1))
print("----------")
#     expand            DataFrame
# n       
# 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])  #         
print(s.str[:2]) #        
print(df["key2"].str[0])
# str

【レッスン2.15】merge、joinDatetimeIndexの統合
全機能を備えた、高性能メモリでの接続操作は、SQLなどの関係データベースと非常に似ています.
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：   df
# right：   df
# on：   
print(df3, "
", df4)
print(pd.merge(df3, df4, on=['key1','key2']))
#

#   how ->     

print(pd.merge(df3, df4, on = ["key1", "key2"], how = "inner"))
print('------')
# inner：  ，   

print(pd.merge(df3, df4, on=['key1','key2'], how = 'outer'))  
print('------')
# outer：   ，      NaN

print(pd.merge(df3, df4, on=['key1','key2'], how = 'left'))  
print('------')
# left：  df3     ，      NaN

print(pd.merge(df3, df4, on=['key1','key2'], how = 'right'))  
# right：  df4     ，      NaN

パラメータleft_on, right_on, left_index, right_index→キーが1列でない場合は、左キーと右キーを個別に設定できます

#    left_on, right_on, left_index, right_index →         ，           

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, "####
", df2)
print(pd.merge(df1, df2, left_on='key', right_index=True))
# df1 ‘key’  ，df2 index  
# left_index： True ，   df index  ，  False
# right_index： True ，   df index  ，  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

パラメータsort

#    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：                DataFrame    。   False，   False       

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('-----')
#    ：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')  

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'))
#    pd.merge(left, right, left_on='key', right_index=True, how='left', sort=False);
# left ‘key’ right index

【【カリキュラム2.16】接続とパッチconcat、combine_first
「接続」-軸に沿って接続操作を行います.
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

#   ：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('-----')
#   axis=0， + 

print(pd.concat([s3,s4], axis=1))
print('-----')
# axis=1, + ，    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'}，   “outer”。           。outer    inner   。
# join_axes：     index

列名の上書き

#     

sre = pd.concat([s5,s6], keys = ['one','two'])
print(sre,type(sre))
print(sre.index)
print('-----')
# keys：  ，    。                 

sre = pd.concat([s5,s6], axis=1, keys = ['one','two'])
print(sre,type(sre))
# axis = 1,

補修pd.combine_first()

#    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('-----')
#   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('-----')
#       
#       ，       

s_re = s.drop_duplicates()
print(s_re)
print('-----')
# drop.duplicates    
# inplace  ：      ，  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}))
#              
#

【レッスン2.18】データグループ
グループ統計-groupby機能
①ある条件によりデータをグループ化する②各グループに対して独立して関数を適用する③結果を1つのデータ構造にまとめる
Dataframe行(axis=0)または列(axis=1)にグループ化し、1つの関数を各グループに適用して新しい値を生成し、関数実行結果を最終結果オブジェクトにマージします.
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("----------")
#         groupby  ，       ，      

a = df.groupby("A").mean()
b = df.groupby(["A", "B"]).mean()
c = df.groupby(["A"])["D"].mean()  #  A  ， D    
print(a, type(a), "
", a.columns)
print(b, type(b), "
", b.columns)
print(c, type(c))
#         ，      dataframe
#   axis = 0，     
#       （[]）

グループ化→反復可能オブジェクト

#    -      

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
')
print(list(df.groupby("X"))[0], '→        
')
for n,g in df.groupby("X"):
    print(n)
    print(g)
    print("###")
print("-----------------")
# n   ，g     Dataframe

print(df.groupby(["X"]).get_group("A"), "
")
print(df.groupby(["X"]).get_group("B"), "
")
print('-----')
# .get_group()       

grouped = df.groupby(["X"])
print(grouped.groups)
print(grouped.groups["A"])    #    ：df.groupby("X").groups["A"]
print('-----')
# .groups：     groups  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")])
#

その他の軸のグループ化

#        

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     one，c、d     two，      

s = pd.Series(mapping)
print(s, "
")
print(s.groupby(s).count())
 s ，index a、b    one，c、d    two， Series

関数によるグループ化

#       

df = pd.DataFrame(np.arange(16).reshape(4,4),
                 columns = ["a", "b", "c", "d"],
                 index = ["abc", "bcd", "aa", "b"])
print(df, "
")
print(df.groupby(len).sum())

グループ計算関数メソッド

#         

s = pd.Series([1, 2, 3, 10, 20, 30], index = [1, 2, 3, 1, 2, 3])
grouped = s.groupby(level=0)  #      .groupby(level=0)，    index     
print(grouped)
print(grouped.first(),'→ first： NaN     
')
print(grouped.last(),'→ last： NaN      
')
print(grouped.sum(),'→ sum： NaN  
')
print(grouped.mean(),'→ mean： NaN    
')
print(grouped.median(),'→ median： NaN      
')
print(grouped.count(),'→ count： NaN  
')
print(grouped.min(),'→ min、max： NaN    、   
')
print(grouped.std(),'→ std，var： NaN       
')
print(grouped.prod(),'→ prod： NaN  
')

多関数計算:agg()

#      ：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}))
#        str，  np.  
#     list，dict  ，  dict ，key  columns

【レッスン2.19】グループ変換および一般的な「分割-適用-マージ」
transform/apply
データパケット変換、transform

#       ，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("-------")
#     、  ，         Dataframe

print(df.groupby("key2").mean()) #   key2      
print(df.groupby("key2").transform(np.mean))
# data1、data2               
#

一般化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         
#        ，           

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), "
")
print(df.groupby('key1').apply(f_df2,'data2'))
print(type(df.groupby('key1').apply(f_df2,'data2')))
# f_df1  ：       n   
# f_df2  ：       k1 ，   Series，     
#     f_df  
#         ，    .apply(f_df,n = 2))

【カリキュラム2.20】ピボットおよびクロス集計
同様のexcelデータピボット-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：      index，         
# columns：      columns，         
# aggfunc：       ，   numpy.mean，  numpy    

print(pd.pivot_table(df, values = 'values', index = ['date','key'], aggfunc=len))
print('-----')
#       date、key       ，  values：    （date，key）   values    
# aggfunc=len(  count)：

クロス集計クロス集計:crosstab

#    ：crosstab
#      ，crosstab        ，    str       
# 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     Series，         。
#  A    ，  B        

print(pd.crosstab(df['A'],df['B'],normalize=True))
print('-----')
# normalize：  False，                →  True       

print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum))
print('-----')
# values：  ，          
# aggfunc：  ，     values  ，      ，      ，       
#       A B    ，           C  

print(pd.crosstab(df['A'],df['B'],values=df['C'],aggfunc=np.sum, margins=True))
print('-----')
# margins：   ，   False，   /   （  ）

【レッスン2.21】データ読み出し
コア:read_table, read_csv, read_excel
通常の区切りデータの読み込み:read_table

#         ：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：       ，   0（   ）
# index_col：        ，      0, 1, .....

# read_table           ，txt/csv

csvデータの読み込み:read_csv

#   csv  ：read_csv
#      excel    csv

data2 = pd.read_csv('data3.csv',engine = 'python')
print(data2.head())
# engine：       。    C   python。C     Python        。
# encoding：       ，   ，     'utf-8'

#        excel  csv，

最後:
Pandas課程の宿題Pandas課程の宿題の解答以上の完全なコード

Luaパッケージ&C++実践(二)——C++がLua関数を呼び出すパッケージ

AzureをAnsibleから弄ってみる