Python3快速入门（十三）——Pandas数据结构
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Python3快速入门（十三）——Pandas数据结构相关的知识，希望对你有一定的参考价值。
Python3快速入门（十三）——Pandas数据结构一、Pandas数据结构简介
Pandas有三种主要数据结构，Series、DataFrame、Panel。
Series是带有标签的一维数组，可以保存任何数据类型（整数，字符串，浮点数，Python对象等），轴标签统称为索引（index）。
DataFrame是带有标签的二维数据结构，具有index（行标签）和columns（列标签）。如果传递index或columns，则会用于生成的DataFrame的index或columns。
Panel是一个三维数据结构，由items、major_axis、minor_axis定义。items（条目），即轴0，每个条目对应一个DataFrame；major_axis（主轴），即轴1，是每个DataFrame的index（行）；minor_axis（副轴），即轴2，是每个DataFrame的columns（列）。
二、Series
1、Series简介
Series是能够保存任何类型数据(整数，字符串，浮点数，Python对象等)的一维标记数组，轴标签统称为index（索引）。
series是一种一维数据结构，每一个元素都带有一个索引，其中索引可以为数字或字符串。Series结构名称：
2、Series对象构造
Series构造函数如下：pandas.Series( data, index, dtype, copy)
data：构建Series的数据，可以是ndarray，list，dict，constants。
index：索引值必须是唯一的和散列的，与数据的长度相同。 如果没有索引被传递，默认为np.arange(n)。
dtype：数据类型，如果没有，将推断数据类型。
copy：是否复制数据，默认为false。
（1）创建一个空的 Series
import pandas as pd
if __name__ == "__main__":
s = pd.Series()
print(s)
# output:
# Series([], dtype: float64)（2）使用ndarray创建Series
使用ndarray作为数据时，传递的索引必须与ndarray具有相同的长度。 如果没有传递索引值，那么默认的索引是range(n)，其中n是数组长度，即[0,1,2,3…. range(len(array))-1] - 1]。
import pandas as pd
import numpy as np
if __name__ == "__main__":
data = np.array([‘a‘, 1, 2, 4, 6])
s = pd.Series(data,index=[101, 102, 103, ‘hello‘, ‘world‘])
print(s)
# output:
# 101 a
# 102 1
# 103 2
# hello 4
# world 6
# dtype: object不传递任何索引时，默认分配从0到len(data)-1的索引。
import pandas as pd
import numpy as np
if __name__ == "__main__":
data = np.array([‘a‘, 1, 2, 4, 6])
s = pd.Series(data)
print(s)
# output:
# 0 a
# 1 1
# 2 2
# 3 4
# 4 6
# dtype: object（3）使用字典创建Series
使用字典(dict)作为数据时，如果没有指定索引，则按排序顺序取得字典键以构造索引。 如果传递索引，索引中与标签对应的数据中的值将被取出。
import pandas as pd
if __name__ == "__main__":
data = ‘a‘: 1, 2: ‘hello‘, ‘b‘: ‘hello world‘
s = pd.Series(data)
print(s)
# output:
# a 1
# 2 hello
# b hello world
# dtype: object传递索引时，索引顺序保持不变，缺少的元素使用NaN(不是数字)填充。
import pandas as pd
if __name__ == "__main__":
data = ‘a‘: 1, 2: ‘hello‘, ‘b‘: ‘hello world‘, "hello": "world"
s = pd.Series(data, index=[‘a‘, ‘b‘, "hello", ‘d‘])
print(s)
# output:
# a 1
# b hello world
# hello world
# d NaN
# dtype: object（4）使用标量创建Series
使用标量值作为数据，则必须提供索引，会重复标量值以匹配索引的长度。
import pandas as pd
if __name__ == "__main__":
s = pd.Series(100, index=[1, 2, 3])
print(s)
# output:
# 1 100
# 2 100
# 3 100
# dtype: int64（5）使用list、tuple创建Series
使用list、tuple作为数据时，传递的索引必须与list、tuple具有相同的长度。 如果没有传递索引值，那么默认的索引是range(n)，其中n是list的长度，即[0,1,2,3…. range(len(list))-1] - 1]。
import pandas as pd
if __name__ == "__main__":
s = pd.Series([1, 2, 3, "hello"])
print(s)
# output:
# 0 1
# 1 2
# 2 3
# 3 hello
# dtype: object3、Series数据的访问
Series中的数据可以使用有序序列的方式进行访问。
import pandas as pd
if __name__ == "__main__":
s = pd.Series([1, 2, 3, 4, 5], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘])
print(s[0])
print(s[-1])
print(s[-3:])
# output:
# 1
# 5
# c 3
# d 4
# e 5
# dtype: int64Series像一个固定大小的字典，可以通过索引标签获取和设置值，使用索引标签值检索单个元素，使用索引标签值列表检索多个元素。如果使用不包含在索引内的标签，则会出现异常。
import pandas as pd
if __name__ == "__main__":
s = pd.Series([1, 2, 3, 4, 5], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘])
s[‘a‘] = 101
print(s[‘a‘])
print(s[0])
print(s[[‘a‘, ‘b‘, ‘e‘]])
# output:
# 101
# 101
# a 101
# b 2
# e 5
# dtype: int644、Series属性
Series对象的属性和方法如下：
Series.axes：返回行轴标签列表
Series.dtype：返回对象的数据类型
Series.empty：如果对象为空，返回True
Series.ndim：返回底层数据的维数，默认为1
Series.size：返回基础数据中的元素数
Series.values：将对象作为ndarray返回
Series.head()：返回前n行
Series.tail()：返回后n行
import pandas as pd
if __name__ == "__main__":
s = pd.Series(["Bauer", 30, 90], index=[‘Name‘, ‘Age‘, ‘Score‘])
print("Series=================")
print(s)
print("axes===================")
print(s.axes)
print("dtype==================")
print(s.dtype)
print("empty==================")
print(s.empty)
print("ndim===================")
print(s.ndim)
print("size===================")
print(s.size)
print("values=================")
print(s.values)
print("head()=================")
print(s.head(2))
print("tail()=================")
print(s.tail(2))
# output:
# Series=================
# Name Bauer
# Age 30
# Score 90
# dtype: object
# axes===================
# [Index([‘Name‘, ‘Age‘, ‘Score‘], dtype=‘object‘)]
# dtype==================
# object
# empty==================
# False
# ndim===================
# 1
# size===================
# 3
# values=================
# [‘Bauer‘ 30 90]
# head()=================
# Name Bauer
# Age 30
# dtype: object
# tail()=================
# Age 30
# Score 90
# dtype: object三、DataFrame
1、DataFrame简介
数据帧(DataFrame)是二维的表格型数据结构，即数据以行和列的表格方式排列，DataFrame是Series的容器。
DataFrame的结构名称如下：
2、DataFrame的特点
数据帧(DataFrame)的功能特点如下：
（1）底层数据列是不同的类型
（2）大小可变
（3）标记轴(行和列)
（4）可以对行和列执行算术运算
3、DataFrame对象构造
pandas.DataFrame( data, index, columns, dtype, copy)
data：构建DataFrame的数据，可以是ndarray，series，map，lists，dict，constant和其它DataFrame。
index：行索引标签，如果没有传递索引值，索引默认为np.arrange(n)。
columns：列索引标签，如果没有传递索列引值，默认列索引是np.arange(n)。
dtype：每列的数据类型。
copy：如果默认值为False，则此命令(或任何它)用于复制数据。
（1）创建空的DataFrame
import pandas as pd
if __name__ == "__main__":
df = pd.DataFrame()
print(df)
# output:
# Empty DataFrame
# Columns: []
# Index: []（2）使用list创建DataFrame
使用单个列表或嵌套列表作为数据创建DataFrame时，如果不指定index或columns，默认使用range(len(list))作为index，对于单列表，默认columns=[0]，对于嵌套列表，默认columns为内层列表的长度的range。
import pandas as pd
if __name__ == "__main__":
data = [1, 2, 3, 4, 5]
df = pd.DataFrame(data)
print(df)
df = pd.DataFrame(data, index=[‘a‘, ‘b‘, ‘c‘, ‘h‘, ‘e‘], columns=[‘A‘])
print(df)
# output:
# 0
# 0 1
# 1 2
# 2 3
# 3 4
# 4 5
# A
# a 1
# b 2
# c 3
# h 4
# e 5指定index或columns时，index的长度必须与list长度匹配，columns的长度必须与list的内层列表长度匹配，否则将报错。
import pandas as pd
if __name__ == "__main__":
data = [[‘Alex‘, 25], [‘Bob‘, 26], [‘Bauer‘, 24]]
df = pd.DataFrame(data, columns=[‘Name‘, ‘Age‘])
print(df)
df = pd.DataFrame(data, columns=[‘Name‘, ‘Age‘], dtype=float)
print(df)
# output:
# Name Age
# 0 Alex 25
# 1 Bob 26
# 2 Bauer 24
# Name Age
# 0 Alex 25.0
# 1 Bob 26.0
# 2 Bauer 24.0（3）使用ndarray和list的字典创建DataFrame
使用ndarray、list组成的字典作为数据创建DataFrame时，所有的ndarray、list必须具有相同的长度。如果传递index，则index的长度必须等于ndarray、list的长度，columns为字典的key组成的集合。如果没有传递index，则默认情况下，index将为range(n)，其中n为list或ndarray长度。
import pandas as pd
if __name__ == "__main__":
data = ‘Name‘: [‘Tom‘, ‘Jack‘, ‘Steve‘, ‘Ricky‘], ‘Age‘: [28, 34, 29, 42]
df = pd.DataFrame(data)
print(df)
df = pd.DataFrame(data, index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘])
print(df)
# output:
# Name Age
# 0 Tom 28
# 1 Jack 34
# 2 Steve 29
# 3 Ricky 42
# Name Age
# rank1 Tom 28
# rank2 Jack 34
# rank3 Steve 29
# rank4 Ricky 42（4）使用字典列表创建DataFrame
使用字典列表作为数据创建DataFrame时，默认使用range（len（list））作为index，字典键的集合作为columns，如果字典没有相应键值对，其值使用NaN填充。当指定columns时，如果columns使用字典键集合以外元素作为columns的元素，则使用NaN进行填充，并提取出columns指定的数据源字典中相应的键值对。
import pandas as pd
if __name__ == "__main__":
data = [‘a‘: 1, ‘b‘: 2, ‘a‘: 5, ‘b‘: 10, ‘c‘: 20]
df = pd.DataFrame(data)
print(df)
df = pd.DataFrame(data, index=[‘first‘, ‘second‘], columns=[‘a‘, ‘b‘, ‘c‘, ‘A‘, ‘B‘])
print(df)
# output:
# a b c
# 0 1 2 NaN
# 1 5 10 20.0
# a b c A B
# first 1 2 NaN NaN NaN
# second 5 10 20.0 NaN NaN（5）使用Series字典创建DataFrame
使用Series字典作为数据创建DataFrame时，得到的DataFrame的index是所有Series的index的并集，字典键的集合作为columns。
import pandas as pd
if __name__ == "__main__":
data = ‘one‘: pd.Series([1, 2, 3], index=[‘a‘, ‘b‘, ‘c‘]),
‘two‘: pd.Series([1, 2, 3, 4], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘])
df = pd.DataFrame(data, columns=[‘one‘, ‘two‘])
print(df)
df = pd.DataFrame(data, columns=[‘one‘, ‘two‘, ‘three‘])
print(df)
df = pd.DataFrame(data, index=[‘a‘, ‘b‘, ‘c‘, ‘A‘], columns=[‘one‘, ‘two‘, ‘three‘])
print(df)
# output:
# one two
# a 1.0 1
# b 2.0 2
# c 3.0 3
# d NaN 4
# one two three
# a 1.0 1 NaN
# b 2.0 2 NaN
# c 3.0 3 NaN
# d NaN 4 NaN
# one two three
# a 1.0 1.0 NaN
# b 2.0 2.0 NaN
# c 3.0 3.0 NaN
# A NaN NaN NaN4、DataFrame列操作
通过字典键可以进行列选择，获取DataFrame中的一列数据。
import pandas as pd
if __name__ == "__main__":
data = ‘one‘: pd.Series([1, 2, 3], index=[‘a‘, ‘b‘, ‘c‘]),
‘two‘: pd.Series([1, 2, 3, 4], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘])
df = pd.DataFrame(data, columns=[‘one‘, ‘two‘])
print(df)
print(df[‘one‘])
# output:
# one two
# a 1.0 1
# b 2.0 2
# c 3.0 3
# d NaN 4
# a 1.0
# b 2.0
# c 3.0
# d NaN
# Name: one, dtype: float64通过向DataFrame增加相应的键和Series值，可以为DataFrame增加一列。
import pandas as pd
if __name__ == "__main__":
data = ‘one‘: pd.Series([1, 2, 3], index=[‘a‘, ‘b‘, ‘c‘]),
‘two‘: pd.Series([1, 2, 3, 4], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘])
df = pd.DataFrame(data, columns=[‘one‘, ‘two‘])
print(df)
df[‘three‘] = pd.Series([10, 20, 30], index=[‘a‘, ‘b‘, ‘c‘])
print(df)
df[‘four‘] = df[‘one‘] + df[‘three‘]
print(df)
# output:
# one two
# a 1.0 1
# b 2.0 2
# c 3.0 3
# d NaN 4
# one two three
# a 1.0 1 10.0
# b 2.0 2 20.0
# c 3.0 3 30.0
# d NaN 4 NaN
# one two three four
# a 1.0 1 10.0 11.0
# b 2.0 2 20.0 22.0
# c 3.0 3 30.0 33.0
# d NaN 4 NaN NaN通过del可以删除DataFrame的列。
import pandas as pd
if __name__ == "__main__":
data = ‘one‘: pd.Series([1, 2, 3], index=[‘a‘, ‘b‘, ‘c‘]),
‘two‘: pd.Series([1, 2, 3, 4], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘]),
‘three‘: pd.Series([10, 20, 30], index=[‘a‘, ‘b‘, ‘c‘])
df = pd.DataFrame(data, columns=[‘one‘, ‘two‘, ‘three‘])
print(df)
del(df[‘two‘])
print(df)
# output:
# one two three
# a 1.0 1 10.0
# b 2.0 2 20.0
# c 3.0 3 30.0
# d NaN 4 NaN
# one three
# a 1.0 10.0
# b 2.0 20.0
# c 3.0 30.0
# d NaN NaN5、DataFrame行选择
DataFrame行选择可以通过将行标签传递给loc函数来选择行，也可以通过将整数位置传递给iloc()函数来选择行，返回Series，Series的名称是检索的标签，Series的index为DataFrame的columns。
import pandas as pd
if __name__ == "__main__":
data = ‘one‘: pd.Series([1, 2, 3], index=[‘a‘, ‘b‘, ‘c‘]),
‘two‘: pd.Series([1, 2, 3, 4], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘]),
‘three‘: pd.Series([10, 20, 30], index=[‘a‘, ‘b‘, ‘c‘])
df = pd.DataFrame(data, columns=[‘one‘, ‘two‘, ‘three‘])
print(df.loc[‘a‘])
print(df.iloc[0])
# output:
# one 1.0
# two 1.0
# three 10.0
# Name: a, dtype: float64
# one 1.0
# two 1.0
# three 10.0
# Name: a, dtype: float64DataFrame多行选择可以通过使用:运算符对DataFrame进行行切片操作，选择多行。
import pandas as pd
if __name__ == "__main__":
data = ‘one‘: pd.Series([1, 2, 3], index=[‘a‘, ‘b‘, ‘c‘]),
‘two‘: pd.Series([1, 2, 3, 4], index=[‘a‘, ‘b‘, ‘c‘, ‘d‘]),
‘three‘: pd.Series([10, 20, 30], index=[‘a‘, ‘b‘, ‘c‘])
df = pd.DataFrame(data, columns=[‘one‘, ‘two‘, ‘three‘])
print(df)
print(df[2:4])
# output:
# one two three
# a 1.0 1 10.0
# b 2.0 2 20.0
# c 3.0 3 30.0
# d NaN 4 NaN
# one two three
# c 3.0 3 30.0
# d NaN 4 NaNDataFrame的行追加通过append函数实现。
import pandas as pd
if __name__ == "__main__":
df = pd.DataFrame([["Bauer", 20], ["Jack", 30]], index=["rank1", "rank2"], columns=[‘Name‘, ‘Age‘])
df2 = pd.DataFrame([["Alex", 18], ["Bob", 28]], index=["rank3", "rank3"], columns=[‘Name‘, ‘Age‘])
df = df.append(df2)
print(df)
# output:
# Name Age
# rank1 Bauer 20
# rank2 Jack 30
# rank3 Alex 18
# rank3 Bob 28DataFrame的行删除通过将索引标签传递给drop函数进行行删除， 如果标签重复，则会删除多行。
import pandas as pd
if __name__ == "__main__":
df = pd.DataFrame([["Bauer", 20], ["Jack", 30]], index=["rank1", "rank2"], columns=[‘Name‘, ‘Age‘])
df2 = pd.DataFrame([["Alex", 18], ["Bob", 28]], index=["rank3", "rank3"], columns=[‘Name‘, ‘Age‘])
df = df.append(df2)
print(df)
df = df.drop("rank2")
print(df)
# output:
# Name Age
# rank1 Bauer 20
# rank2 Jack 30
# rank3 Alex 18
# rank3 Bob 28
# Name Age
# rank1 Bauer 20
# rank3 Alex 18
# rank3 Bob 286、DataFrame属性
DataFrame对象的属性和方法如下：
DataFrame.T：转置行和列
DataFrame.axes：返回一个列，行轴标签和列轴标签作为唯一的成员。
DataFrame.dtypes：返回对象的数据类型
DataFrame.empty：如果NDFrame完全为空，返回True
DataFrame.ndim：返回轴/数组维度的大小
DataFrame.shape：返回表示DataFrame维度的元组
DataFrame.size：返回DataFrame的元素数
DataFrame.values：将对象作为ndarray返回
DataFrame.head()：返回前n行
DataFrame.tail()：返回后n行
import pandas as pd
if __name__ == "__main__":
df = pd.DataFrame([["Bauer", 30, 90], [‘Jack‘, 32, 98], [‘Bob‘, 28, 78]], columns=[‘Name‘, ‘Age‘, ‘Score‘])
print("DataFrame=================")
print(df)
print("T======================")
print(df.T)
print("axes===================")
print(df.axes)
print("dtypes==================")
print(df.dtypes)
print("empty==================")
print(df.empty)
print("ndim===================")
print(df.ndim)
print("shape==================")
print(df.shape)
print("size===================")
print(df.size)
print("values=================")
print(df.values)
print("head()=================")
print(df.head(2))
print("tail()=================")
print(df.tail(2))
# output:
# DataFrame=================
# Name Age Score
# 0 Bauer 30 90
# 1 Jack 32 98
# 2 Bob 28 78
# T======================
# 0 1 2
# Name Bauer Jack Bob
# Age 30 32 28
# Score 90 98 78
# axes===================
# [RangeIndex(start=0, stop=3, step=1), Index([‘Name‘, ‘Age‘, ‘Score‘], dtype=‘object‘)]
# dtypes==================
# Name object
# Age int64
# Score int64
# dtype: object
# empty==================
# False
# ndim===================
# 2
# shape==================
# (3, 3)
# size===================
# 9
# values=================
# [[‘Bauer‘ 30 90]
# [‘Jack‘ 32 98]
# [‘Bob‘ 28 78]]
# head()=================
# Name Age Score
# 0 Bauer 30 90
# 1 Jack 32 98
# tail()=================
# Name Age Score
# 1 Jack 32 98
# 2 Bob 28 78四、Panel
1、Panel简介
Panel 是三维的数据结构，是DataFrame的容器，Panel的3个轴如下：
items - axis 0，每个项目对应于内部包含的数据帧(DataFrame)。
major_axis - axis 1，是每个数据帧(DataFrame)的索引(行)。
minor_axis - axis 2，是每个数据帧(DataFrame)的列。
2、Panel对象构建
pandas.Panel(data, items, major_axis, minor_axis, dtype, copy)
data：构建Panel的数据，采取各种形式，如：ndarray，series，map，lists，dict，constant和另一个数据帧(DataFrame)。
items：axis=0
major_axis：axis=1
minor_axis：axis=2
dtype：每列的数据类型
copy：复制数据，默认 - false
（1）创建空Panel
import pandas as pd
if __name__ == "__main__":
p = pd.Panel()
print(p)
# output:
# class ‘pandas.core.panel.Panel‘>
# Dimensions: 0 (items) x 0 (major_axis) x 0 (minor_axis)
# Items axis: None
# Major_axis axis: None
# Minor_axis axis: None（2）使用3D ndarray创建Panel
import pandas as pd
import numpy as np
if __name__ == "__main__":
data = np.random.rand(2, 4, 5)
p = pd.Panel(data, items=["item1", "item2"], major_axis=[1, 2, 3, 4], minor_axis=[‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘])
print(p)
print("item1")
print(p["item1"])
print(p.major_xs(2))
print(p.minor_xs(‘b‘))
# output:
# <class ‘pandas.core.panel.Panel‘>
# Dimensions: 2 (items) x 4 (major_axis) x 5 (minor_axis)
# Items axis: item1 to item2
# Major_axis axis: 1 to 4
# Minor_axis axis: a to e
# item1
# a b c d e
# 1 0.185626 0.976123 0.566263 0.273208 0.675442
# 2 0.209664 0.205190 0.217200 0.158447 0.400683
# 3 0.499591 0.963321 0.759330 0.089930 0.362824
# 4 0.723158 0.585642 0.629246 0.886086 0.493039
# item1 item2
# a 0.209664 0.592154
# b 0.205190 0.661562
# c 0.217200 0.743716
# d 0.158447 0.055882
# e 0.400683 0.245760
# item1 item2
# 1 0.976123 0.630320
# 2 0.205190 0.661562
# 3 0.963321 0.741791
# 4 0.585642 0.729366（3）使用DataFrame字典创建Panel
import pandas as pd
import numpy as np
if __name__ == "__main__":
data = ‘Table1‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]),
‘Table2‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]
)
p = pd.Panel(data)
print(p)
# output:
# <class ‘pandas.core.panel.Panel‘>
# Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
# Items axis: Table1 to Table2
# Major_axis axis: rank1 to rank4
# Minor_axis axis: Name to Score3、Panel数据索引
使用Items访问Panel可以获取相应的DataFrame。
import pandas as pd
import numpy as np
if __name__ == "__main__":
data = ‘Table1‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]),
‘Table2‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]
)
p = pd.Panel(data)
print(p[‘Table1‘])
# output:
# Name Age Score
# rank1 -1.240644 -0.820041 1.656150
# rank2 1.830655 -0.258068 -0.728560
# rank3 1.268695 1.259693 -1.005151
# rank4 -0.139876 0.611589 2.343394使用panel.major_axis(key)函数访问Panel数据，需要传递Major_axis的值作为key，返回DataFrame，DataFrame的index为Minor_axis，columns为Items。
import pandas as pd
import numpy as np
if __name__ == "__main__":
data = ‘Table1‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]),
‘Table2‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]
)
p = pd.Panel(data)
print(p.major_xs(‘rank2‘))
# output:
# Table1 Table2
# Name 1.664996 0.326820
# Age 0.952639 0.686095
# Score -0.473985 -0.343404使用panel.minor_axis(key)函数访问Panel数据，需要传递Minor_axis的值作为key，返回DataFrame，DataFrame的index为Major_axis，columns为Items。
import pandas as pd
import numpy as np
if __name__ == "__main__":
data = ‘Table1‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]),
‘Table2‘: pd.DataFrame(np.random.randn(4, 3),
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]
)
p = pd.Panel(data)
print(p.minor_xs(‘Name‘))
# output:
# Table1 Table2
# rank1 -1.314702 -0.198485
# rank2 0.055324 0.295646
# rank3 -0.352192 -0.523549
# rank4 -4.002903 -0.5773894、Panel属性
Panel对象的属性和方法如下：
Panel.T：转置行和列
Panel.axes：返回一个列，行轴标签和列轴标签作为唯一的成员。
Panel.dtypes：返回对象的数据类型
Panel.empty：如果NDFrame完全为空，返回True
Panel.ndim：返回轴/数组维度的大小
Panel.shape：返回表示DataFrame维度的元组
Panel.size：返回DataFrame的元素数
Panel.values：将对象作为ndarray返回
import pandas as pd
import numpy as np
if __name__ == "__main__":
array1 = np.random.randn(4, 3)
array2 = np.random.randn(4, 3)
data = ‘Table1‘: pd.DataFrame(array1,
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]),
‘Table2‘: pd.DataFrame(array2,
index=[‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘],
columns=[‘Name‘, ‘Age‘, ‘Score‘]
)
p = pd.Panel(data)
print("panel=================")
print(p)
print("axes===================")
print(p.axes)
print("dtypes==================")
print(p.dtypes)
print("empty==================")
print(p.empty)
print("ndim===================")
print(p.ndim)
print("shape==================")
print(p.shape)
print("size===================")
print(p.size)
print("values=================")
print(p.values)
print(p["Table1"])
print(array1)
# output:
# panel=================
# <class ‘pandas.core.panel.Panel‘>
# Dimensions: 2 (items) x 4 (major_axis) x 3 (minor_axis)
# Items axis: Table1 to Table2
# Major_axis axis: rank1 to rank4
# Minor_axis axis: Name to Score
# axes===================
# [Index([‘Table1‘, ‘Table2‘], dtype=‘object‘), Index([‘rank1‘, ‘rank2‘, ‘rank3‘, ‘rank4‘], dtype=‘object‘), Index([‘Name‘, ‘Age‘, ‘Score‘], dtype=‘object‘)]
# dtypes==================
# Table1 float64
# Table2 float64
# dtype: object
# empty==================
# False
# ndim===================
# 3
# shape==================
# (2, 4, 3)
# size===================
# 24
# values=================
# [[[ 0.22914664 -0.88176603 0.48050365]
# [-0.15099586 0.23380446 0.20165317]
# [-0.13652604 1.08191771 0.60361811]
# [-0.81742392 -0.09018878 1.62892609]]
#
# [[-0.72965894 0.58207009 0.15309812]
# [ 0.06467707 1.13494668 -0.19074456]
# [-0.53869056 1.28244925 -0.01832724]
# [-0.26831567 0.65912009 0.38607594]]]
# Name Age Score
# rank1 0.229147 -0.881766 0.480504
# rank2 -0.150996 0.233804 0.201653
# rank3 -0.136526 1.081918 0.603618
# rank4 -0.817424 -0.090189 1.628926
# [[ 0.22914664 -0.88176603 0.48050365]
# [-0.15099586 0.23380446 0.20165317]
# [-0.13652604 1.08191771 0.60361811]
# [-0.81742392 -0.09018878 1.62892609]]以上是关于Python3快速入门（十三）——Pandas数据结构的主要内容，如果未能解决你的问题，请参考以下文章