[Python知识库]做项目常用的Pandas基本操作

import numpy as np
import pandas  as pd

对象创建

• Series通过传递值列表来创建a,让pandas创建一个默认整数索引

s = pd.Series([1,3,5,np.nan,6,8])

s

0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

• DataFrame通过传递一个Numpy数组、一个日期时间索引和标签列来创建一个：

dates = pd.date_range("2022-06-07",periods=6)

dates

DatetimeIndex(['2022-06-07', '2022-06-08', '2022-06-09', '2022-06-10',
               '2022-06-11', '2022-06-12'],
              dtype='datetime64[ns]', freq='D')

df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=list("ABCD"))

df

• DataFrame通过传递可以转换为类似系列结构的对象字典来创建a:

df2 = pd.DataFrame(
{
    "A":1.0,
    "B":pd.Timestamp("20130102"),
    "C":pd.Series(1,index=list(range(4)),dtype="float32"),
    "D":np.array([3]*4,dtype="int32"),
    "E":pd.Categorical(["test","train","test","train"]),
    "F":"foo",
})

df2

df3 = pd.DataFrame(
{
    "A":1.0,
    "B":pd.Timestamp("20130102"),
    "C":pd.Series(1,index=list(range(5)),dtype="float32"),
    "D":np.array([3]*5,dtype="int32"),
    "E":pd.Categorical(["test","train","test","train","a"]),
    "F":"foo",
})

df3

df2

# 结果的列DataFrame具有不同的dtypes
df2.dtypes

A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object

• 如果您使用的是IPython,则会自动启用列名(以及公共属性)的制表符(Tab键)补全。

df2.A

0    1.0
1    1.0
2    1.0
3    1.0
Name: A, dtype: float64

df2.abs

<bound method NDFrame.abs of      A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo>

df2.add

<bound method flex_arith_method_FRAME.<locals>.f of      A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo>

df2.all

<bound method NDFrame._add_numeric_operations.<locals>.all of      A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo>

查看数据

df

# 前三行
df.head()

df.head(3)

df.tail()

# 后三行
df.tail(3)

# 显示索引
df.index

DatetimeIndex(['2022-06-07', '2022-06-08', '2022-06-09', '2022-06-10',
               '2022-06-11', '2022-06-12'],
              dtype='datetime64[ns]', freq='D')

# 显示列
df.columns

Index(['A', 'B', 'C', 'D'], dtype='object')

• 注意：DataFrame.to_numpy()给出底层数据的NumPy表示，请注意，当您的DataFrame列具有不同的数据类型时，这可能是一项昂贵的操作，这归结为pandas和NumPy之间的根本区别：NumPy数组对整个数组有一个dtype，而pandas
  DataFrames每列有一个dtype.当您调用时 DataFrame.to_numpy()，pandas会找到可以容纳DataFrame中所有dtype的
  NumPy dtype。这最终可能是object,这需要将每个值转换为Python对象。
• 对于df,我们DataFrame的所有浮点值，DataFrame.to_numpy()速度很快并且不需要复制数据：

df

df.dtypes

A    float64
B    float64
C    float64
D    float64
dtype: object

df.to_numpy()

array([[ 0.40526325,  0.46532668,  0.07694617, -0.3115456 ],
       [ 0.06912909,  0.9769407 , -0.28743027,  1.08426954],
       [-0.20022708,  1.17280586,  1.34307017,  0.56144631],
       [-0.34616439, -1.60996101,  1.18171013,  0.04600243],
       [-1.83349661, -0.26301183,  0.36815984,  0.16598165],
       [-0.61690579,  0.95554251, -0.60358546,  0.89023561]])

df2

df2.dtypes

A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object

df2.to_numpy()

array([[1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'test', 'foo'],
       [1.0, Timestamp('2013-01-02 00:00:00'), 1.0, 3, 'train', 'foo']],
      dtype=object)

df.index

DatetimeIndex(['2022-06-07', '2022-06-08', '2022-06-09', '2022-06-10',
               '2022-06-11', '2022-06-12'],
              dtype='datetime64[ns]', freq='D')

df2.index

Int64Index([0, 1, 2, 3], dtype='int64')

• DataFrame.to_numpy() 不包括输出中的索引或列标签

• describe()显示数据的快速统计摘要:

# describe()方法一般用于对数据进行统计学估计，输出行名分别为：count(行数)，mean(平均值)，std(标准差)，min(最小值），25%(第一四分位数)，50%(第二四分位数)，75%(第三四分位数)，max(最大值)。
df.describe()

# 转置数据
df.T

df

df2

df2.columns

Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')

df2.describe()

df2.T

df

df.T

#  sort_index（）方法专门用于对index排序
# axis=0对应的是对左边一列的index进行排序(列排); axis=1对应的是对上边一行的index进行排序(行排)
# ascending=False代表降序
df.sort_index(axis=1,ascending=False)

df

df.sort_index(axis=0,ascending=False)

df.sort_index(axis=1,ascending=False)

df.sort_index(axis=0,ascending=False)

df.sort_index(axis=0,ascending=True)

df

df.T

# 对df进行转置，然后按轴排序(降序)
df.T.sort_index(axis=1,ascending=False)

df

# 按值排序
df.sort_values(by="B")

"
df.sort_values(
    by,
    axis: 'Axis' = 0,
    ascending=True,
    inplace: 'bool' = False,
    kind: 'str' = 'quicksort',
    na_position: 'str' = 'last',
    ignore_index: 'bool' = False,
    key: 'ValueKeyFunc' = None,
)
"

df.sort_values(axis=1,by="2022-06-10")

df.sort_values(axis=0,by="B")

选择

• 虽然用于选择和设置的标准Python/NumPy表达式很直观，并且在交互工作中派上用场，但对于生产代码，我们推荐优化的pandas数据访问方法.at、、、、.iat和.loc .iloc

获取

• 选择单个列，这会产生a Series,相当于df.A:

df

df["A"]

2022-06-07    0.405263
2022-06-08    0.069129
2022-06-09   -0.200227
2022-06-10   -0.346164
2022-06-11   -1.833497
2022-06-12   -0.616906
Freq: D, Name: A, dtype: float64

df["D"]

2022-06-07   -0.311546
2022-06-08    1.084270
2022-06-09    0.561446
2022-06-10    0.046002
2022-06-11    0.165982
2022-06-12    0.890236
Freq: D, Name: D, dtype: float64

• 选择via [],对行切片

df

df[0:3]

df["20220608":"20220611"]

按标签选择

• 在按标签选择中查看更多信息

• 使用标签获取横截面：

df.loc[dates[0]]

A    0.405263
B    0.465327
C    0.076946
D   -0.311546
Name: 2022-06-07 00:00:00, dtype: float64

• 按标签在多轴选择：

df

df.loc()

<pandas.core.indexing._LocIndexer at 0x162f252a130>

df.loc[dates[1]]

A    0.069129
B    0.976941
C   -0.287430
D    1.084270
Name: 2022-06-08 00:00:00, dtype: float64

df.loc[dates[2]]

A   -0.200227
B    1.172806
C    1.343070
D    0.561446
Name: 2022-06-09 00:00:00, dtype: float64

• 按标签在多轴上选择：

df.loc[:,]

df.loc[:,["A","B"]]

• 显示标签切片，包括两个端点：

df.loc[["20220607","20220609"],["C","D"]]

df.loc[["20220607","20220611"],["A","D"]]

df.loc[["20220611"],["A","D"]]

• 返回对象的尺寸减少：

df.loc["20220611",["A","D"]]

A   -1.833497
D    0.165982
Name: 2022-06-11 00:00:00, dtype: float64

• 获取标量值

df

df.loc[dates[0]]

A    0.405263
B    0.465327
C    0.076946
D   -0.311546
Name: 2022-06-07 00:00:00, dtype: float64

df.loc[dates[1]]

A    0.069129
B    0.976941
C   -0.287430
D    1.084270
Name: 2022-06-08 00:00:00, dtype: float64

df.loc[dates[1],"A"]

0.06912908863219207

df.loc[dates[1],"C"]

-0.28743026681864575

• 为了快速访问标量

df.at[dates[0],"A"]

0.40526325343260083

df.at[dates[1],"C"]

-0.28743026681864575

按位置选择

• 通过传递整数的位置进行选择

df

df.iloc[3]

A   -0.346164
B   -1.609961
C    1.181710
D    0.046002
Name: 2022-06-10 00:00:00, dtype: float64

df.iloc[4]

A   -1.833497
B   -0.263012
C    0.368160
D    0.165982
Name: 2022-06-11 00:00:00, dtype: float64

• 按标签在多轴上选择

df.iloc[3:5]

df.iloc[3:5,0:2]

• 通过整数位置列表，类似于Numpy/Python样式

df.iloc[[1,2,4],[0,2]]

• 对于显式切片行：

df.iloc[1:3,:]

df.iloc[1:3,2:3]

• 对于显示切片列

df.iloc[:,1:3]

df.iloc[1:4,1:3]

• 要明确获取值：

df.iloc[1,1]

0.9769407016879463

df

df.iloc[3,3]

0.04600243177073029

• 为了快速访问标量

df.iat[1,1]

0.9769407016879463

df.iat[3,3]

0.04600243177073029

布尔索引

• 使用单个列的值来选择数据

df

df["A"]

2022-06-07    0.405263
2022-06-08    0.069129
2022-06-09   -0.200227
2022-06-10   -0.346164
2022-06-11   -1.833497
2022-06-12   -0.616906
Freq: D, Name: A, dtype: float64

df["A"]>0

2022-06-07     True
2022-06-08     True
2022-06-09    False
2022-06-10    False
2022-06-11    False
2022-06-12    False
Freq: D, Name: A, dtype: bool

df[df["A"]>0]

df

df[df["B"] < 0]

• 使用isin()过滤方法：

df3 = df.copy()

df3

df3["E"] = ["zero","one","two","three","four","five"]

df3

df3["E"]

2022-06-07     zero
2022-06-08      one
2022-06-09      two
2022-06-10    three
2022-06-11     four
2022-06-12     five
Freq: D, Name: E, dtype: object

df3["E"].isin(["two"])

2022-06-07    False
2022-06-08    False
2022-06-09     True
2022-06-10    False
2022-06-11    False
2022-06-12    False
Freq: D, Name: E, dtype: bool

df3["E"].isin(["two","four"])

2022-06-07    False
2022-06-08    False
2022-06-09     True
2022-06-10    False
2022-06-11     True
2022-06-12    False
Freq: D, Name: E, dtype: bool

df3[df3["E"].isin(["two","four"])]

设置

• 设置新列会自动按索引对齐数据：

s1 = pd.Series([1,2,3,4,5,6],index=pd.date_range("20220607",periods=6))

s1

2022-06-07    1
2022-06-08    2
2022-06-09    3
2022-06-10    4
2022-06-11    5
2022-06-12    6
Freq: D, dtype: int64

• 按标签设置值：

df.at[dates[0],"A"] = 0

df

• 按位置设置值

df

df.iat[0,3]=0

df

• 通过分配一个NumPy数组来设置：

df.loc[:,"D"]

2022-06-07    0.000000
2022-06-08    1.084270
2022-06-09    0.561446
2022-06-10    0.046002
2022-06-11    0.165982
2022-06-12    0.890236
Freq: D, Name: D, dtype: float64

df.loc[:,"D"] = np.array([5] * len(df))

df

df.loc[:,"F"] = np.array([i for i in range(6)])

df

df.loc[:,"E"] = np.array([5] * len(df))

df

• where带设置的操作：

df4 = df.copy()

df4

df4 > 0

df4[df4>0]

-df4

# 条件符合的不变，条件不符合的变为相反数
df4[df4>0] = -df4

df4

df4

df3

df6 = df.copy()

df6

df6>0

df6[df6>0]

df6

-df6

df6[df6>0] = -df6

df6

df6

df7 = -df6

df7

df7[df7>0]

df7[df7>0]=0

df7

缺失数据

• pandas 主要使用该值np.nan来表示缺失数据。默认情况下，它不包含在计算中。

• 重新索引允许您更改/添加/删除/指定轴上的索引。这将返回数据的副本：

df

df1 = df.reindex(index=dates[0:4],columns=list(df.columns) + ["E"])

df1.loc[dates[0] :dates[1],"E"] = 1

df1

• 要删除任何缺少数据的行:

df1.dropna(how="any")

df1 = df1[df1>0]

df1

df1.dropna(how="any")

df6

-df6

df8 = -df6[-df6>0]

df8

# 删除任何缺少数据的行
df8.dropna(how="any")

• 填充缺失数据：

df1

df1.fillna(value=5)

• 要获取值所在的布尔掩码nan:

df1

pd.isna(df1)

操作

统计

• 操作通常排除丢失的数据

• 执行描述性统计：

df

df.mean()

A   -0.487944
B    0.205386
C    0.333654
D    5.000000
F    2.500000
E    5.000000
dtype: float64

• 在另一个轴上进行相同的操作:

df.mean(1)

2022-06-07    1.666667
2022-06-08    1.959773
2022-06-09    2.385941
2022-06-10    2.037597
2022-06-11    2.045275
2022-06-12    2.455842
Freq: D, dtype: float64

df.mean(0)

A   -0.487944
B    0.205386
C    0.333654
D    5.000000
F    2.500000
E    5.000000
dtype: float64

• 使用具有不同维度且需要对齐的对象进行操作。此外，pandas会自动沿指定维度进行广播：

s = pd.Series([1,3,5,np.nan,6,8],index=dates).shift(2)

s

2022-06-07    NaN
2022-06-08    NaN
2022-06-09    1.0
2022-06-10    3.0
2022-06-11    5.0
2022-06-12    NaN
Freq: D, dtype: float64

pd.Series([1,3,5,np.nan,6,8],index=dates).shift(3)

2022-06-07    NaN
2022-06-08    NaN
2022-06-09    NaN
2022-06-10    1.0
2022-06-11    3.0
2022-06-12    5.0
Freq: D, dtype: float64

pd.Series([1,3,5,np.nan,6,8],index=dates).shift(1)

2022-06-07    NaN
2022-06-08    1.0
2022-06-09    3.0
2022-06-10    5.0
2022-06-11    NaN
2022-06-12    6.0
Freq: D, dtype: float64

pd.Series([1,3,5,np.nan,6,8],index=dates)

2022-06-07    1.0
2022-06-08    3.0
2022-06-09    5.0
2022-06-10    NaN
2022-06-11    6.0
2022-06-12    8.0
Freq: D, dtype: float64

dates

DatetimeIndex(['2022-06-07', '2022-06-08', '2022-06-09', '2022-06-10',
               '2022-06-11', '2022-06-12'],
              dtype='datetime64[ns]', freq='D')

pd.Series([1,3,5,np.nan,7,8],index=dates)

2022-06-07    1.0
2022-06-08    3.0
2022-06-09    5.0
2022-06-10    NaN
2022-06-11    7.0
2022-06-12    8.0
Freq: D, dtype: float64

# 默认情况下，shift函数是在行方向上移动一个单位
# shift(2)在行方向上移动两个单位

s = pd.Series([1,3,5,np.nan,7,8],index=dates).shift(2)

s

2022-06-07    NaN
2022-06-08    NaN
2022-06-09    1.0
2022-06-10    3.0
2022-06-11    5.0
2022-06-12    NaN
Freq: D, dtype: float64

应用

• 对数据应用函数：

df

np.cumsum

<function numpy.cumsum(a, axis=None, dtype=None, out=None)>

df.apply(np.cumsum)

df

df.apply(lambda x: x.max() - x.min())

A    1.902626
B    2.782767
C    1.946656
D    0.000000
F    5.000000
E    0.000000
dtype: float64

df.apply(lambda x: x.max() - x.min(),axis=1)

2022-06-07    5.000000
2022-06-08    5.287430
2022-06-09    5.200227
2022-06-10    6.609961
2022-06-11    6.833497
2022-06-12    5.616906
Freq: D, dtype: float64

• series，只是一个一维数据结构，它由index和value组成。
• dataframe，是一个二维结构，除了拥有index和value之外，还拥有column。
• 联系：
• dataframe由多个series组成，无论是行还是列，单独拆分出来都是一个series。

直方图

s = pd.Series(np.random.randint(0,7,size=10))

s

0    2
1    5
2    2
3    4
4    1
5    3
6    0
7    2
8    5
9    4
dtype: int32

s.value_counts()

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

字符串的方法

• Series 在属性中配备了一组字符串处理方式str,可以方便地对数组的每个元素进行操作,如下面的代码片段所示。请注意，模式匹配str通常默认使用正则表达式

s = pd.Series(["A","B","C","Aaba","Baca",np.nan,"CABA","dog","cat"])

s

0       A
1       B
2       C
3    Aaba
4    Baca
5     NaN
6    CABA
7     dog
8     cat
dtype: object

s.str

<pandas.core.strings.accessor.StringMethods at 0x26552ed2a90>

s.str.lower()

0       a
1       b
2       c
3    aaba
4    baca
5     NaN
6    caba
7     dog
8     cat
dtype: object

s.str.upper()

0       A
1       B
2       C
3    AABA
4    BACA
5     NaN
6    CABA
7     DOG
8     CAT
dtype: object

合并

• 在连接/合并类型操作的情况下,pandas提供了各种工具，可以轻松地将Series和DataFrame对象与索引和关系代数功能的各种集合逻辑组合在一起。

• 将pandas对象与连接在一起concat():

# 生成一个浮点数或N维浮点数组，取数范围：正态分布的随机样本数。
df = pd.DataFrame(np.random.randn(10,4))

df

pd.DataFrame(np.random.randn(10,4))

df

# 拆分
df[:3]

df[3:7]

df[7:]

pieces=[df[:3],df[3:7],df[7:]]

pieces

[          0         1         2         3
 0  0.879358 -0.162415 -0.122199 -1.436661
 1 -0.090463  0.173721 -0.425374 -0.509393
 2 -1.155403 -1.351560  0.032734  0.085148,
           0         1         2         3
 3 -0.808055 -1.637611  0.382922  0.525315
 4  0.659453 -0.851103  0.214721  1.031853
 5  0.532633  1.506630  1.476901 -1.016453
 6  0.860219  3.015384  1.003056 -2.795348,
           0         1         2         3
 7  0.580518 -2.575408  1.470146 -1.946652
 8 -1.104715  0.954115  0.479431  1.001990
 9  0.709469 -1.613924  0.424452 -0.641368]

pd.concat(pieces)

 a = [df[3:]]

a

[          0         1         2         3
 3 -0.808055 -1.637611  0.382922  0.525315
 4  0.659453 -0.851103  0.214721  1.031853
 5  0.532633  1.506630  1.476901 -1.016453
 6  0.860219  3.015384  1.003056 -2.795348
 7  0.580518 -2.575408  1.470146 -1.946652
 8 -1.104715  0.954115  0.479431  1.001990
 9  0.709469 -1.613924  0.424452 -0.641368]

pd.concat(a)

pd

<module 'pandas' from 'D:\\software\\anaconda\\lib\\site-packages\\pandas\\__init__.py'>

df

• [笔记]
• 向a添加列DataFrame相对较快。但是，添加一行需要一个副本，并且可能很昂贵。我们建议将预先构建的记录列表传递给DataFrame构造函数，而不是DataFrame通过迭代地将记录附加到它来构建一个。

加入

• SQL样式合并

left = pd.DataFrame({"key":["foo","foo"],"lval":[1,2]})

left

right = pd.DataFrame({"key":["foo","foo"],"rval":[4,5]})

right

pd.merge(left,right,on="key")

pd

<module 'pandas' from 'D:\\software\\anaconda\\lib\\site-packages\\pandas\\__init__.py'>

left

right

# pd.merge(left,right,on="rval") 会报错，因为没有相同字段

• 例子

left = pd.DataFrame({"key":["foo","bar"],"lval":[1,2]})

left

right = pd.DataFrame({"key":["foo","bar"],"rval":[4,5]})

right

pd.merge(left,right,on="key")

分组

• "分组依据"是指涉及以下一个或多个步骤的过程：
• 根据某些标准将数据分组
• 将函数独立应用于每个组
• 将结果组合成数据结构

df = pd.DataFrame({
    "A":["foo","bar","foo","bar","foo","bar","foo","foo"],
    "B":["zero","one","two","there","four","five","six","seven"],
    "C":np.random.randn(8),
    "D":np.random.randn(8),
    }
)

df

• 分组，然后将sum()函数应用于结果组:

df.groupby("A")

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000002655C66AFD0>

df.groupby("A").sum()

df.index

RangeIndex(start=0, stop=8, step=1)

df.columns

Index(['A', 'B', 'C', 'D'], dtype='object')

df.groupby("D").mean()

df.groupby("D").sum()

df.sum()

A           foobarfoobarfoobarfoofoo
B    zeroonetwotherefourfivesixseven
C                           0.669445
D                           8.054443
dtype: object

df.groupby("A").sum()

df.groupby("B").sum()

• 按照多列分组形成层次索引，我们可以再次应用该sum()函数：

df.groupby(["A","B"]).sum()

重塑

堆栈

tuples = list(
zip(
    *[
        ["bar","bar","baz","baz","foo","foo","qux","que"],
        ["one","two","one","two","one","two","one","there"]
     ]
    )
)

tuples

[('bar', 'one'),
 ('bar', 'two'),
 ('baz', 'one'),
 ('baz', 'two'),
 ('foo', 'one'),
 ('foo', 'two'),
 ('qux', 'one'),
 ('que', 'there')]

# 构造多变指标(MultiIndex)的四种方式
# from_tuples：列表中的每一个元组 构造MultiIndex
# from_arrays：根据元素的位置，一一对应形成组合 构造MultiIndex
# from_product：通过参数形成的“全组合” 构造MultiIndex
# from_frame：通过 DataFrame 构造MultiIndex
index = pd.MultiIndex.from_tuples(tuples,name=["first","second"])

index

MultiIndex([('bar',   'one'),
            ('bar',   'two'),
            ('baz',   'one'),
            ('baz',   'two'),
            ('foo',   'one'),
            ('foo',   'two'),
            ('qux',   'one'),
            ('que', 'there')],
           names=['first', 'second'])

df = pd.DataFrame(np.random.randn(8,2),index=index,columns=["A","B"])

df

df2 = df[:4]

df2

• 该stack()方法在DataFrame的列中"压缩"一个级别:

stacked = df2.stack()

stacked

first  second   
bar    one     A   -0.484529
               B    1.071371
       two     A   -0.295187
               B    1.255282
baz    one     A   -0.341345
               B    0.790919
       two     A   -1.297284
               B   -1.285871
dtype: float64

• 对于"堆叠"的DataFrame或Series (将aMultiIndexz作为),is index的逆运算，默认情况下会取消堆栈最后一层:stack()unstack()

stacked

first  second   
bar    one     A   -0.484529
               B    1.071371
       two     A   -0.295187
               B    1.255282
baz    one     A   -0.341345
               B    0.790919
       two     A   -1.297284
               B   -1.285871
dtype: float64

stacked.unstack()

stacked.unstack().unstack()

• stack()就是把二维表转化成一维表
• unstack() 则为stack的逆函数，即把一维表转化成二维表的过程

stacked.unstack(1)