Pandas数据结构之创建DataFrame

DataFrame 是一种二维标签数据结构，其中的列可以是不同的类型。 可以把它想象成电子表格或 SQL 表，或者是一个包含一系列 Series 对象的 dict。 一般来说，它是最常用的 pandas 对象。 与 Series 一样，DataFrame 也接受多种不同类型的输入

常见创建方式

基本api：

pd.DataFrame(data, index, columns)

使用字典创建

当使用字典创建DataFrame对象时，字典的键作为DataFrame的column 名称（也就是Series对象的name属性），字典的值作为列的值，有多少个键值对，创建的DataFrame就会有多少个列，即Series对象。当指定了index以及columns时，index和columns中指定的内容会与字典中的对齐，其中index是DataFrame的行索引，columns是DataFrame的列索引

直接传入一个字典

当直接传入一个字典，字典中的每一项都是一个Series对象时，如果Series之间的索引不相同，则默认创建的DataFrame中每个Series为字典中所有Series的并集

d = {
    "one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
    "two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
df = pd.DataFrame(d)
# df的结果为：
#      one    two
# a    1.0    1.0
# b    2.0    2.0
# c    3.0    3.0
# d    NaN    4.0

字典中的每一项也可以是一个列表或者元组，但是这种情况下由于指定不了Series的index，因此每个列表的长度必须相等，否则会报错，而当字典中的每一项是一个Series且没有指定index时不会出错，是因为Series在创建时会有默认的index策略

d = {
    "one": [1.0, 2.0, 3.0],
    "two": [1.0, 2.0, 3.0, 4.0],
}
df = pd.DataFrame(d)
# 此时，会出现以下错误：ValueError: All arrays must be of the same length

传入一个字典且指定index

注意此处的index指的是pd.DataFrame()方法中的index参数，当指定了index时，会进行index对齐，从字典中各项中查找对应的index，如果找到了，就对应该值，如果没有找到就是NaN，如果index中某个索引在所有的字典项中都没有，则默认创建后该索引对应的行元素全部为NaN，如下述代码中的e

d = {
    "one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
    "two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
df = pd.DataFrame(d, index=['b', 'd', 'c', 'e'])
# df的结果为：
#      one    two
# b    2.0    2.0
# d    NaN    4.0
# c    3.0    3.0
# e    NaN    NaN

传入一个字典且指定columns

这种情况类似与上一种情况，columns有且在字典中能够找到的直接复制，字典中有但columns中没有的键会被忽略，当columns中指定的键如果在字典对象中不存在时，则该键对应的Series行中每一个元素均为NaN。另外需要格外注意的是columns的键是大小写敏感的，即'two'和'Two'是不同的

d = {
    "one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
    "two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
df = pd.DataFrame(d, columns=['two', 'three'])
# df的值为：
#     two    three
# a    1.0    NaN
# b    2.0    NaN
# c    3.0    NaN
# d    4.0    NaN

d = {
    "one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
    "two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
df = pd.DataFrame(d, columns=['Two', 'three'])
# 此种情况下相当于两个键都不存在与字典中，默认会创建一个空的DataFrame，没有任何元素
# 此处df的值为：
#     Two    three

传入一个字典且同时指定index以及columns

这种情况只需将第二种以及第三种情况的应对原则依次结合起来就行了

d = {
    "one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
    "two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
}
df = pd.DataFrame(d, index=['b', 'd', 'c', 'e'], columns=['two', 'three'])
# 此时df的值为：
#     two    three
# b    2.0    NaN
# d    4.0    NaN
# c    3.0    NaN
# e    NaN    NaN

使用包含字典的列表

当使用列表包含字典的方式创建DataFrame是，与上面的字典中每一项都是一个列表不同，此处列表中的每一项都对应创建后的DataFrame的一行，当指定index或/和columns时，策略和上述其它方式相同，总体来说无论是哪种创建方式，对于指定了index和columns的方式来说处理策略都是统一的，不会随着传入数据的方式改变而改变

data2 = [{"a": 1, "b": 2}, {"a": 5, "b": 10, "c": 20}]
df = pd.DataFrame(data2)
# df的值为：
#      a    b    c
# 0    1    2    NaN
# 1    5    10    20.0

df = pd.DataFrame(data2, index=["first", "second"])
# 此时df的值为：
#         a   b     c
# first   1   2   NaN
# second  5  10  20.0

df = pd.DataFrame(data2, columns=["a", "b"])
# 此时df的值为：
#    a   b
# 0  1   2
# 1  5  10

使用单个Series

可以直接使用单个Series对象创建一个DataFrame对象，此时创建后的DataFrame对象只包含一个列，Series的name属性就是DataFrame的列的列名，index属性就是DataFrame的index

ser = pd.Series(range(3), index=list("abc"), name="ser")
df = pd.DataFrame(ser)
# df的值为：
#     ser
# a    0
# b    1
# c    2

使用from_dict()方法

DataFrame.from_dict() 接收一个 dict 或一个类似数组序列的 dict，然后返回一个 DataFrame。

df = pd.DataFrame.from_dict(dict([("A", [1, 2, 3]), ("B", [4, 5, 6])]))
# df的值为：
#    A  B
# 0  1  4
# 1  2  5
# 2  3  6