pd.DataFrame()函數解析

原文鏈接

DataFrame是Python中Pandas庫中的一種數據結構，它類似excel，是一種二維表。==

簡介

　　DataFrame的單元格可以存放數值、字符串等，這和excel表很像，同時DataFrame可以設置列名columns與行名index。

1、創建DataFrame

　　1.1函數創建

　　　　pandas常與numpy庫一起使用，所以通常會一起引用

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randn(3, 3), index=list('abc'), columns=list('ABC'))
print(df1)

#           A         B         C
# a -0.612978  0.237191  0.312969
# b -1.281485  1.135944  0.162456
# c  2.232905  0.200209  0.028671

　　  其中第一個參數是存放在DataFrame里的數據，第二個參數index就是之前說的行名，第三個參數columns是之前說的列名。

　　其中后兩個參數可以使用list輸入，但是注意，這個list的長度要和DataFrame的大小匹配，不然會報錯

df2 = pd.DataFrame(np.random.randn(3, 3), index=list('abcd'), columns=list('ABCD'))
# ValueError: Shape of passed values is (3, 3), indices imply (4, 4)

　　　當然，這兩個參數是可選的，你可以選擇不設置，而且這兩個list是可以一樣的。

df3 = pd.DataFrame(np.random.randn(3, 3), index=list('ABC'), columns=list('ABC'))

#           A         B         C
# A  1.106838  0.309086  0.748472
# B  0.439228 -0.213154 -1.438647
# C  0.292450  0.841237 -0.069207

　　　　1.2直接創建

import pandas as pd
import numpy as np

df4 = pd.DataFrame([[1, 2, 3], 
                    [2, 3, 4],
                    [3, 4, 5]],
                   index=list('abc'), columns=list('ABC'))
print(df4)

#    A  B  C
# a  1  2  3
# b  2  3  4
# c  3  4  5

　　　　1.3字典創建

import pandas as pd
import numpy as np

dic1 = {
    'name': [
        '張三', '李四', '王二麻子', '小淘氣'], 'age': [
            37, 30, 50, 16], 'gender': [
                '男', '男', '男', '女']}
df5 = pd.DataFrame(dic1)
print(df5)

#    age gender  name
# 0   37      男    張三
# 1   30      男    李四
# 2   50      男  王二麻子
# 3   16      女   小淘氣

2 DataFrame屬性

　　2.1 查看列的數據類型

print(df5.dtypes)

# age        int64
# gender    object
# name      object
# dtype: object

　　2.2 查看DataFrame的頭尾　　　　

　　　　使用head可以查看前幾行的數據，默認的是前5行，不過也可以自己設置。

　　　　使用tail可以查看后幾行的數據，默認也是5行，參數可以自己設置。

　　　　比如看前5行。

import pandas as pd
import numpy as np

df6 = pd.DataFrame(np.arange(36).reshape(6, 6), index=list('abcdef'), columns=list('ABCDEF'))
print(df6)
#     A   B   C   D   E   F
# a   0   1   2   3   4   5
# b   6   7   8   9  10  11
# c  12  13  14  15  16  17
# d  18  19  20  21  22  23
# e  24  25  26  27  28  29
# f  30  31  32  33  34  35

print(df6.head())
#     A   B   C   D   E   F
# a   0   1   2   3   4   5
# b   6   7   8   9  10  11
# c  12  13  14  15  16  17
# d  18  19  20  21  22  23
# e  24  25  26  27  28  29

　　　　比如只看前2行。

print(df6.head(2))

#    A  B  C  D   E   F
# a  0  1  2  3   4   5
# b  6  7  8  9  10  11

　　　　比如看后5行。

print(df6.tail())

#     A   B   C   D   E   F
# b   6   7   8   9  10  11
# c  12  13  14  15  16  17
# d  18  19  20  21  22  23
# e  24  25  26  27  28  29
# f  30  31  32  33  34  35

　　　　比如只看后2行。

print(df6.tail(2))

#     A   B   C   D   E   F
# e  24  25  26  27  28  29
# f  30  31  32  33  34  35

　　2.3 查看行名與列名

　　　　

print(df6.index)
print(df6.columns)

# Index(['a', 'b', 'c', 'd', 'e', 'f'], dtype='object')
# Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')

　　

　　2.4 查看數據值

　　　　使用values可以查看DataFrame里的數據值，返回的是一個數組。

print(df6.values)

# [[ 0  1  2  3  4  5]
#  [ 6  7  8  9 10 11]
#  [12 13 14 15 16 17]
#  [18 19 20 21 22 23]
#  [24 25 26 27 28 29]
#  [30 31 32 33 34 35]]

　　　　比如說查看某一列所有的數據值。

print(df6['B'].values)

[ 1  7 13 19 25 31]

　　　　如果查看某一行所有的數據值。使用iloc查看數據值（但是好像只能根據行來查看？），iloc是根據數字索引（也就是行號）。可以看一下博客pandas.iloc()函數解析。

print(df6.iloc[0])

# A    0
# B    1
# C    2
# D    3
# E    4
# F    5
# Name: a, dtype: int32

　　2.5 查看行列數

　　　　使用shape查看行列數，參數為0表示查看行數，參數為1表示查看列數。

print(df6.shape[0])
print(df6.shape[1])

# 6
# 6

　　2.6 切片

　　　　使用冒號進行切片。

print(df6['a':'b'])

#    A  B  C  D   E   F
# a  0  1  2  3   4   5
# b  6  7  8  9  10  11

 

　　2.7 索引

print(df6.loc[:,'A':'B'])

#     A   B
# a   0   1
# b   6   7
# c  12  13
# d  18  19
# e  24  25
# f  30  31

• 切片表示的是行切片
• 索引表示的是列索引

3 DataFrame操作

　　3.1 轉置

　　　　直接字母T，線性代數上線。

print(df6.T)

#    a   b   c   d   e   f
# A  0   6  12  18  24  30
# B  1   7  13  19  25  31
# C  2   8  14  20  26  32
# D  3   9  15  21  27  33
# E  4  10  16  22  28  34
# F  5  11  17  23  29  35

　　3.2 描述性統計

　　　　使用describe可以對數據根據列進行描述性統計。

print(df6.describe())

#                A          B          C          D          E          F
# count   6.000000   6.000000   6.000000   6.000000   6.000000   6.000000
# mean   15.000000  16.000000  17.000000  18.000000  19.000000  20.000000
# std    11.224972  11.224972  11.224972  11.224972  11.224972  11.224972
# min     0.000000   1.000000   2.000000   3.000000   4.000000   5.000000
# 25%     7.500000   8.500000   9.500000  10.500000  11.500000  12.500000
# 50%    15.000000  16.000000  17.000000  18.000000  19.000000  20.000000
# 75%    22.500000  23.500000  24.500000  25.500000  26.500000  27.500000
# max    30.000000  31.000000  32.000000  33.000000  34.000000  35.000000

　　　　如果有的列是非數值型的，那么就不會進行統計。

　　　　如果想對行進行描述性統計，轉置后再進行descr

 

　　3.3 計算

　　　　使用sum默認對每列求和，sum(1)為對每行求和。

print(df6.sum())
# A     90
# B     96
# C    102
# D    108
# E    114
# F    120
# dtype: int64

print(df6.sum(1))
# a     15
# b     51
# c     87
# d    123
# e    159
# f    195
# dtype: int64

　　　　數乘運算使用apply。

print(df6.apply(lambda x: x * 2))

#     A   B   C   D   E   F
# a   0   2   4   6   8  10
# b  12  14  16  18  20  22
# c  24  26  28  30  32  34
# d  36  38  40  42  44  46
# e  48  50  52  54  56  58
# f  60  62  64  66  68  70

　　　　乘方運算跟matlab類似，直接使用兩個*。

print(df6**2)

#      A    B     C     D     E     F
# a    0    1     4     9    16    25
# b   36   49    64    81   100   121
# c  144  169   196   225   256   289
# d  324  361   400   441   484   529
# e  576  625   676   729   784   841
# f  900  961  1024  1089  1156  1225

　　3.4 新增

　　　　擴充列可以直接像字典一樣，列名對應一個list，但是注意list的長度要跟index的長度一致。

df6['G']=['999','999','999','999','999','999']
print(df6)

#     A   B   C   D   E   F    G
# a   0   1   2   3   4   5  999
# b   6   7   8   9  10  11  999
# c  12  13  14  15  16  17  999
# d  18  19  20  21  22  23  999
# e  24  25  26  27  28  29  999
# f  30  31  32  33  34  35  999

　　　　還可以使用insert，使用這個方法可以指定把列插入到第幾列，其他的列順延。

df6.insert(0, 'QQ', ['999','999','999','999','999','999'])
print(df6)

#     QQ   A   B   C   D   E   F
# a  999   0   1   2   3   4   5
# b  999   6   7   8   9  10  11
# c  999  12  13  14  15  16  17
# d  999  18  19  20  21  22  23
# e  999  24  25  26  27  28  29
# f  999  30  31  32  33  34  35

　　3.5 合並

　　　　使用join可以將兩個DataFrame合並，但只根據行列名合並，並且以作用的那個DataFrame的為基准。

# 也就是以df6為基准。
df7 = pd.DataFrame(['my', 'name', 'is', 'a', 'b', 'c'], index=list('abcdef'), columns=list('G'))
df8 = df6.join(df7)
print(df8)

#     A   B   C   D   E   F     G
# a   0   1   2   3   4   5    my
# b   6   7   8   9  10  11  name
# c  12  13  14  15  16  17    is
# d  18  19  20  21  22  23     a
# e  24  25  26  27  28  29     b
# f  30  31  32  33  34  35     c

　　　　但是，join這個方法還有how這個參數可以設置，合並兩個DataFrame的交集或並集。參數為’inner’表示交集，'outer’表示並集。

df7 = pd.DataFrame(['2', '6', '7', '19', '44', '77'], index=list('abekld'), columns=list('G'))

df8=df6.join(df7,how='inner')
df9=df6.join(df7,how='outer')
print(df8)
#     A   B   C   D   E   F   G
# a   0   1   2   3   4   5   2
# b   6   7   8   9  10  11   6
# d  18  19  20  21  22  23  77
# e  24  25  26  27  28  29   7

print(df9)
#       A     B     C     D     E     F    G
# a   0.0   1.0   2.0   3.0   4.0   5.0    2
# b   6.0   7.0   8.0   9.0  10.0  11.0    6
# c  12.0  13.0  14.0  15.0  16.0  17.0  NaN
# d  18.0  19.0  20.0  21.0  22.0  23.0   77
# e  24.0  25.0  26.0  27.0  28.0  29.0    7
# f  30.0  31.0  32.0  33.0  34.0  35.0  NaN
# k   NaN   NaN   NaN   NaN   NaN   NaN   19
# l   NaN   NaN   NaN   NaN   NaN   NaN   44

　　　　如果要合並多個Dataframe，可以用list把幾個Dataframe裝起來，然后使用concat轉化為一個新的Dataframe。

df10 = pd.DataFrame([1, 2, 3, 4, 5, 6], 
                    index=list('ABCDEF'), columns=['a'])
df11 = pd.DataFrame([10, 20, 30, 40, 50, 60],
                    index=list('ABCDEF'), columns=['b'])
df12 = pd.DataFrame([100, 200, 300, 400, 500, 600],
                    index=list('ABCDEF'), columns=['c'])
list1 = [df10.T, df11.T, df12.T]
df13 = pd.concat(list1)
print(df13)

#      A    B    C    D    E    F
# a    1    2    3    4    5    6
# b   10   20   30   40   50   60
# c  100  200  300  400  500  600

　　3.6 去重

df.drop_duplicates(subset=None,
                   keep='first',
                   inplace=False
                   )

　　參數：

• subset：指定是哪些列重復。
• keep：去重后留下第幾行，{‘first’, ‘last’, False}, default ‘first’｝，如果是False，則去除全部重復的行。
• inplace：是否作用於原來的df。

df14 = pd.DataFrame(data=[[1, 2, 3],
                          [1, 2, 4],
                          [1, 2, 4],
                          [1, 2, 3],
                          [1, 2, 5],
                          [1, 2, 5]],
                    index=list('ABCDEF'),
                    columns=['a', 'b', 'c'])
print(df14)

#    a  b  c
# A  1  2  3
# B  1  2  4
# C  1  2  4
# D  1  2  3
# E  1  2  5
# F  1  2  5

　　　　去除重復行,保留重復行中最后一行

df14.drop_duplicates(keep='last')

#    a  b  c
# C  1  2  4
# D  1  2  3
# F  1  2  5

　　　　去除’c’列中有重復的值所在的行

print(df14.drop_duplicates(subset=('c',)))

#    a  b  c
# A  1  2  3
# B  1  2  4
# E  1  2  5