pandas之DataFrame

- DataFrame是一个【表格型】的数据结构。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。
- 创建DataFrame的方式
    - 列表
    - 字典
    - 系列
    - Numpy ndarrays
    - 另一个数据帧(DataFrame)
- DataFrame的参数
    - data   数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
    - index   对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值。
    - columns  对于列标签，可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。
    - dtype   每列的数据类型。
    - copy   如果默认值为False，则此命令(或任何它)用于复制数据。

data = [1,2,3,4,5]
df = pd.DataFrame(data)
print(df)

   0
0  1
1  2
2  3
3  4
4  5

# 列表套列表
data = [[‘Alex‘,10],[‘Bob‘,12],[‘Clarke‘,13]]
df = pd.DataFrame(data,columns=["name","age"],dtype=float) # dtype指定输出的数字类型,可加可不加
print(df)

     name   age
0    Alex  10.0
1     Bob  12.0
2  Clarke  13.0

- 所有的ndarrays必须具有相同的长度。如果传递了索引(index)，则索引的长度应等于数组的长度。
- 如果没有传递索引，则默认情况下，索引将为range(n)，其中n为数组长度。

import pandas as pd
data = {‘Name‘:[‘Tom‘, ‘Jack‘, ‘Steve‘, ‘Ricky‘],‘Age‘:[28,34,29,42]}
df = pd.DataFrame(data)
print(df)   # 0,1,2,3 就是range(数组)得到的值


    Name  Age
0    Tom   28
1   Jack   34
2  Steve   29
3  Ricky   42

import pandas as pd
data = {‘Name‘:[‘Tom‘, ‘Jack‘, ‘Steve‘, ‘Ricky‘],‘Age‘:[28,34,29,42]}
df = pd.DataFrame(data,index=[‘1‘,‘2‘,‘3‘,‘4‘])   # 指定索引
print(df)

    Name  Age
1    Tom   28
2   Jack   34
3  Steve   29
4  Ricky   42

# 字典列表可作为输入数据传递以用来创建数据帧(DataFrame)，
data = [{‘a‘: 1, ‘b‘: 2},{‘a‘: 5, ‘b‘: 10, ‘c‘: 20}]  # 字典键默认为列名,没有值得为NaN
df = pd.DataFrame(data,index=["first","second"])  # 自定义行索引
print(df)

        a   b     c
first   1   2   NaN
second  5  10  20.0

data = [{"name":"alex","age":87,"gender":"男"},{"name":"wuchao","age":20,"gender":"男"}]
df = pd.DataFrame(data,index=[1,2],columns=["name","age","gender"])  # 自定义行索引和列索引
print(df)

     name  age   gender
1    alex   87      男
2  wuchao   20      男

data = {
        "one":pd.Series(["1","2","3"],index=["a","b","c"],dtype=float), # 指定数字输出类型
        "tow":pd.Series(["1","2","3","4"],index=["a","b","c","d"])
       }
df = pd.DataFrame(data)
print(df)

   one tow
a  1.0   1
b  2.0   2
c  3.0   3
d  NaN   4

pd.DataFrame(np.random.randint(60,100,size=(3,4)))  # 60-100随机选择,3行4列


　　　0      1     2     3
0    95    74    71    92
1    95    91    79    98
2    94    87    62    65

pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","d"])  # 60-100随机选择,3行4列 指定行索引和列索引


　　　 a     b     c    d
A    91    70    63    98
B    98    68    88    96
C    99    77    86    66

res = pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","d"])
res.values   # 取出所有数据
res.index    # 取出行索引
res.columns  # 取出列索引
res.shape    # 显示当前数据是几行几列

============================================

练习

根据以下考试成绩表，创建一个DataFrame，命名为df：
```
    张三  李四  
语文 150  0
数学 150  0
英语 150  0
理综 300  0
```

============================================

dic = {
    "张三":[150,150,150,300],
    "李四":[0,0,0,0]
}
df = pd.DataFrame(dic,index=["语文","数学","英语","理综"])
df



       张三   李四
语文    150    0
数学    150    0
英语    150    0
理综    300    0    

(1) 对列进行索引

    - 通过类似字典的方式  df[‘q‘]
    - 通过属性的方式     df.q

 可以将DataFrame的列获取为一个Series。返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。

res = pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","d"])
res

      a     b    c     d
A    95    83    92    89
B    70    96    92    67
C    65    69    85    78

# 属性方式
res.a
A    95
B    70
C    65
Name: a, dtype: int32

# 字典方式
res["a"]
A    95
B    70
C    65
Name: a, dtype: int32

# 修改列索引
res.columns=["aa","bb","cc","dd"]
res
     aa    bb    cc    dd
A    76    90    91    78
B    80    81    82    85
C    93    70    63    81

# 读取前两列
res[["aa","bb"]]
     aa    bb
A    76    90
B    80    81
C    93    70

- 使用.loc[]加index来进行行索引
- 使用.iloc[]加整数来进行行索引
    
同样返回一个Series，index为原来的columns。

res = pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","d"])
res
      a    b     c     d
A    91    83    96    75
B    88    92    91    60
C    73    79    72    79

# loc方式
res.loc["A"]

a    91
b    83
c    96
d    75
Name: A, dtype: int32

# iloc方式
res.iloc[0]

a    91
b    83
c    96
d    75
Name: A, dtype: int32


res.loc[["A","B"]]

　　　　a    b     c     d
A    95    83    92    89
B    70    96    92    67

 - 使用列索引
 - 使用行索引(iloc[3,1] or loc[‘C‘,‘q‘]) 行索引在前，列索引在后

res = pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","d"])
res


      a     b    c     d
A    95    83    92    89
B    70    96    92    67
C    65    69    85    78    

res.iloc[2,3]  # 无论是行还是列 索引都是从0开始的  【78在表格中的2行3列的位置】

78

res.loc[["A","C"],"c"]  # 行数据取了A/C两行得数据,列取得c列的数据

A    92
C    85
Name: c, dtype: int32

【注意】
直接用中括号时：
- 索引表示的是列索引
- 切片表示的是行切片

res = pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","d"])
res


      a    b     c     d
A    64    60    82    97
B    64    74    63    90
C    88    68    60    71    

res[1:]   # 切片 表示的是行切片

        a    b    c    d
B    99    72    91    72
C    83    61    71    98    

res["c"]  # 索引表示的是列索引

A    82
B    63
C    60
Name: c, dtype: int32

res.iloc[1,1:3]  # 取第二行,b-c列的数据    顾头不顾尾
b    74
c    63
Name: B, dtype: int32

res.iloc[:,1:3]  # 取所有行,b-c列数据
      b    c
A    60    82
B    74    63
C    68    60

res.loc["A":"C","b":"c"]   # 取A-C行  b-c列数据
      b    c
A    60    82
B    74    63
C    68    60

DataFrame之间的运算

同Series一样：

- 在运算中自动对齐不同索引的数据
- 如果索引不对应，则补NaN

res = pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","d"])
ret = pd.DataFrame(np.random.randint(60,100,size=(3,4)),index=["A","B","C"],columns=["a","b","c","f"])
res + ret


      a      b      c      d      f
A    138    174    173    NaN    NaN
B    142    168    180    NaN    NaN
C    160    156    187    NaN    NaN