import pandas as pd
file_path_read=''
file_path_write=''
 
#讀入csv或txt文件內(nèi)數(shù)據(jù)，以下只羅列了常用的參數(shù)
df=pd.read_csv( 
    file_path_read ,  #指定需讀入或?qū)懭氲奈募穆窂剑蔀橄鄬β窂?，也可為絕對路徑
    sep= ',' ,  #指定分隔符
    encoding= utf-8 , #指定字符編碼格式
    usecols=None , #指定需讀入的列，列表格式，可為索引[1,2,3]或列明['A','B','C']
    names=['A','B','C'] , #可自定義讀入數(shù)據(jù)的列標簽
    skip_blank_lines=True,  #設置是否跳過內(nèi)容全空的行
    nrows=1000, #指定讀入的行數(shù) 
    skiprows=[2,5],#指定需跳過的行數(shù)
    dtype={0:str,'B':'float64'}) #指定列數(shù)據(jù)讀入的格式，可分別對每一列指定讀入的數(shù)據(jù)格式
 
#將分析好的數(shù)據(jù)寫入csv或txt文件
df.to_csv( file_path_write  )

import pandas as pd
file_path_read=''
file_path_write=''
 
#從數(shù)據(jù)源讀取數(shù)據(jù)，并同時指定讀入數(shù)據(jù)的格式，也可不指定，讀入后就是一個標準的DataFrame
#其他常用的參數(shù)，與read_csv一致，不再贅述
df=pd.read_excel(file_path_read ,encoding= utf-8 , usecols=None , names=['A','B','C'] , skip_blank_lines=True, nrows=1000, skiprows=[2,5],dtype={0:str,2:'float64'})
 
#將分析好的數(shù)據(jù)寫入Excel，并同時指定寫入數(shù)據(jù)的格式，也可不指定
df.to_excel(file_path_write , dtype=str)

import pandas as pd
from sqlalchemy import create_engine
 
#1、連接數(shù)據(jù)庫
#其中username為賬戶名，比如root，password為密碼，ip為數(shù)據(jù)庫的ip，如果是本地的一般是localhost，port為端口，database為數(shù)據(jù)庫名
engine = create_engine('mysql+pymysql://username:password@ip:port/database')
 
#2、定義查詢sql語句
sql = '''select * from tablename where colname in (,)  '''
 
#3、讀取數(shù)據(jù)，使用以上數(shù)據(jù)庫引擎和sql語句查詢數(shù)據(jù)，直接讀入，為DataFrame格式
#coerce_float，很有用，為true時會將字符串格式的數(shù)據(jù)直接讀取為float數(shù)字格式，columns，列表格式，指定讀入的行，一般沒用，因為基本會在sql語句中指定
#sql也可以直接為表名，即讀入整張表，但一般使用sql語句
df=pd.read_sql(sql, engine,  coerce_float=True, columns=None)
 
#4、寫入數(shù)據(jù)，將分析好的數(shù)據(jù)落庫
#tablename為需要寫入的表名，if_exists,默認為false，即表存在則不寫入，也可設置為'append'，即將數(shù)據(jù)追加到該表內(nèi)，dtype可指定各個列的數(shù)據(jù)格式，一般無需指定
df.to_sql('tablename', engine , if_exists='append' ,dtype={})

#清除滿足指定條件的行數(shù)據(jù)的表達式
df = df.drop(df[<some boolean condition>].index)
 
#比如希望清除x列小于0.01或大于10的指定行數(shù)據(jù)，返回一個清除后的DataFrame
#其中的布爾表達式可以有多個,可以用與（&）或（|）非（~）進行連接
df_clear = df.drop(df[(df['x']<0.01) | (df['x']>10)].index) #刪除x小于0.01或大于10的行
 
#或者，比如希望清除A列值為空，或者B列中值小于0的行，然后返回清除后的新的DataFrame
df_clear = df.drop(df[(df['A']==‘') | (df['B']<0)].index) 

#清除指定的行
#drop(list)，函數(shù)接受一個列表，列表內(nèi)是指定需刪除的行索引
df.drop([index]) #即刪除指定行
df.drop([0,1,2,3,4]) #清除前5行
df.drop(range(20)) #清除前20行，

#執(zhí)行刪除操作時，原df不會變化，一般是返回一個新的DataFra
df.drop(['列索引或標簽',axis=1])
 
#刪除索引為2，即第三列
df.drop([2],axis=1)
 
#刪除索引為0，1，2即第一、第二、第三列
df.drop([0,1,2],axis=1)
 
#刪除列標簽為A的列
df.drop(['A'],axis=1)
 
#刪除列標簽為A、B、C的多列
df.drop(['A','B','C'],axis=1)

#語句如下，使用reindex函數(shù)
new_col_list=['B','C','A'] #假設希望將列的展示順序由A、B、C，調(diào)整為B、C、A
df.reindex(columns = new_col_list)
 
#調(diào)整存量DataFrame的列標簽名稱，一般用于將默認的列標簽修改的更加直觀易懂
new_col_name=['age','name',gender']
df.columns=new_col_name

#df.sort_values()函數(shù)
#既可以根據(jù)列數(shù)據(jù)，也可根據(jù)行數(shù)據(jù)排序，最為常用
 
#axis，默認為0，即縱向排序，可指定按照哪列的值進行排序，最終會改變數(shù)據(jù)縱向的順序
#axis，為1時，即橫向排序，可指定按照哪行（根據(jù)行索引）進行排序，最終會改變數(shù)據(jù)的橫向順序
#inplace,
#ascending，可為數(shù)組格式，即指定按照多行或列，不同行或列的升序降序規(guī)則
#na_position，指定缺省值排在最前還是最后，一般是last，即最后
df.sort_values(by=, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
 
#假設數(shù)據(jù)如下：
    b   a   c
2   1   4   1
0   2   3   3
3   2   1   2
1   3   2   8
 
#先按照b降序，再按照a升序排序
df.sort_values(by=['b','a'],axis=0,ascending=[False,True])
 
#先按照3行升序排序，再按照0行降序排序
df.sort_values(by=[3,0],axis=1,ascending=[True,False])

#df.sort_index()函數(shù)
#默認根據(jù)行標簽對所有行排序，或根據(jù)列標簽對所有列排序，或根據(jù)指定某列或某幾列對行排序。
 
#axis，默認為0，即按行標簽進行排序，最終會改變數(shù)據(jù)在縱向的順序
#axis，為1時，即按列標簽排序，最終會改變數(shù)據(jù)在橫向的順序
#na_position，指定缺省值排在最前還是最后，一般是last，即最后
df.sort_index(axis=0, ascending=True , na_position='last')
 
 
#假設數(shù)據(jù)如下：
    b   a   c
2   1   4   1
0   2   3   3
3   2   1   2
1   3   2   8
 
#按照行標簽升序排序，最后會變成0、1、2、3
df.sort_index(axis=0,ascending=True)
 
#按照列標簽升序排序，最后會變成a、b、c
df.sort_index(axis=1,ascending=True)

#1、對空值直接清除
df.dropna(
    axis=0,     # 0: 對行進行操作; 1: 對列進行操作 默認為0
    how='any'   # 'any': 只要存在 NaN 就 drop 掉; 'all': 必須全部是 NaN 才 drop 默認為'any'
    ) 
 
#2、對空值填補
df.fillna(value=0) #用0填補所有的空值
df.fillna({'B': 3,'C': 4})  #使用常量填補對應列的空值，比如針對B列，用3填補空值，針對C列，用4填補空值
 
#3、用前項填充或者后項填充
df.fillna(method = 'ffill') #用前一個觀測值填充
df.fillna(method = 'bfill') #用后一個觀測值填充
 
#4、用均值或中位數(shù)填充各自的列
df.fillna(df.median())
df.fillna(df.mean())
 
 
#注：使用fillna,dropna時，需要添加參數(shù) inplace = True，如df.fillna(df.median()，inplace = True),以確認修改，否則實際的數(shù)據(jù)并不會有改動。

#刪除重復行時，需要用到drop_duplicates函數(shù)
df.drop_duplicates(
    ['A','B'], #指定按照某列，判斷數(shù)據(jù)重復，參數(shù)非必填，可以單列、多列
    keep='first' #指定如果發(fā)現(xiàn)重復，保留哪行數(shù)據(jù)，枚舉有first（保留第一行）、last（保留最后一行），F(xiàn)alse（刪除所有重復行）
)
 
df.drop_duplicates() #刪除完全重復的行數(shù)據(jù)

#1、map()函數(shù)
#可對一列數(shù)據(jù)，統(tǒng)一給一列(Series)中的每一個元素應用指定函數(shù)
def myfunc(x):
    if x>40:
        return '中年人'
    elif x<30:
        return '青年人'
    else:
        return '尷尬的年紀'
df['age'].map(myfunc)
 
 
#2、apply()函數(shù)
#也可對一列數(shù)據(jù)，統(tǒng)一應用指定函數(shù)，但功能更強大，可傳入除列元素的其他參數(shù)
#其他參數(shù)可以關鍵詞的方式傳入，也可以直接傳入其他值
def myfunc(x,*args,**args_dict):
    if x<10000:
        return x+args_dict['high']
    else:
        return x+args_dict['low']
df1['salary']=df1['salary'].apply(myfunc,low=100,high=300)#對工資列，低于1萬的加一個值，高于1萬的，加另外一個值

#以下會對DataFrame每個元素應用一次指定的函數(shù)，并將返回值作為新的值
#一般會產(chǎn)生一個新的df
#以下函數(shù)將空值全部填充為0
df_new=df.apply(lambda x: 0 if str(x)=='' else x)

#以下主要演示對某df內(nèi)某列數(shù)據(jù)進行常見的數(shù)字格式設置
 
#四舍五入
df['salary'].round([decimals=2]) #將工資列，數(shù)字進行四舍五入并保留小數(shù)點后2位
 
#將小數(shù)設置為百分數(shù)，以下設置為精確到小數(shù)點后2位，返回一個設置好格式的series
df['percent'].map( lambda x: format(x,'.2%') )
 
 
#設置千分位分隔符，返回一個設置好格式的series
df['percent'].map( lambda x: format(x,',') )
 
#更多設置格式的方式，可自行了解

#1、直接使用索引
df[index:index+1] #注意，一定要用切片的形式，如果希望直接使用index，則可用iloc[index]
#2、使用行標簽，行標簽為再創(chuàng)建DataFrame或Series時自定義的行標簽
df['row_tag']
 
 
#提起的方法，可以直接使用標準的列表訪問方式[]，也可使用loc()和iloc（函數(shù)）
#[]方式，可使用標簽或索引，如果傳入的是
#loc()函數(shù)，一般用于使用行或列標簽進行訪問
#iloc()函數(shù)，一般使用行或列index索引進行訪問
 
df[2:5] #提取第3到5行
 
df['2020-10-20'] #提取行標簽為2020-10-20的行數(shù)據(jù)
 
df.loc['2020-10-20':'2020-10-31',:] #提取指定3到5行，全列，后面的 : 也可不寫
 
df.loc[2:4,:] #提取指定3到5行，全列，后面的 : 也可不寫

df['colname'] #直接提取指定單列標簽的列數(shù)據(jù)
 
df[['A','D','E']] #指定直接提取指定多列數(shù)據(jù)，這種方法只能使用列標簽進行提取
 
 
df.loc[:,'A':'C'] #使用loc方法提取A列到C列
df.iloc[:,0:2] #使用iloc方法提取第1到3列

df.head(n) #展示前n行，默認5
df.tail(n) #展示后n行，默認5

#通過邏輯運算來取數(shù)據(jù)子集，查詢和篩選出列值滿足指定條件的行數(shù)據(jù)
#可使用 & (AND)、 ~ (NOT) 和 | (OR) 連接多個條件表達式
df[df[ ‘country' ]== 'french' ]
df[(df[ ‘country'  ]== 'french' ) & (df[ 'year_born' ]=='1990')]
df[(df[‘country'  ]== 'french' ) & (df[ 'year_born' ]=='1990') & ~(df[ 'city' ]== 'London' )]
 
df[(df[‘country'  ]== french ) & (df[ 'year_born' ]==1990) & ~(df[ 'city' ].isin([ ['London' , 'beijing']) )]

df.filter(regex='string')#其中string為正則表達式

#逐行打印數(shù)據(jù)，使用iloc
for i in range(len(df.index)):
    print(df.iloc[i])
#逐行打印數(shù)據(jù)，使用loc
for i in df.index:
    print(df.loc[i])

#逐個打印df中的每一列，使用df
for i in df.columns:
    print(df[i])
#逐個打印df中的每一列，使用loc
for i in df.columns:
    print(df.loc[:,i])
 
#逐個打印df中的每一列，使用iloc
for i in range(len(df.columns)):
    print(df.iloc[:,i])

#使用loc
for i in df.index:
    for j in df.columns:
        if df.loc[i][j]=='':
            print('發(fā)現(xiàn)空值')
#使用iloc
for i in range(len(df.index)):
    for j in range(len(df.columns)):
        if df.iloc[i][j]=='':
            print('發(fā)現(xiàn)空值')

#常見統(tǒng)計數(shù)據(jù)值
#某列的個數(shù)、合、平均值、最大值、最小值
df['colname'].count()
df['colname'].sum()
df['colname'].mean()
df['colname'].max()
df['colname'].min()
 
 
#快速統(tǒng)計
#會快速展示每一列的最大、最小、平均、均方差等統(tǒng)計數(shù)據(jù)
df.describe()

#協(xié)方差--相關度系數(shù)
df.corr()  #會輸出相關性矩陣,展示每一列的相關度系

#先按照A列的值，對數(shù)據(jù)進行分組，然后計算出每個分組的數(shù)據(jù)記錄數(shù)量
df['A'].value_counts() 

#分組使用groupby函數(shù)，分組之后，得到一個DataFrameGroupBy對象，后續(xù)可對該對象進行聚合
 
#1、按單列分組，縱向分組
df.groupby('colname')
df.groupby('country') #指按國家列分組
 
#2、按多列分組，縱向分組
df.groupby(['cloA','colB']) #先按照A列，再按照B列分組
 
#3、按單行分組，橫向分組
df.groupby(level=index)
 
#4、按多行分組，橫向分組
df.groupby(level=[0,1])
 
#5、通過字典或者Series分組
#可將行或者列標簽，通過子字典映射成對應的值，然后進行分組
mapping = {'a':'one','b':'one','c':'two','d':'two','e':'three'}
df.groupby(mapping)
 
#6、自定義函數(shù)分組
#會將行或者列標簽作為參數(shù)傳入自定義函數(shù)，并以函數(shù)返回值作為分組的名進行分組
def myfunc(x):
    if x =='a' or x=='b'
        return 'one'
    else:
        return 'two'
df.groupby(myfunc,axis=0)

gp=df.groupby('A')
gp.count() #計數(shù)
gp.sum()#求和
gp.max(),gp.min()#最大值、最小值
gp.mean()#算數(shù)平均數(shù)
gp.first(),gp.last()#第一個和最后一個非空
gp.prod()#非空數(shù)值的乘積
gp.median()#非空的算數(shù)中位數(shù)
gp.std(),gp.var()#非空數(shù)據(jù)的標準差和均方差
gp.describe()#快速生成以上所有統(tǒng)計數(shù)據(jù)

#對某分組后的對象使用自定義的聚合函數(shù)，需要用到agg()函數(shù)
#具體實現(xiàn)，分組后的數(shù)據(jù)為一個數(shù)組，然后會分別將每組對應的數(shù)組作為參數(shù)傳入自定義函數(shù)內(nèi)，最終以函數(shù)返回值作為該分組數(shù)據(jù)聚合后的值
def myfunc(x):
    return (x.max()-x.min())
 
df.groupby('A').agg(myfunc)

#對某次分組對象，一次性應用多個聚合函數(shù)
#可以集合的格式傳入不同的聚合函數(shù)，如果不寫名稱，只傳入函數(shù)，則默認以函數(shù)名為列標簽
df.groupby('A').agg([('求和',sum),('標準差',std),'mean',('range',myfunc)])
 
#對某次分組對象，不同列使用不同的聚合函數(shù)
df.groupby('sku_type').agg({
    'sku_sale_price':'max',
    'profit_rate':'mean'
    })

#1、使用merge函數(shù)進行連接合并
agg=df1.groupby('card_cate_name').sum().add_prefix('sum_')
pd.merge(df1,agg,on='card_cate_name',how='right')
 
#2、使用transform()，,將聚合結(jié)果按照原始數(shù)據(jù)排序成一個DataFrame對象，然后再合并
tf = df.groupby('A').transform(sum)
df[tf.columns]=tf

#類似Excel的數(shù)據(jù)透視圖，pandas可對數(shù)據(jù)快速生成你想要的數(shù)據(jù)透視圖，以快速發(fā)現(xiàn)數(shù)據(jù)相關有趣的特征
 
#1、數(shù)據(jù)透視表的使用
pd.pivot_table(
    df,#要生成透視圖的數(shù)據(jù)源
    index=['colA','colB','colC'],#設置透視圖的行索引，類似指定需要以源數(shù)據(jù)的哪些列值進行分組，可指定多個，自左向右依次多級分組
    values=['colD','colE'],#指定分組后，需要透視的數(shù)據(jù)列，可對數(shù)據(jù)列應用不同的聚合函數(shù)來透視，也可不指定，不指定則會展示出除了index指定的列外所有其他列的聚合透視
    columns=['colF','colG'],#指定透視表的列，即會使用指定列的值，對指定的values列進行分組，該概念是相較于index,注意，columns指定的列和index指定的列及values指定的列不能有重復
    aggfunc=[np.mean,len],#指定聚合函數(shù)，可以指定多個，如果指定多個，則會分別對指定的values列應用對應的聚合函數(shù)
    fill_value=0,#將Nan空值設置為0，為了便于后面應用聚合函數(shù)造成異常，也可不設
    margins=True,#主要是對已經(jīng)分組透視好的數(shù)據(jù)values，最后進行縱向求和，得出一個匯總值
)
 
#2、對每一個values列應用不同的聚合函數(shù)
pd.pivot_table(
    df,#要生成透視圖的數(shù)據(jù)源
    index=['colA','colB','colC'],
    values=['colD','colE'],
    aggfunc={'colD':np.mean,'colE':len},#指定colD列使用mean聚合函數(shù)，colE列使用len聚合函數(shù)，字典格式
    #或者
    aggfunc={'colD':np.mean,'colE':[np.mean,np.sum,len]},#對colE列使用多個聚合函數(shù)
)
 
#3、使用自定義的聚合函數(shù)
#與分組與聚合一樣，也可以指定使用自定義的聚合函數(shù)，此時同理，也會將分組后每列的值作為參數(shù)傳入自定義函數(shù)
#以下實現(xiàn)了count的功能，即根據(jù)A分組，計算B列值對應各分組的記錄個數(shù)
def count(x):
    c=0
    for i in x:
        c+=1
    return c
pd.pivot_table(df,index=["A"],values=["B"],aggfunc=[count])
 
 
#4、數(shù)據(jù)透視表的篩選
tb=pd.pivot_table(df,index=['colA'])
tb.query('name == ["jacky"]')
#或
tb.query('name == ["jacky","dennis"]')