pandas 数据结构之系列、数据帧详解

系列

系列是一个一维标记数组，能够保存任何数据 类型（整数、字符串、浮点数、Python 对象等）。

轴标签统称为索引。创建序列的基本方法是调用

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

其中data可以为 NDARRAY、字典、标量值

为ndarray

如果是 ndarray，则索引的长度必须与数据相同。如果没有 索引被传递，将创建一个具有值的索引

In:
s = pd.Series(np.arange(5),index=["a","b","c","d","e"])
print(s)
print(s.index)

Out:
a    0
b    1
c    2
d    3
e    4
dtype: int32
Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

In:
a = pd.Series(np.random.randn(5))
print(a)

Out:
0    0.244636
1    1.038671
2    0.752578
3   -2.267479
4   -0.592213
dtype: float64

为字典

In:
b={"a":1,"b":2,"c":3}
c=pd.Series(b)
print(c)

print(pd.Series(b,index=["b","a","c","d"]))

Out:
a    1
b    2
c    3
dtype: int64

b    2.0
a    1.0
c    3.0
d    NaN
dtype: float64

如果传递索引，则数据中的值对应于 索引将被拉出
NaN（不是数字）是熊猫中使用的标准缺失数据标记。

为标量值

In:
print(pd.Series(5,index=[1,2,3,4,5]))

Out:
1    5
2    5
3    5
4    5
5    5
dtype: int64

系列类似 ndarray

系列类似ndarray，与列表切片相似

In:
a=pd.Series(np.random.randn(6))
print(a)
print(a[0])
print(a[:3])
print(a[::2])

Out：
0   -0.347091
1   -1.407420
2    0.348607
3    0.639882
4    0.632786
5    1.147535
dtype: float64

-0.34709118061406613

0   -0.347091
1   -1.407420
2    0.348607
dtype: float64

0   -0.347091
2    0.348607
4    0.632786
dtype: float64

系列类型

In:
a=pd.Series(np.random.randn(6))
b=pd.Series(np.arange(6))
print(a.dtype)
print(b.dtype)

Out:
float64
int32

序列转化为实际数组

In:
b=pd.Series(np.arange(6))
print(b.array)

Out:
[0, 1, 2, 3, 4, 5]

序列类似与ndarray 用to_numpy转为ndarray

In:
b=pd.Series(np.arange(6))
print(b.to_numpy())

Out:
[0 1 2 3 4 5]

系列是字典般的

序列也类似于固定大小的字典，您可以按索引获取和设置值 标签：

In:
a=pd.Series(np.random.randn(6),index=[1,4,4,4,5,6])
print(a)
print(a[4])
print(4 in a

Out:
1    1.143214
4   -0.784372
4    0.972141
4    2.132039
5   -0.329324
6    0.236532
dtype: float64

4   -0.784372
4    0.972141
4    2.132039
dtype: float64

True

系列没有索引值会报错 ，为了防止报错，使用Series.get

In:
a=pd.Series(np.random.randn(6),index=[1,4,4,4,5,6])
print(a.get(3))

Out:
None

默认为空，可以设置其他值

In:
a=pd.Series(np.random.randn(6),index=[1,4,4,4,5,6])
str="没有该索引"
print(a.get(str))

Out:
没有该索引

矢量化操作和标签对齐与系列

系列之间可以矢量化操作

In:
a=pd.Series(np.arange(2),index=[1,4])
print(a)
print(a+a)
print(a*2)
print(np.exp(a))

Out:
1    0
4    1
dtype: int32
1    0
4    2
dtype: int32
1    0
4    2
dtype: int32
1    1.000000
4    2.718282
dtype: float64

名称属性

系列还有一个属性：name 列标签

In:
a=pd.Series(np.arange(6),index=[1,4,4,4,5,6],name=int)
print(a)
print(a.name)
b = a.rename("int2")  ##更改属性
print(b.name)

Out:
1    0
4    1
4    2
4    3
5    4
6    5
Name: <class 'int'>, dtype: int32
<class 'int'>
int2

数据帧

数据帧是一种二维标记数据结构，其列 可能不同的类型,

与系列一样，数据帧可以介绍不同类型的输入

• 一维数组、列表、字典或系列的字典
• 2-D numpy.ndarray
• 结构化或记录阵列
• A系列
• 另一个数据帧

从系列或字典的字典输入

In:
a = pd.Series([1,2,3,4],index=["a","b","c","d"])
b = pd.DataFrame(a)
print(b)

Out:
   0
a  1
b  2
c  3
d  4

系列输入

In:
a ={
    "one" : pd.Series([1,2,3,4,5],index=["a","b","c","d","e"]) ,
    "two" : pd.Series([5,6,7,8,9],index=["a","b","c","d","e"])
}
b=pd.DataFrame(a)
print(b)

Out:
   one  two
a    1    5
b    2    6
c    3    7
d    4    8
e    5    9

字典输入

可以通过index，columns 改变行列顺序

In:
a ={
    "one" : pd.Series([1,2,3,4],index=["a","b","c","d"]) ,
    "two" : pd.Series([5,6,7,8,9],index=["a","b","c","d","e"])
}
b=pd.DataFrame(a)
b=pd.DataFrame(a)
c=pd.DataFrame(a,index=["e","d","c","b","a"],columns=["two","one"])
print(c)

Out:
   two  one
e    9    NaN
d    8    4
c    7    3
b    6    2
a    5    1

缺行会被补齐，NaN

从 ndarrays / list 的字典

In:
d = {"one": [1.0, 2.0, 3.0, 4.0], "two": [4.0, 3.0, 2.0, 1.0]}
print(pd.DataFrame(d))
print(pd.DataFrame(d, index=["a", "b", "c", "d"]))

Out:
   one  two
a  1.0  4.0
b  2.0  3.0
c  3.0  2.0
d  4.0  1.0

从结构化或记录数组

从字典列表

In:
data2 = [{"a": 1, "b": 2}, {"a": 5, "b": 10, "c": 20}]
print(pd.DataFrame(data2))
print(pd.DataFrame(data2, index=["first", "second"]))
print(pd.DataFrame(data2, columns=["a", "b"]))

Out:
   a   b     c
0  1   2   NaN
1  5  10  20.0
        a   b     c
first   1   2   NaN
second  5  10  20.0
   a   b
0  1   2
1  5  10

来自元组的字典

从系列

In:
ser = pd.Series(range(3), index=list("abc"), name="ser")
print(pd.DataFrame(ser))

Out:
   ser
a    0
b    1
c    2

从命名元组列表

从数据类列表

备用构造函数

列选择、添加、删除

与系列类似,数据帧也能实现 数据帧内列于列，和数据帧与数据帧之间 的+ - * 比较，
可以像字典一样删除或弹出列：del pop

del df["two"]
three = df.pop("three")

当插入标量值时，它自然会被传播以填充 列：

In:
a ={
    "one" : pd.Series([1,2,3],index=["a","b","c"]) ,
    "two" : pd.Series([5,6,7,8,9],index=["a","b","c","d","e"])
}
b=pd.DataFrame(a)
b["there"]=1
print(b)

Out:
   one  two  there
a  1.0    5      1
b  2.0    6      1
c  3.0    7      1
d  NaN    8      1
e  NaN    9      1

插入与数据帧没有相同索引的系列时，它 将符合数据帧的索引：

In:
a ={
    "one" : pd.Series([1,2,3],index=["a","b","c"]) ,
    "two" : pd.Series([5,6,7,8,9],index=["a","b","c","d","e"])
}

b=pd.DataFrame(a)
b["there"]=b["one"][:2]
print(b)

Out:
   one  two  there
a  1.0    5    1.0
b  2.0    6    2.0
c  3.0    7    NaN
d  NaN    8    NaN
e  NaN    9    NaN

在方法链中分配新列

索引/选择

操作	语法	结果
选择列	df[col]	系列
按标签选择行	df.loc[label]	系列
按整数位置选择行	df.iloc[loc]	系列
切片行	df[5:10]	数据帧
按布尔向量选择行	df[bool_vec]	数据帧

数据对齐和算术

转置

DataFrame.transpose（）
###数据帧与 NumPy 函数的互操作性
大多数 NumPy 函数可以直接在 Series 和数据帧上调用

控制台显示

非常大的数据帧将被截断以在控制台中显示它们，还可以使用 info（） 获取摘要。

使用 DataFrame.to_string（） 将以表格形式返回数据帧的字符串表示形式，尽管它并不总是适合控制台宽度：

您可以通过设置以下选项来更改单行上的打印量：display.width

您可以通过设置来调整各个列的最大宽度display.max_colwidth

数据帧列属性访问和 IPython

如果数据帧列标签是有效的 Python 变量名称，则该列可以是 像属性一样访问：