Python pandas學習總結

時間 2019-11-12

原文原文鏈接

　　原本打算學習pandas模塊，並寫一個博客記錄一下本身的學習，可是不知道怎麼了，最近好像有點急功近利，就想把別人的東西複製過來，小心沉下來，本身自覺地將本來寫滿的pandas學習筆記刪除了，此次打算寫上本身的學習記錄，這裏送給本身一句話，同時送給看這篇博客的人，共勉html

　　當你迷茫的時候，當你飽受煎熬的時候，請停下來，想一想本身學習的初衷，想一想本身寫博客的初衷，愛你所愛，行你所行，遵從你心，無問西東。java

　　好了，正文開始。python

　　pandas是作數據分析很是重要的一個模塊，它使得數據分析的工做變得更快更簡單。因爲現實世界中數據源的格式很是多，可是pandas也支持了不一樣數據格式的導入方法，因此學習pandas很是有必要。mysql

　　本文首先記錄一下本身學習read_csv的筆記，固然了本身須要用什麼，就學習什麼，而不是記錄人家read_csv的全部方法，要是想看全部的方法詳解能夠去官網，要想學習Pandas建議先看下面2個網站。c++

　　官網地址以下：https://pandas.pydata.org/sql

　　官網教程以下（十分鐘搞定pandas）：https://pandas.pydata.org/pandas-docs/stable/10min.html數據庫

　　NAN （數值數據類型的一類數），全稱Not a Number ，表示未定義或者不可表示的值。json

一：read_csv方法

1，準備CSV文件

Train_A_001.csv文件內容以下：api

0.916,4.37,-1.372,0.102,0.041,0.069,0.018
0.892,3.955,-1.277,0.015,-0.099,-0.066,0.018
0.908,3.334,-1.193,0.033,-0.098,-0.059,0.018
1.013,3.022,-1.082,0.151,0.015,0.035,0.018
1.111,2.97,-1.103,-0.048,-0.175,-0.171,0.019
1.302,3.043,-1.089,0.011,-0.085,-0.097,0.018
1.552,3.017,-1.052,0.066,-0.002,-0.036,0.019
1.832,2.796,-0.933,0.002,-0.028,-0.075,0.019
2.127,2.521,-0.749,0.011,0.041,-0.022,0.019
2.354,2.311,-0.623,-0.038,0.012,-0.056,0.019
2.537,2.024,-0.452,0.039,0.089,0.031,0.019
2.639,1.669,-0.277,-0.005,0.036,-0.008,0.019
2.707,1.314,-0.214,0.013,0.031,-0.005,0.019
2.81,0.926,-0.142,0.062,0.046,0.031,0.019

2，直接讀取文件內容

　　read_csv讀取的數據類型爲Dataframe，經過obj.dtypes能夠查看每列的數據類型數組

　　首先說一下，我這段csv文件是沒有列索引的，那麼個人讀取代碼以下能夠讀取到什麼呢？

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename)
print(data)

　　結果以下;

    0.916   4.37  -1.372  0.102  0.041  0.069  0.018
0   0.892  3.955  -1.277  0.015 -0.099 -0.066  0.018
1   0.908  3.334  -1.193  0.033 -0.098 -0.059  0.018
2   1.013  3.022  -1.082  0.151  0.015  0.035  0.018
3   1.111  2.970  -1.103 -0.048 -0.175 -0.171  0.019
4   1.302  3.043  -1.089  0.011 -0.085 -0.097  0.018
5   1.552  3.017  -1.052  0.066 -0.002 -0.036  0.019
6   1.832  2.796  -0.933  0.002 -0.028 -0.075  0.019
7   2.127  2.521  -0.749  0.011  0.041 -0.022  0.019
8   2.354  2.311  -0.623 -0.038  0.012 -0.056  0.019
9   2.537  2.024  -0.452  0.039  0.089  0.031  0.019
10  2.639  1.669  -0.277 -0.005  0.036 -0.008  0.019
11  2.707  1.314  -0.214  0.013  0.031 -0.005  0.019
12  2.810  0.926  -0.142  0.062  0.046  0.031  0.019

　　　　你們能夠發現，它默認你有列索引，而且把第一行的數據當作列索引，而且從第二行開始設置了行索引，因此說列索引的設置很是重要，起碼在這裏看來是這樣的，那麼如何設置呢，下面就具體分析一下。

3，列索引 header=？的含義

　　當加上header=None的時候，代表原始文件沒有列索引，這樣的話會默認自動加上，除非你給定名稱。結果以下：

        0      1      2      3      4      5      6
0   0.916  4.370 -1.372  0.102  0.041  0.069  0.018
1   0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
2   0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
3   1.013  3.022 -1.082  0.151  0.015  0.035  0.018
4   1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019
5   1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018
6   1.552  3.017 -1.052  0.066 -0.002 -0.036  0.019
7   1.832  2.796 -0.933  0.002 -0.028 -0.075  0.019
8   2.127  2.521 -0.749  0.011  0.041 -0.022  0.019
9   2.354  2.311 -0.623 -0.038  0.012 -0.056  0.019
10  2.537  2.024 -0.452  0.039  0.089  0.031  0.019
11  2.639  1.669 -0.277 -0.005  0.036 -0.008  0.019
12  2.707  1.314 -0.214  0.013  0.031 -0.005  0.019
13  2.810  0.926 -0.142  0.062  0.046  0.031  0.019

　　當加上header=0的時候，代表原始文件的第0行爲列索引。結果以下：

    0.916   4.37  -1.372  0.102  0.041  0.069  0.018
0   0.892  3.955  -1.277  0.015 -0.099 -0.066  0.018
1   0.908  3.334  -1.193  0.033 -0.098 -0.059  0.018
2   1.013  3.022  -1.082  0.151  0.015  0.035  0.018
3   1.111  2.970  -1.103 -0.048 -0.175 -0.171  0.019
4   1.302  3.043  -1.089  0.011 -0.085 -0.097  0.018
5   1.552  3.017  -1.052  0.066 -0.002 -0.036  0.019
6   1.832  2.796  -0.933  0.002 -0.028 -0.075  0.019
7   2.127  2.521  -0.749  0.011  0.041 -0.022  0.019
8   2.354  2.311  -0.623 -0.038  0.012 -0.056  0.019
9   2.537  2.024  -0.452  0.039  0.089  0.031  0.019
10  2.639  1.669  -0.277 -0.005  0.036 -0.008  0.019
11  2.707  1.314  -0.214  0.013  0.031 -0.005  0.019
12  2.810  0.926  -0.142  0.062  0.046  0.031  0.019

　　　從這段代碼咱們能夠發現，少了一行，因此第一行的代碼也被默認爲列索引。

　　當沒有列索引的時候，咱們也能夠本身指定索引名稱，方便本身記錄，代碼以下：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,header=None,names=('a','b','c','d','e','f','g'))
print(data)

　　經過上述代碼，咱們能夠指定列索引爲a~f，結果以下：

        a      b      c      d      e      f      g
0   0.916  4.370 -1.372  0.102  0.041  0.069  0.018
1   0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
2   0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
3   1.013  3.022 -1.082  0.151  0.015  0.035  0.018
4   1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019
5   1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018
6   1.552  3.017 -1.052  0.066 -0.002 -0.036  0.019
7   1.832  2.796 -0.933  0.002 -0.028 -0.075  0.019
8   2.127  2.521 -0.749  0.011  0.041 -0.022  0.019
9   2.354  2.311 -0.623 -0.038  0.012 -0.056  0.019
10  2.537  2.024 -0.452  0.039  0.089  0.031  0.019
11  2.639  1.669 -0.277 -0.005  0.036 -0.008  0.019
12  2.707  1.314 -0.214  0.013  0.031 -0.005  0.019
13  2.810  0.926 -0.142  0.062  0.046  0.031  0.019

4，行索引 index_col = ？的含義

　　從上面的代碼，咱們能夠發現，沒有行索引，只要設置了列索引就行，可是真的行索引不重要嗎，固然不是，有些時候有些需求也是須要列索引爲本身定義的名稱，這裏咱們一樣看待，並學習一下：

　　當設置行索引爲None的時候，也就是index_col = None，同時設置列索引的時候，代碼以下：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,index_col=None,header=None)
print(data)

　　結果呢，以下：

        0      1      2      3      4      5      6
0   0.916  4.370 -1.372  0.102  0.041  0.069  0.018
1   0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
2   0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
3   1.013  3.022 -1.082  0.151  0.015  0.035  0.018
4   1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019
5   1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018
6   1.552  3.017 -1.052  0.066 -0.002 -0.036  0.019
7   1.832  2.796 -0.933  0.002 -0.028 -0.075  0.019
8   2.127  2.521 -0.749  0.011  0.041 -0.022  0.019
9   2.354  2.311 -0.623 -0.038  0.012 -0.056  0.019
10  2.537  2.024 -0.452  0.039  0.089  0.031  0.019
11  2.639  1.669 -0.277 -0.005  0.036 -0.008  0.019
12  2.707  1.314 -0.214  0.013  0.031 -0.005  0.019
13  2.810  0.926 -0.142  0.062  0.046  0.031  0.019

　　固然了，當設置行索引爲0的時候，也就是index_col = 0，則第一列爲索引。

5，讀取指定csv的某一列 usecols = [?]

　　固然了，在作數據分析的許多時候，咱們會讀取指定的某一列，使用的函數以下：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,index_col=None,header=None,usecols=[1])
print(data)

　　上面意思是使用第一列數據（列表默認從0開始的啊），結果以下：

　　要想一塊兒讀取三列，則代碼以下：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,index_col=None,header=None,usecols=[1,2,3])
print(data)

　　結果以下：

        1      2      3
0   4.370 -1.372  0.102
1   3.955 -1.277  0.015
2   3.334 -1.193  0.033
3   3.022 -1.082  0.151
4   2.970 -1.103 -0.048
5   3.043 -1.089  0.011
6   3.017 -1.052  0.066
7   2.796 -0.933  0.002
8   2.521 -0.749  0.011
9   2.311 -0.623 -0.038
10  2.024 -0.452  0.039
11  1.669 -0.277 -0.005
12  1.314 -0.214  0.013
13  0.926 -0.142  0.062

6 讀取csv前幾行內容

　　使用data.head(n)返回文件的前n行內容，示例以下：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data1 = pd.read_csv(filename,index_col=None,header=None)
# print(data1)
#讀取文件的前5行
headdata = data1.head(5)
print(headdata)

　　運行效果，返回前5行全部數據內容：

       0      1      2      3      4      5      6
0  0.916  4.370 -1.372  0.102  0.041  0.069  0.018
1  0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
2  0.908  3.334 -1.193  0.033 -0.098 -0.059  0.018
3  1.013  3.022 -1.082  0.151  0.015  0.035  0.018
4  1.111  2.970 -1.103 -0.048 -0.175 -0.171  0.019

7，返回某行-全部列　

　　下面代碼表示了函數loc返回了第一行全部列的數據，也就是說第一行的數據：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,index_col=None,header=None)
# print(data1)
data1 = data.loc[0,:]
print(data1)

　　由此咱們能夠推斷出，某幾行-全部列的數據，代碼以下：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,index_col=None,header=None)
# print(data1)
# 返回第n行全部列的數據
data1 = data.loc[[1,3,5],:]
print(data1)

　　結果展現一下：

       0      1      2      3      4      5      6
1  0.892  3.955 -1.277  0.015 -0.099 -0.066  0.018
3  1.013  3.022 -1.082  0.151  0.015  0.035  0.018
5  1.302  3.043 -1.089  0.011 -0.085 -0.097  0.018

8，返回全部行-全部列

　　獲取全部行全部列，直接看代碼：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,index_col=None,header=None)
# print(data1)
# 返回第n行全部列的數據
data1 = data.loc[:,:]
print(data1)

　　結果就是全部行，全部列，這裏就不展現了。

9，返回某行-全部列

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data = pd.read_csv(filename,index_col=None,header=None)
# print(data1)
# 返回全部列-某行的數據
data1 = data.loc[:,0]
print(data1)

　　運行效果以下：

0     0.916
1     0.892
2     0.908
3     1.013
4     1.111
5     1.302
6     1.552
7     1.832
8     2.127
9     2.354
10    2.537
11    2.639
12    2.707
13    2.810
Name: 0, dtype: float64

10，數據統計

　　describe()統計下數據量，標準值，平均值，最大值等

data.describe()

　　就拿上面的csv文件爲例，讀取結果，解析以下：

import pandas as pd

filename = r'Train_A/Train_A_001.csv'

data1 = pd.read_csv(filename,index_col=None,header=None)
# print(data1)
print(data1.describe())

　　結果以下：

               0          1    ...              5          6
count  14.000000  14.000000    ...      14.000000  14.000000
mean    1.764286   2.662286    ...      -0.030643   0.018643
std     0.748950   0.957612    ...       0.063172   0.000497
min     0.892000   0.926000    ...      -0.171000   0.018000
25%     1.037500   2.095750    ...      -0.064250   0.018000
50%     1.692000   2.883000    ...      -0.029000   0.019000
75%     2.491250   3.037750    ...       0.022000   0.019000
max     2.810000   4.370000    ...       0.069000   0.019000

[8 rows x 7 columns]

11，pandas讀取csv後，獲取列標籤

　　好比csv文件內容以下：

cut,flute_1,flute_2,flute_3
1,32.31711361,48.89261732,37.72082548
2,37.914879,49.57081504,37.72082548
3,43.08790971,50.30286727,37.72082548
4,47.8590723,51.08365203,37.84985103
5,52.25032922,51.90828793,38.17266456
6,56.28276562,52.77212655,38.61755643
7,59.97661561,53.6707451,39.17455623
8,63.3512879,54.5999392,39.83415523
9,66.4253909,55.55571585,40.58729178

　　那麼，咱們讀取到的數據，通常來講，第一行是列標籤，但是如何獲取第一行的內容呢？以下：

column_headers = list(df.columns.values)

　　　以上面的csv文件爲例，讀取代碼以下：

import pandas as pd
import numpy as np

data = pd.read_csv(file1,header=0,index_col=0)
# print(data)
column_header = list(data.columns.values)
print(column_header)

　　結果以下：

['flute_1', 'flute_2', 'flute_3']

　　這樣咱們就獲取告終果。

12，取數據總結

以標籤（行、列的名字）爲索引選擇數據—— x.loc[行標籤,列標籤]
以位置（第幾行、第幾列）爲索引選擇數據—— x.iloc[行位置,列位置]
同時根據標籤和位置選擇數據——x.ix[行,列]

　　既然瞭解了pandas，之後也須要使用，那麼我就不止想學習讀取csv了，我還想學習基本的pandas數據結構，起碼之後使用會知道一些，下面學習一下pandas其的基本數據結構。

13，迅速獲取數據描述

　　~info() 獲取總行數，每一個屬性的類型，非空值的數量

14，獲取每一個值出現的次數

　　~value_counts() 獲取每一個值出現的次數。

housing["ocean_proximity"].value_counts()

# 輸出
<1H OCEAN     9136
INLAND        6551
NEAR OCEAN    2658
NEAR BAY      2290
ISLAND           5
Name: ocean_proximity, dtype: int64

15，scatter_matrix() 經過繪圖比較相關性

　　代碼以下：

from pandas.plotting import scatter_matrix

attributes = ["median_house_value", "median_income", "total_rooms",
              "housing_median_age"]
scatter_matrix(housing[attributes], figsize=(12, 8))
save_fig("scatter_matrix_plot")

16，~dropna() 返回略去丟失數據部分後的剩餘數據

sample_incomplete_rows.dropna(subset=["total_bedrooms"])

17，~fillna() 用指定的方法填充

# 用中位數填充
median = housing["total_bedrooms"].median()
sample_incomplete_rows["total_bedrooms"].fillna(median, inplace=True)

18，~factorize() 將數據轉換爲數值類型特徵

housing_cat = housing['ocean_proximity']
housing_cat.head(10)
# 輸出
# 17606     <1H OCEAN
# 18632     <1H OCEAN
# 14650    NEAR OCEAN
# 3230         INLAND
# 3555      <1H OCEAN
# 19480        INLAND
# 8879      <1H OCEAN
# 13685        INLAND
# 4937      <1H OCEAN
# 4861      <1H OCEAN
# Name: ocean_proximity, dtype: object

housing_cat_encoded, housing_categories = housing_cat.factorize()
housing_cat_encoded[:10]
# 輸出
# array([0, 0, 1, 2, 0, 2, 0, 2, 0, 0], dtype=int64)

二：pandas的基本數據結構

　　pandas是基於Numpy的一個很是好用的庫，正如名字同樣，人見人愛，之因此以下，就在於不管是讀取，處理數據，使用它都很是簡單。

　　pandas有兩種本身獨有的基本數據結構，即便如此，可是它依然只是Python的一個庫，因此Python中有的數據類型在這裏依然使用，一樣還可使用類本身定義的數據類型，只不過，pandas裏面又定義了兩種數據類型：Series和DataFrame。

1，Series

　　series就如同列表同樣，一系列數據，每一個數據對應於一個索引值，好比這樣一個列表：[9,3,8]，若是跟索引值寫到一塊兒，就是這樣：

　　這種樣式咱們已經熟悉了，不過有些時候，須要將其豎起來表示：

　　上面兩種，只是表現形式上的差異罷了。

Series就是「豎起來」的列表。舉個例子：

import pandas as pd
s = pd.Series([1,2,3,'python'])
s
0         1
1         2
2         3
3    python
dtype: object

　　另一點也很像列表，就是裏面的元素的類型，由咱們任意決定。

　　這裏，咱們實質上建立了一個Series對象，這個對象固然就有其屬性和方法了，好比下面兩個屬性依次能夠顯示Series對象的數據值和索引：

s.values
array([1, 2, 3, 'python'], dtype=object)
s.index
RangeIndex(start=0, stop=4, step=1)

　　因爲列表的索引只能是從0開始的整數，Series數據類型在默認狀況下，其索引也是如次，不過區別於列表的是，Series能夠自定義索引：

s = pd.Series(['java','python'],index=['1','2'])
s
1      java
2    python
dtype: object

　　自定義索引以後，咱們就能夠根據索引操做元素，series也能夠學習list操做：

s['1']
'java'

　　固然了，前面定義Series對象的是，用的是列表，即 Series() 方法的參數中，第一個列表就是其數據值，若是須要定義 index，放在後面，依然是一個列表。除了這種方法以外，還能夠用下面的方法定義 Series 對象：

s = {'python':800,'java':600,'c++':1000}
s = pd.Series(s)
s
python     800
java       600
c++       1000
dtype: int64

　　這樣的話，索引依然能夠自定義，pandas的優點就在這裏體現出來，若是自定義了索引，自定的索引會自動尋找原來的索引，若是同樣的話，就取代原來索引對應的值，這個能夠簡稱爲「自動對齊」，咱們舉例說明：

s = pd.Series(s,index=['python','java','c','c++'])
s
python     800.0
java       600.0
c            NaN
c++       1000.0
dtype: float64

　　在裏面，沒有c，可是索引參數中有，因而其餘可以「自動對齊」的照搬原值，依然能夠在新的Series對象的索引中存在，而且能夠自動爲其賦值NaN，若是pandas中沒有值，都對齊賦值給NaN，下面來一個更特殊的：

ilist = ['a','b','c']
s = pd.Series(s,index=ilist)
s
a   NaN
b   NaN
c   NaN
dtype: float64

　　這樣的話，新獲得的Series對象索引與s對象的值一個也不對應，因此都是NaN。pandas有專門的方法來判斷值是否爲空。

pd.isnull(s)
a    True
b    True
c    True
dtype: bool

　　也能夠判斷不爲空：

pd.notnull(s)
a    False
b    False
c    False
dtype: bool

　　固然了，也能夠對索引的名字，從新定義：

s = [1,2,3,4]
s = pd.Series(s,index=['python','java','c','c++'])
s
python    1
java      2
c         3
c++       4
dtype: int64
s.index = ['a','b','c','d']
s
a    1
b    2
c    3
d    4
dtype: int64

2，DataFrame　　

　　DataFrame是一個表格型的數據結構，它含有一組有序的列，每類能夠是不一樣的值類型（數值，字符串，布爾值）。DataFrame既有行索引也有列索引，它能夠被看作由Series組成的字典（共同使用同一個索引）。跟其餘相似的數據結構相比（如R的data.frame)DataFrame中面向行和麪向列的操做基本上是平衡的，其實DataFrame中的數據是以一個或者多個二維塊存放的（而不是列表，字典或者其餘一維數據結構）。

　　DataFrame 是一種二維的數據結構，很是接近於電子表格或者相似 mysql 數據庫的形式。它的豎行稱之爲 columns，橫行跟前面的 Series 同樣，稱之爲 index，也就是說能夠經過 columns 和 index 來肯定一個主句的位置。（有人把 DataFrame 翻譯爲「數據框」，是否是還能夠稱之爲「筐」呢？向裏面裝數據嘛。)

　　首先給一個例子：

>>> import pandas as pd 
>>> from pandas import Series, DataFrame 

>>> data = {"name":["yahoo","google","facebook"], "marks":
[200,400,800], "price":[9, 3, 7]} 
>>> f1 = DataFrame(data) 
>>> f1 
     marks  name      price 
0    200    yahoo     9 
1    400    google    3 
2    800    facebook  7

　　這是定義一個 DataFrame 對象的經常使用方法——使用 dict 定義。字典的「鍵」（"name"，"marks"，"price"）就是 DataFrame 的 columns 的值（名稱），字典中每一個「鍵」的「值」是一個列表，它們就是那一豎列中的具體填充數據。上面的定義中沒有肯定索引，因此，按照慣例（Series 中已經造成的慣例）就是從 0 開始的整數。從上面的結果中很明顯表示出來，這就是一個二維的數據結構（相似 excel 或者 mysql 中的查看效果）。

　　上面的數據顯示中，columns 的順序沒有規定，就如同字典中鍵的順序同樣，可是在 DataFrame 中，columns 跟字典鍵相比，有一個明顯不一樣，就是其順序能夠被規定，向下面這樣作：

>>> f2 = DataFrame(data, columns=['name','price','marks']) 
>>> f2 
       name     price  marks 
0     yahoo     9      200 
1    google     3      400 
2  facebook     7      800

　　跟Series相似的，DataFrame數據的索引也能夠自定義：

>>> f3 = DataFrame(data, columns=['name', 'price', 'marks', 'debt'], index=['a','b','c']) 
>>> f3 
       name      price  marks  debt 
a     yahoo      9      200     NaN 
b    google      3      400     NaN 
c  facebook      7      800     NaN

　　你們還要注意觀察上面的顯示結果。由於在定義 f3 的時候，columns 的參數中，比以往多了一項('debt')，可是這項在 data 這個字典中並無，因此 debt 這一豎列的值都是空的，在 Pandas 中，空就用 NaN 來表明了。

　　定義 DataFrame 的方法，除了上面的以外，還可使用「字典套字典」的方式。

>>> newdata = {"lang":{"firstline":"python","secondline":"java"}, "price":{"firstline":8000}} 
>>> f4 = DataFrame(newdata) 
>>> f4 
              lang     price 
firstline     python   8000 
secondline    java     NaN

　　在字典中就規定好數列名稱（第一層鍵）和每橫行索引（第二層字典鍵）以及對應的數據（第二層字典值），也就是在字典中規定好了每一個數據格子中的數據，沒有規定的都是空。

>>> DataFrame(newdata, index=["firstline","secondline","thirdline"]) 
              lang     price 
firstline     python   8000 
secondline    java     NaN 
thirdline     NaN      NaN

　　若是額外肯定了索引，就如同上面顯示同樣，除非在字典中有相應的索引內容，不然都是 NaN。

　　前面定義了 DataFrame 數據（能夠經過兩種方法），它也是一種對象類型，好比變量 f3 引用了一個對象，它的類型是 DataFrame。承接之前的思惟方法：對象有屬性和方法。

>>> f3.columns 
Index(['name', 'price', 'marks', 'debt'], dtype=object)

　　DataFrame 對象的 columns 屬性，可以顯示素有的 columns 名稱。而且，還能用下面相似字典的方式，獲得某豎列的所有內容（固然包含索引）：

>>> f3['name'] 
a       yahoo 
b      google 
c    facebook 
Name: name

　　這是什麼？這其實就是一個 Series，或者說，能夠將 DataFrame 理解爲是有一個一個的 Series 組成的。

　　一直耿耿於懷沒有數值的那一列，下面的操做是統一給那一列賦值：

>>> f3['debt'] = 89.2 
>>> f3 
       name     price  marks  debt 
a     yahoo     9        200  89.2 
b    google     3        400  89.2 
c  facebook     7        800  89.2

　　除了可以統一賦值以外，還可以「點對點」添加數值，結合前面的 Series，既然 DataFrame 對象的每豎列都是一個 Series 對象，那麼能夠先定義一個 Series 對象，而後把它放到 DataFrame 對象中。以下：

>>> sdebt = Series([2.2, 3.3], index=["a","c"])    #注意索引 
>>> f3['debt'] = sdebt

　　將 Series 對象(sdebt 變量所引用) 賦給 f3['debt']列，Pandas 的一個重要特性——自動對齊——在這裏起作用了，在 Series 中，只有兩個索引（"a","c"），它們將和 DataFrame 中的索引自動對齊。因而乎：

>>> f3 
       name  price  marks  debt 
a     yahoo  9        200   2.2 
b    google  3        400   NaN 
c  facebook  7        800   3.3

　　自動對齊以後，沒有被複制的依然保持 NaN。

　　還能夠更精準的修改數據嗎？固然能夠，徹底仿照字典的操做：

>>> f3["price"]["c"]= 300 
>>> f3 
       name   price   marks  debt 
a     yahoo   9       200    2.2 
b    google   3       400    NaN 
c  facebook   300     800    3.3

3，pandas.DataFrame.values

　　DataFrame.values 返回DataFrame的Numpy表示形式

　　僅返回DataFrame中的值，將刪除軸標籤

示例一：

　　全部列都是相同類型（例如：int64）的DataFrame會生成相同類型的數組。

>>> df = pd.DataFrame({'age':    [ 3,  29],
...                    'height': [94, 170],
...                    'weight': [31, 115]})
>>> df
   age  height  weight
0    3      94      31
1   29     170     115
>>> df.dtypes
age       int64
height    int64
weight    int64
dtype: object
>>> df.values
array([[  3,  94,  31],
       [ 29, 170, 115]], dtype=int64)

示例二：

　　具備混合類型列的DataFrame（例如，str / object，int64，float32）致使最寬泛類型的ndarray，其適應這些混合類型（例如，對象）。

>>> df2 = pd.DataFrame([('parrot',   24.0, 'second'),
...                     ('lion',     80.5, 1),
...                     ('monkey', np.nan, None)],
...                   columns=('name', 'max_speed', 'rank'))
>>> df2.dtypes
name          object
max_speed    float64
rank          object
dtype: object
>>> df2.values
array([['parrot', 24.0, 'second'],
       ['lion', 80.5, 1],
       ['monkey', nan, None]], dtype=object)

三，DataFrame切片大全（包含多重索引）

　　這節主要學習如何對pandas的DataFrame進行切片，包括取某行，某列，某幾行，某幾列以及多重索引的取數方法。

測試的CSV文件以下（test.csv）：

注意：測試數據沒有行標題和列標題

2.95072,3.37973,3.03758,0.711681,3.37973,3.37973
2.95072,3.37973,3.03758,0.711681,3.37973,3.37973
3.19946,3.72793,3.22612,0.899132,3.72793,3.72793
3.23699,3.72295,3.29885,0.988473,3.72295,3.72295
3.23179,3.71829,3.29314,0.96549,3.71829,3.71829
3.29573,3.76237,3.32046,0.978557,3.76237,3.76237
3.32537,3.82346,3.35758,1.04363,3.82346,3.82346
3.34407,3.87181,3.38804,1.05891,3.87181,3.87181
3.4196,3.88913,3.44196,1.12763,3.88913,3.88913
3.3904,3.87997,3.42206,1.10885,3.87997,3.87997

　　首先說明一下，直接read_csv和轉換爲DataFrame的效果，

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
print(type(filecontent))
df = pd.DataFrame(filecontent)
print(type(df))

　　先看結果：

<class 'pandas.core.frame.DataFrame'>
<class 'pandas.core.frame.DataFrame'>

　　從結果來看，因此說兩個效果是同樣的，轉不轉換都同樣。

1，取DataFrame的某列三種方法

　直接拿第四列的數據（列表默認從0開始取），代碼以下：

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None)
df = pd.DataFrame(filecontent,index=None)
index4 = df.iloc[:,3]
print(index4)

　　結果：

0    0.711681
1    0.711681
2    0.899132
3    0.988473
4    0.965490
5    0.978557
6    1.043630
7    1.058910
8    1.127630
9    1.108850
Name: 3, dtype: float64

　　當加上索引，就取索引，兩個效果是同樣的，代碼以下：

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
print(filecontent.a)
print(filecontent['a'])

　　結果：

0    2.95072
1    2.95072
2    3.19946
3    3.23699
4    3.23179
5    3.29573
6    3.32537
7    3.34407
8    3.41960
9    3.39040
Name: a, dtype: float64
0    2.95072
1    2.95072
2    3.19946
3    3.23699
4    3.23179
5    3.29573
6    3.32537
7    3.34407
8    3.41960
9    3.39040
Name: a, dtype: float64

2，取DataFrame某幾列的兩種方法

　　使用索引和不適用索引取多列的方法

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
df = pd.DataFrame(filecontent)
# 取某幾列的方法一使用索引
result = df[['b','c']]
print(result)

# 取某幾列的方法一不使用索引取前兩列
result1 = df.iloc[:,:2]
print(result1)

　　結果：

         b        c
0  3.37973  3.03758
1  3.37973  3.03758
2  3.72793  3.22612
3  3.72295  3.29885
4  3.71829  3.29314
5  3.76237  3.32046
6  3.82346  3.35758
7  3.87181  3.38804
8  3.88913  3.44196
9  3.87997  3.42206
         a        b
0  2.95072  3.37973
1  2.95072  3.37973
2  3.19946  3.72793
3  3.23699  3.72295
4  3.23179  3.71829
5  3.29573  3.76237
6  3.32537  3.82346
7  3.34407  3.87181
8  3.41960  3.88913
9  3.39040  3.87997

3，取DataFrame的某行三種方法

　　代碼以下;

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
df = pd.DataFrame(filecontent)
# 取某幾行的方法一使用索引
result = df[1:2]
print(result)

print('************************************************')
# 取某幾列的方法一不使用索引取第一行
result1 = df.ix[1]
print(result1)
print('************************************************')
# 取某幾列的方法一不使用索引取第一行
result2 = df.iloc[1,:]
print(result2)

　　結果以下：

         a        b        c         d        e        f
1  2.95072  3.37973  3.03758  0.711681  3.37973  3.37973
************************************************
a    2.950720
b    3.379730
c    3.037580
d    0.711681
e    3.379730
f    3.379730
Name: 1, dtype: float64
************************************************
a    2.950720
b    3.379730
c    3.037580
d    0.711681
e    3.379730
f    3.379730
Name: 1, dtype: float64

4，取DataFrame的某幾行的方法

　　代碼以下：

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'],index_col=None)
df = pd.DataFrame(filecontent)

# 取某幾行的方法一不使用索引取前兩行
result1 = df.iloc[:2,]
print(result1)

　　結果以下：

         a        b        c         d        e        f
0  2.95072  3.37973  3.03758  0.711681  3.37973  3.37973
1  2.95072  3.37973  3.03758  0.711681  3.37973  3.37973

5，取DataFrame的某特定位置元素的方法

　　代碼以下：

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'],index_col=None)
df = pd.DataFrame(filecontent)

# 取DataFrame的某特定位置元素的方法
result = df.ix[1,2]
print(result)

　　結果以下：

3.0375799999999997

6，取DataFrame的多行多列的方法

　　代碼以下：

import pandas as pd

filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'],index_col=None)
df = pd.DataFrame(filecontent)

# 取DataFrame的多行多列的方法
# 取前兩行，前三列
result = df.ix[:2,:3]
print(result)

# 取前兩行，前三列
result1 = df.iloc[:2,:3]
print(result1)

　　結果以下：

         a        b        c
0  2.95072  3.37973  3.03758
1  2.95072  3.37973  3.03758
2  3.19946  3.72793  3.22612
         a        b        c
0  2.95072  3.37973  3.03758
1  2.95072  3.37973  3.03758

四，Pandas其餘方法

1，刪除（drop）方法

　　刪除Series的元素或者DataFrame的某一行（列）的意思，經過對象的方法，刪除Series的一個元素。

　　其方法調用以下：

 def drop(self, labels=None, axis=0, index=None, columns=None,
             level=None, inplace=False, errors='raise'):

　　對象的 .drop(labels, axis=0) 方法返回的是一個新對象，元對象不會被改變。

1.1 刪除Series的一個元素

In[11]: ser = Series([4.5,7.2,-5.3,3.6], index=['d','b','a','c'])
In[13]: ser.drop('c')
Out[13]:
d 4.5
b 7.2
a -5.3
dtype: float64

1.2 刪除DataFrame的行或者列

　　drop函數默認刪除行，列須要加axis = 1

In[17]: df = DataFrame(np.arange(9).reshape(3,3), index=['a','c','d'], columns=['oh','te','ca'])
In[18]: df
Out[18]:
oh te ca
a 0 1 2
c 3 4 5
d 6 7 8
In[19]: df.drop('a')
Out[19]:
oh te ca
c 3 4 5
d 6 7 8
In[20]: df.drop(['oh','te'],axis=1)
Out[20]:
ca
a 2
c 5
d 8

1.3 drop函數的inplace參數

　　採用drop方法，有下面三種等價的表達式　

1. DF= DF.drop('column_name', axis=1)；

2. DF.drop('column_name',axis=1, inplace=True)

3. DF.drop([DF.columns[[0,1, 3]]], axis=1, inplace=True)   # Note: zero indexed

　　注意：凡是會對原數組作出修改並返回一個新數組的，每每都會有一個inplace可選參數。若是手動設定位True（默認爲False），那麼原數組就直接被替換。也就是說，採用inplace = True以後，原數組名如（狀況2 和3 所示）對應的內存值直接改變。

　　而採用inplace =False 以後，原數組名對應的內存值並不改變，須要將新的結果賦給一個新的數組或者覆蓋原數組的內存位置。

1.4 drop函數的使用：數據類型轉換

df['Name'] = df['Name'].astype(np.datetime64)

　　DataFrame.astype() 方法可對整個DataFrame或某一列進行數據格式轉換，支持Python和NumPy的數據類型。

2，python合併兩個csv文件（列合併）

　　注意：要合併的兩個文件行數須要相同，若不一樣可指定數組下標使其相同

代碼以下：

# _*_ coding:utf-8 _*_
import csv

aFile = open('a.csv', 'r')
aInfo = csv.reader(aFile)

bfile = open('b.csv', 'r')
bInfo = csv.reader(bfile)

cfile = open('c.csv', 'w')
abcsv = csv.writer(cfile, dialect='excel')

a=[]
a=list()

b=[]
b=list()

for info in aInfo:
    a.append(info)

for info in bInfo:
    b.append(info )

for index in range(len(b)):  
    a[index+1].extend(b[index])
    abcsv.writerow(a[index+1])

3，python合併（拼接）多個csv文件

　　當作數據分析與挖掘的時候，常常遇到要合併CSV文件的問題，因此此處記錄一下使用python中的Pandas庫進行拼接。

import pandas as pd
import os

orgin_dir = "Train_A"
result_dir = "result_A"
for filename in os.listdir(orgin_dir):
    print(filename)
    # header=None表示原始文件數據沒有列索引，這樣的話read_csv會自動加上列索引
    a = pd.read_csv('Train_A/'+filename,header=None)
    # header=0表示不保留列名，index=False表示不保留行索引，mode='a'表示附加方式寫入，文件原有內容不會被清除
    a.to_csv('all.csv',mode='a',index=False,header=False)

import pandas as pd
import os

orgin_dir = "Train_A"
result_dir = "result_A"
for filename in os.listdir(orgin_dir):
    print(filename)
    # header=None表示原始文件數據沒有列索引，這樣的話read_csv會自動加上列索引
    pd.read_csv('Train_A/'+filename,header=None)
    # header=0表示不保留列名，index=False表示不保留行索引，mode='a'表示附加方式寫入，文件原有內容不會被清除
    pd.to_csv('all.csv',mode='a',index=False,header=False)

4，排序sort_values 和sort_index

　　排序是按照某一列的大小進行排序，Python3.x目前提供兩個函數

4.1 sort_index

　　這個函數彷佛不建議使用了，推薦使用sort_values，詳情參考：官方文檔

## 參數
sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
#### 參數說明
axis：0按照行名排序；1按照列名排序
level：默認None，不然按照給定的level順序排列---貌似並非，文檔
ascending：默認True升序排列；False降序排列
inplace：默認False，不然排序以後的數據直接替換原來的數據框
kind：默認quicksort，排序的方法
na_position：缺失值默認排在最後{"first","last"}
by：按照那一列數據進行排序，可是by參數貌似不建議使用

　　舉例：

## 對x1列升序排列，x2列升序。處理x1有相同值的狀況  
import pandas as pd  
x = pd.DataFrame({"x1":[1,2,2,3],"x2":[4,3,2,1]})  
x.sort_index(by = ["x1","x2"],ascending = [False,True])

4.2 sort_values

## 參數    
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')  
#### 參數說明    
axis:{0 or ‘index’, 1 or ‘columns’}, default 0，默認按照索引排序，即縱向排序，若是爲1，則是橫向排序    
by:str or list of str；若是axis=0，那麼by="列名"；若是axis=1，那麼by="行名"；  
ascending:布爾型，True則升序，能夠是[True,False]，即第一字段升序，第二個降序  
inplace:布爾型，是否用排序後的數據框替換現有的數據框  
kind:排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。彷佛不用太關心  
na_position : {‘first’, ‘last’}, default ‘last’，默認缺失值排在最後面

## 沿着軸方向按指定值排序  
x.sort_values(by="x1",ascending= False)

## 沿着行方向按指定行排序  
x.sort_values(by = 1,ascending=False,axis=1)

五，Pandas速查手冊（翻譯官網）

　　此外，在學習的時候，我參考了別人的知乎內容，並查看官網，而後彙總了pandas官網中比較經常使用的函數和方法，以方便本身記憶。其實這個比較全面的歸納了pandas的全部知識點，只不過沒有舉例子，可是要是認真看了我上面的兩個大的例子，學習下面的知識點，根本不費吹灰之力。

1，關鍵縮寫和包的導入

　　首先，咱們使用以下的縮寫：

df：任意的Pandas DataFrame對象

s：任意的Pandas Series對象

　　同時導入pandas包和numpy包

import pandas as pd
import numpy as np

　　當看到np和pd的時候，咱們就知道其是什麼含義（這些縮寫都是你們默認的）。

2，導入數據

pd.read_csv(filename)：從CSV文件導入數據
pd.read_table(filename)：從限定分隔符的文本文件導入數據
pd.read_excel(filename)：從Excel文件導入數據
pd.read_sql(query, connection_object)：從SQL表/庫導入數據
pd.read_json(json_string)：從JSON格式的字符串導入數據
pd.read_html(url)：解析URL、字符串或者HTML文件，抽取其中的tables表格
pd.read_clipboard()：從你的粘貼板獲取內容，並傳給read_table()
pd.DataFrame(dict)：從字典對象導入數據，Key是列名，Value是數據

原文：

pd.read_csv(filename) | From a CSV file
pd.read_table(filename) | From a delimited text file (like TSV)
pd.read_excel(filename) | From an Excel file
pd.read_sql(query, connection_object) | Read from a SQL table/database
pd.read_json(json_string) | Read from a JSON formatted string, URL or file.
pd.read_html(url) | Parses an html URL, string or file and extracts tables to a list of dataframes
pd.read_clipboard() | Takes the contents of your clipboard and passes it to read_table()
pd.DataFrame(dict) | From a dict, keys for columns names, values for data as lists

3，導出數據

df.to_csv(filename)：導出數據到CSV文件
df.to_excel(filename)：導出數據到Excel文件
df.to_sql(table_name, connection_object)：導出數據到SQL表
df.to_json(filename)：以Json格式導出數據到文本文件

原文：

df.to_csv(filename) | Write to a CSV file
df.to_excel(filename) | Write to an Excel file
df.to_sql(table_name, connection_object) | Write to a SQL table
df.to_json(filename) | Write to a file in JSON format

4，建立測試對象

pd.DataFrame(np.random.rand(20,5))：建立20行5列的隨機數組成的DataFrame對象
pd.Series(my_list)：從可迭代對象my_list建立一個Series對象
df.index = pd.date_range('1900/1/30', periods=df.shape[0])：增長一個日期索引

原文：

pd.DataFrame(np.random.rand(20,5)) | 5 columns and 20 rows of random floats
pd.Series(my_list) | Create a series from an iterable my_list
df.index = pd.date_range('1900/1/30', periods=df.shape[0]) | Add a date index

5，查看，檢查數據

df.head(n)：查看DataFrame對象的前n行
df.tail(n)：查看DataFrame對象的最後n行
df.shape()：查看行數和列數
df.info()：查看索引、數據類型和內存信息
df.describe()：查看數值型列的彙總統計
s.value_counts(dropna=False)：查看Series對象的惟一值和計數
df.apply(pd.Series.value_counts)：查看DataFrame對象中每一列的惟一值和計數

原文：

df.head(n) | First n rows of the DataFrame
df.tail(n) | Last n rows of the DataFrame
df.shape | Number of rows and columns
df.info() | Index, Datatype and Memory information
df.describe() | Summary statistics for numerical columns
s.value_counts(dropna=False) | View unique values and counts
df.apply(pd.Series.value_counts) | Unique values and counts for all columns

6，數據選取

df[col]：根據列名，並以Series的形式返回列
df[[col1, col2]]：以DataFrame形式返回多列
s.iloc[0]：按位置選取數據
s.loc['index_one']：按索引選取數據
df.iloc[0,:]：返回第一行
df.iloc[0,0]：返回第一列的第一個元素

原文：

df[col] | Returns column with label col as Series
df[[col1, col2]] | Returns columns as a new DataFrame
s.iloc[0] | Selection by position
s.loc['index_one'] | Selection by index
df.iloc[0,:] | First row
df.iloc[0,0] | First element of first column

7，數據清理

df.columns = ['a','b','c']：重命名列名
pd.isnull()：檢查DataFrame對象中的空值，並返回一個Boolean數組
pd.notnull()：檢查DataFrame對象中的非空值，並返回一個Boolean數組
df.dropna()：刪除全部包含空值的行
df.dropna(axis=1)：刪除全部包含空值的列
df.dropna(axis=1,thresh=n)：刪除全部小於n個非空值的行
df.fillna(x)：用x替換DataFrame對象中全部的空值
s.astype(float)：將Series中的數據類型更改成float類型
s.replace(1,'one')：用‘one’代替全部等於1的值
s.replace([1,3],['one','three'])：用'one'代替1，用'three'代替3
df.rename(columns=lambda x: x + 1)：批量更改列名
df.rename(columns={'old_name': 'new_ name'})：選擇性更改列名
df.set_index('column_one')：更改索引列
df.rename(index=lambda x: x + 1)：批量重命名索引

原文：

df.columns = ['a','b','c'] | Rename columns
pd.isnull() | Checks for null Values, Returns Boolean Arrray
pd.notnull() | Opposite of pd.isnull()
df.dropna() | Drop all rows that contain null values
df.dropna(axis=1) | Drop all columns that contain null values
df.dropna(axis=1,thresh=n) | Drop all rows have have less than n non null values
df.fillna(x) | Replace all null values with x
s.fillna(s.mean()) | Replace all null values with the mean (mean can be replaced with almost any function from the statistics section)
s.astype(float) | Convert the datatype of the series to float
s.replace(1,'one') | Replace all values equal to 1 with 'one'
s.replace([1,3],['one','three']) | Replace all 1 with 'one' and 3 with 'three'
df.rename(columns=lambda x: x + 1) | Mass renaming of columns
df.rename(columns={'old_name': 'new_ name'}) | Selective renaming
df.set_index('column_one') | Change the index
df.rename(index=lambda x: x + 1) | Mass renaming of index

8，數據處理：Filter，Sort和GroupBy

df[df[col] > 0.5]：選擇col列的值大於0.5的行
df.sort_values(col1)：按照列col1排序數據，默認升序排列
df.sort_values(col2, ascending=False)：按照列col1降序排列數據
df.sort_values([col1,col2], ascending=[True,False])：先按列col1升序排列，後按col2降序排列數據
df.groupby(col)：返回一個按列col進行分組的Groupby對象
df.groupby([col1,col2])：返回一個按多列進行分組的Groupby對象
df.groupby(col1)[col2]：返回按列col1進行分組後，列col2的均值
df.pivot_table(index=col1, values=[col2,col3], aggfunc=max)：建立一個按列col1進行分組，並計算col2和col3的最大值的數據透視表
df.groupby(col1).agg(np.mean)：返回按列col1分組的全部列的均值
data.apply(np.mean)：對DataFrame中的每一列應用函數np.mean
data.apply(np.max,axis=1)：對DataFrame中的每一行應用函數np.max

原文：

df[df[col] > 0.5] | Rows where the column col is greater than 0.5
df[(df[col] > 0.5) & (df[col] < 0.7)] | Rows where 0.7 > col > 0.5
df.sort_values(col1) | Sort values by col1 in ascending order
df.sort_values(col2,ascending=False) | Sort values by col2 in descending order
df.sort_values([col1,col2],ascending=[True,False]) | Sort values by col1 in ascending order then col2 in descending order
df.groupby(col) | Returns a groupby object for values from one column
df.groupby([col1,col2]) | Returns groupby object for values from multiple columns
df.groupby(col1)[col2] | Returns the mean of the values in col2, grouped by the values in col1 (mean can be replaced with almost any function from the statistics section)
df.pivot_table(index=col1,values=[col2,col3],aggfunc=mean) | Create a pivot table that groups by col1 and calculates the mean of col2 and col3
df.groupby(col1).agg(np.mean) | Find the average across all columns for every unique col1 group
df.apply(np.mean) | Apply the function np.mean() across each column
nf.apply(np.max,axis=1) | Apply the function np.max() across each row

9，數據合併

df1.append(df2)：將df2中的行添加到df1的尾部
df.concat([df1, df2],axis=1)：將df2中的列添加到df1的尾部
df1.join(df2,on=col1,how='inner')：對df1的列和df2的列執行SQL形式的join

原文：

df1.append(df2) | Add the rows in df1 to the end of df2 (columns should be identical)
pd.concat([df1, df2],axis=1) | Add the columns in df1 to the end of df2 (rows should be identical)
df1.join(df2,on=col1,how='inner') | SQL-style join the columns in df1 with the columns on df2 where the rows for col have identical values. how can be one of 'left', 'right', 'outer', 'inner'

10，數據統計

df.describe()：查看數據值列的彙總統計
df.mean()：返回全部列的均值
df.corr()：返回列與列之間的相關係數
df.count()：返回每一列中的非空值的個數
df.max()：返回每一列的最大值
df.min()：返回每一列的最小值
df.median()：返回每一列的中位數
df.std()：返回每一列的標準差

原文：

df.describe() | Summary statistics for numerical columns
df.mean() | Returns the mean of all columns
df.corr() | Returns the correlation between columns in a DataFrame
df.count() | Returns the number of non-null values in each DataFrame column
df.max() | Returns the highest value in each column
df.min() | Returns the lowest value in each column
df.median() | Returns the median of each column
df.std() | Returns the standard deviation of each column

參考http://wiki.jikexueyuan.com/project/start-learning-python/311.html

https://zhuanlan.zhihu.com/p/25630700

https://www.dataquest.io/blog/pandas-cheat-sheet/