Pandas ——（一）Pandas中的数据对象

Series和DataFrame是Pandas中最常用的两个对象，除了这两个，还有Index对象、MultiINdex对象等。

一、Series对象

Series是Pandas中最基本的对象。实际上每个Series都由两个数组组成：

• index
  它是从ndarray数组继承的Index索引对象，保存标签信息。若创建Series对象时不指定index，将自动创建一个表示位置下标的索引
• values
  保存元素值的ndarray数组，NumPy的函数都对此数组进行处理

# 不指定index
s = pd.Series([1, 2, 3, 4, 5])
print(s)
print('-'*20)
print("　索引:", s.index)
print("值数组:", s.values)

# 指定index
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("　索引:", s.index)
print("值数组:", s.values)

还可以通过字典创建Series

data = {'a':3,'b':2,'c':0,'d':1}
apples = pd.Series(data)
apples

键值不匹配时会报错

apples = pd.Series([3,6,9,8], index=['a','b','c'])
apples

---

Series对象支持多种方式存取元素：

# 位置下标存取元素
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("位置下标   s[2]:", s[2])

# 标签下标存取元素
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("标签下标 s['d']:", s['d'])

# 位置切片存取元素
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("位置切片 s[1:3]:\n", s[1:3])

可以看到：位置切片是遵循切片规则的，即“顾头不顾尾”

# 标签切片存取元素
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("标签切片 s['b':'d']:\n", s['b':'d'])

标签切片同时包括起始标签和结束标签

# 位置列表存取元素
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("位置列表 s[[1,3,2]]:\n", s[[1,3,2]])

# 标签列表存取元素
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("标签列表 s[['b','d','c']]:\n", s[['b','d','c']])

# 布尔数组存取元素
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print("布尔数组 s[[True,False,True,True,False]]:\n", s[[True,False,True,True,False]])

切记：在用列表或数组存取元素时，需要用嵌套列表的形式，否则会报错

# 通过字典存取数据
s = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(s)
print('-'*20)
print(list(s.iteritems()))

二、DataFrame对象

DataFrame对象是Pandas中最常用的数据对象。Pandas提供了将许多数据结构转换为DataFrame对象的方法，还提供了许多输入输出函数来将各种文件格式转换成DataFrame对象。

（一）DataFrame的组成元素

可以看出，DataFrame对象是一个二维表格。其中，每列的元素类型必须一致。但是不同列可以拥有不同的元素类型

data = {
    'apples':[3,2,0,1],
    'oranges':[0,1,2,3],
    'bananas':[1,2,1,0]
}

df = pd.DataFrame(data, index = ['June','Robert','Lily','David'])
df

---

与数组类似，通过shape属性可以得到DataFrame的行数和列数

df.shape

---

DataFrame对象拥有行索引和列索引，可以通过索引标签对其中的数据进行存取。
index属性保存行索引，columns属性保存列索引。且均为Index对象（后续会提到Index对象）

print(df)
print('')
print(df.columns)
print('')
print(df.index)

---

[]运算符可以通过列索引标签获取指定的列。
当下标是单个标签时，所得到的是Series对象；当下标是列表时，则得到一个新的DataFrame对象

# 下标是单个标签
print(df['apples'])
print('')

# 下标是列表
print(df[['apples','oranges']])

---

.loc[]可以通过行索引标签获取指定的行。
同样，当结果是一行时得到的是Series对象，为多行的时候得到的是DataFrame对象。
后续会详细介绍这个。

print(df.loc['Lily'])
print('')
print(df.loc[['Lily','David']])

（二）将其他格式数据转换为DataFrame对象

可以通过from_开头的类方法，将特定格式的数据转换成DataFrame对象。

from_dict()将字典转换为DataFrame对象，其orient参数可以指定字典键对应的方向，默认为columns。
表示把字典的键转换为列索引。当orient参数为index时，字典中的每个值与一行对应。
当字典为嵌套字典时，另一个轴的索引值由第二层字典中的键决定（缺失的数据以NaN表示）。

dict1 = {"a":[1, 2, 3], "b":[4, 5, 6]}
dict2 = {"a":{"A":1, "B":2}, "b":{"A":3, "C":4}}
df1 = pd.DataFrame.from_dict(dict1, orient="index")
df2 = pd.DataFrame.from_dict(dict1, orient="columns")
df3 = pd.DataFrame.from_dict(dict2, orient="index")
df4 = pd.DataFrame.from_dict(dict2, orient="columns")
print(df1)
print('')
print(df2)
print('')
print(df3)
print('')
print(df4)

---

（三）将DataFrame对象转换为其他格式的数据

to_dict()是将DataFrame对象转换为字典，它的orient参数决定字典元素的类型

dict1 = {"a":[1, 2, 3], "b":[4, 5, 6]}
df2 = pd.DataFrame.from_dict(dict1, orient="columns")
print(df2)
print('')
print(df2.to_dict(orient="records"))               #字典列表
print('')
print(df2.to_dict(orient="list"))                  #列表字典
print('')
print(df2.to_dict(orient="dict"))                  #嵌套字典

---

to_records()方法可以将DataFrame对象转换为结构数组，若其index参数为True，则其返回的数组中包含行索引数据

print(df2.to_records().dtype)
print('')
print(df2.to_records(index=False).dtype)

---

三、Index对象

Index对象保存索引标签数据，它可以快速找到标签对应的整数下标，其values属性可以获得保存标签的数组。

data = {
    'apples':[3,2,0,1],
    'oranges':[0,1,2,3],
    'bananas':[1,2,1,0]
}

df = pd.DataFrame(data, index = ['June','Robert','Lily','David'])
index = df.columns
print(index.values)

---

Index对象可当做一维数组，通过与NumPy数组相同的下表操作可以得到一个新的Index对象。

但是Index对象是只读的，因此一旦创建就无法修改其中的元素

print(index[[1, 2]])
print('')
print(index[index > 'c'])
print('')
print(index[1::2])

---

Index对象也具有字典的映射功能，它将数组中的值映射到其位置

• Index.get_loc(value)：获取单个value的下标
• Index.get)indexer(values)：获取一组values的下标（若不存在返回-1）

print(index.get_loc('oranges'))
print('')
print(index.get_indexer(['oranges', 'apples', 'nothing']))

---

可以直接调用Index()来创建Index对象，然后传递给DataFrame()的index或columns。

要注意的是：Index是不可变对象，所以多个数据对象的索引可以是同一个Index对象

index = pd.Index(["A", "B", "C", "D", "E"], name="level")
print(index)
print('')
s1 = pd.Series([1, 2, 3, 4, 5], index=index)
print(s1)
print('')
df1 = pd.DataFrame({"a":[1, 2, 3, 4, 5], "b":[6, 7, 8, 9, 10]}, index=index)
print(df1)
print('')
print(s1.index is df1.index)

---

四、MultiIndex对象

MultiIndex表示多级索引，它从Index继承，其中的多级标签采用元组对象来表示。

（一）创建MultiIndex对象

有以下4种创建MultiIndex的方法：

• pandas.MultiIndex.from_arrays ：从数组创建
• pandas.MultiIndex.from_product：从笛卡尔积创建
• pandas.MultiIndex.from_tuples ：从元组创建
• pandas.MultiIndex.from_frame ：另外DataFrame对象创建

# 从数组创建
class1 = ["A", "A", "B", "B"]
class2 = ["x", "y", "x", "y"]
print(pd.MultiIndex.from_arrays([class1, class2], names=["class1", "class2"]))

#  从笛卡尔积创建
midx = pd.MultiIndex.from_product([["A", "B", "C"], ["x", "y"]], 
                           names=["class1", "class2"])
df1 = pd.DataFrame(np.random.randint(0, 10, (6, 6)), columns=midx, index=midx)
print(df1)

（二）多级索引行列变换

1.unstack()方法可以快速将一个多级索引的Series转换为普通索引的DataFrame

keys=[('June', 'apples'),('June','oranges'),('June','bananas'),
     ('Robert', 'apples'),('Robert','oranges'),('Robert','bananas'),
     ('Lily', 'apples'),('Lily','oranges'),('Lily','bananas'),
     ('David', 'apples'),('David','oranges'),('David','bananas')]

index = pd.MultiIndex.from_tuples(keys, names=['names', 'fruits'])

data = [3,0,1,
       2,1,2,
       0,2,1,
       1,3,0]

s = pd.Series(data, index = index)
print(s)

print(s.unstack())

---

2.stack()方法可以将一个普通索引的DataFrame转换为多级索引的Series

data = {
    'apples':[3,2,0,1],
    'oranges':[0,1,2,3],
    'bananas':[1,2,1,0]
}

df = pd.DataFrame(data, index = ['June','Robert','Lily','David'])
print(df)
print('-'*40)
df1 = df.stack()
print(df1)

---

（三）多级索引数据存取

多级索引数据存取可以使用[]，也可以使用loc等存取器

print(s)
print('-'*40)
print(s[:,'apples'])
print('-'*40)
print(s.loc[:,'apples'])

---

五、常用的函数参数

参数名	常用值	说明
axis	0、1	运算对应的轴
level	整数或索引的级别名	指定运算对应的级别
fill_value	数值	指定运算中出现的NaN的替代填充值
skipna	布尔值	运算是否跳过NaN
index	序列	指定行索引
columns	序列	指定列索引
numeric_only	布尔值	是否只针对数值进行运算
func	可调用对象	指定回调函数
inplace	布尔值	是否原地更新，若为否，则返回新对象
encoding	“utf8”	指定文本编码
dropna	布尔值	是否删除包含NaN的行