pandas数据计算

最新推荐文章于 2024-04-21 15:34:23 发布

才不是小emo的小杨

最新推荐文章于 2024-04-21 15:34:23 发布

阅读量658

点赞数

分类专栏： pandas 文章标签： pandas

本文链接：https://blog.csdn.net/xiaoyang01234/article/details/133217357

版权

pandas 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1 Pandas数据计算

函数名称	描述说明
count()	统计某个非空值的数量。
sum()	求和
mean()	求均值
median()	求中位数
mode()	求众数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积。
cumsum()	计算累计和，axis=0，按照行累加；axis=1，按照列累加。
cumprod()	计算累计积，axis=0，按照行累积；axis=1，按照列累积。
corr()	计算数列或变量之间的相关系数，取值-1到1，值越大表示关联性越强。

从描述统计学角度出发，我们可以对 DataFrame 结构执行聚合计算等其他操作，比如 sum() 求和、mean()求均值等方法。

在 DataFrame 中，使用聚合类方法时需要指定轴(axis)参数。下面介绍两种传参方式：

对行操作，默认使用 axis=0 或者使用 "index"；
对列操作，默认使用 axis=1 或者使用 "columns"。

import pandas as pd

# 创建字典型series结构
dict_data = {'Name': pd.Series(['张三', '李四', '王五', '赵六', '老赵', '小曹', '小陈',
                                '老李', '老王', '小冯', '小何', '老张']),
             'Age': pd.Series([25, 26, 25, 23, 30, 29, 23, 34, 40, 30, 51, 46]),
             'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8, 3.78, 2.98, 4.80, 4.10, 3.65])
             }
df = pd.DataFrame(dict_data)
print(df)


代码的运行结果为：
 Name  Age  Rating
0    张三   25    4.23
1    李四   26    3.24
2    王五   25    3.98
3    赵六   23    2.56
4    老赵   30    3.20
5    小曹   29    4.60
6    小陈   23    3.80
7    老李   34    3.78
8    老王   40    2.98
9    小冯   30    4.80
10   小何   51    4.10
11   老张   46    3.65

1.1 sum()求和

在默认情况下，返回 axis=0 的所有值的和

import pandas as pd

# 创建字典型series结构
dict_data = {'Name': pd.Series(['张三', '李四', '王五', '赵六', '老赵', '小曹', '小陈',
                                '老李', '老王', '小冯', '小何', '老张']),
             'Age': pd.Series([25, 26, 25, 23, 30, 29, 23, 34, 40, 30, 51, 46]),
             'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8, 3.78, 2.98, 4.80, 4.10, 3.65])
             }
df = pd.DataFrame(dict_data)
print(df)
print(df.sum())

代码的运行结果为：
   Name  Age  Rating
0    张三   25    4.23
1    李四   26    3.24
2    王五   25    3.98
3    赵六   23    2.56
4    老赵   30    3.20
5    小曹   29    4.60
6    小陈   23    3.80
7    老李   34    3.78
8    老王   40    2.98
9    小冯   30    4.80
10   小何   51    4.10
11   老张   46    3.65
Name      张三李四王五赵六老赵小曹小陈老李老王小冯小何老张
Age                            382
Rating                       44.92
dtype: object

axis=1 的情况

import pandas as pd

# 创建字典型series结构
dict_data = {
             'Age': pd.Series([25, 26, 25, 23, 30, 29, 23, 34, 40, 30, 51, 46]),
             'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8, 3.78, 2.98, 4.80, 4.10, 3.65])
             }
df = pd.DataFrame(dict_data)
print(df)
print(df.sum(axis=1))


代码运行的结果为：
    Age  Rating
0    25    4.23
1    26    3.24
2    25    3.98
3    23    2.56
4    30    3.20
5    29    4.60
6    23    3.80
7    34    3.78
8    40    2.98
9    30    4.80
10   51    4.10
11   46    3.65
0     29.23
1     29.24
2     28.98
3     25.56
4     33.20
5     33.60
6     26.80
7     37.78
8     42.98
9     34.80
10    55.10
11    49.65
dtype: float64

当axis=1的时候，求的一行的数据和，当字段中出现字符串的时候，尝试将int类型和str类型的数据加起来的时候，就会出现报错。

1.2 mean()求均值

import pandas as pd

# 创建字典型series结构
dict_data = {
    'Age': pd.Series([25, 26, 25, 23, 30, 29, 23, 34, 40, 30, 51, 46]),
    'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8, 3.78, 2.98, 4.80, 4.10, 3.65])
}
df = pd.DataFrame(dict_data)
# print(df)
print(df.mean())


代码运行的结果为：
Age       31.833333
Rating     3.743333
dtype: float64

1.3 std()求标准差

import pandas as pd

# 创建字典型series结构
dict_data = {
    'Age': pd.Series([25, 26, 25, 23, 30, 29, 23, 34, 40, 30, 51, 46]),
    'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8, 3.78, 2.98, 4.80, 4.10, 3.65])
}
df = pd.DataFrame(dict_data)
# print(df)
print(df.std())


代码运行的结果为：
Age       9.232682
Rating    0.661628
dtype: float64

1.4 max()求最大值

import pandas as pd

# 创建字典型series结构
dict_data = {
    'Age': pd.Series([25, 26, 25, 23, 30, 29, 23, 34, 40, 30, 51, 46]),
    'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8, 3.78, 2.98, 4.80, 4.10, 3.65])
}
df = pd.DataFrame(dict_data)
print(df)
# 每个字段的最大值
print("当axis取默认值的时候：\n", df.max())
print("当axis取值为1的时候：\n", df.max(axis=1))


代码运行的结果为：
    Age  Rating
0    25    4.23
1    26    3.24
2    25    3.98
3    23    2.56
4    30    3.20
5    29    4.60
6    23    3.80
7    34    3.78
8    40    2.98
9    30    4.80
10   51    4.10
11   46    3.65
当axis取默认值的时候：
 Age       51.0
Rating     4.8
dtype: float64
当axis取值为1的时候：
 0     25.0
1     26.0
2     25.0
3     23.0
4     30.0
5     29.0
6     23.0
7     34.0
8     40.0
9     30.0
10    51.0
11    46.0
dtype: float64

1.5 median()中位数

import pandas as pd

# 创建字典型series结构
dict_data = {
    'Age': pd.Series([25, 26, 25, 23, 30, 29, 23, 34, 40, 30, 51, 46]),
    'Rating': pd.Series([4.23, 3.24, 3.98, 2.56, 3.20, 4.6, 3.8, 3.78, 2.98, 4.80, 4.10, 3.65])
}
df = pd.DataFrame(dict_data)
# print(df)
print(df.median())


代码的运行结果为：
Age       29.50
Rating     3.79
dtype: float64

2 reindex重置索引

重置索引（reindex）可以更改原 DataFrame 的行标签或列标签，并使更改后的行、列标签与 DataFrame 中的数据逐一匹配。通过重置索引操作，您可以完成对现有数据的重新排序。如果重置的索引标签在原 DataFrame 中不存在，那么该标签对应的元素值将全部填充为 NaN。

2.1 重置行列标签

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'Time': pd.date_range(start='2023-01-01', periods=20, freq='D'),
    'ID': np.linspace(0, 19, num=20),
    'Age': np.random.randint(20, 25, 20),
    'Name': np.random.choice(['Alice', 'Piter', 'Jick'], 20).tolist(),

})
print(df)

# 只获取0 2 5行，A,C,B列
df_new = df.reindex(index=[0, 2, 5], columns=['Time', 'Name', 'Age'])
print(df_new)


代码的运行结果为：
         Time    ID  Age   Name
0  2023-01-01   0.0   23   Jick
1  2023-01-02   1.0   20  Piter
2  2023-01-03   2.0   23   Jick
3  2023-01-04   3.0   20  Piter
4  2023-01-05   4.0   20  Piter
5  2023-01-06   5.0   24  Piter
6  2023-01-07   6.0   21   Jick
7  2023-01-08   7.0   22   Jick
8  2023-01-09   8.0   23   Jick
9  2023-01-10   9.0   22  Alice
10 2023-01-11  10.0   20  Alice
11 2023-01-12  11.0   21  Alice
12 2023-01-13  12.0   24  Piter
13 2023-01-14  13.0   22   Jick
14 2023-01-15  14.0   21  Piter
15 2023-01-16  15.0   20  Alice
16 2023-01-17  16.0   20   Jick
17 2023-01-18  17.0   21  Alice
18 2023-01-19  18.0   21   Jick
19 2023-01-20  19.0   24   Jick
        Time   Name  Age
0 2023-01-01   Jick   23
2 2023-01-03   Jick   23
5 2023-01-06  Piter   24

2.2 填充元素值

reindex_like() 提供了一个可选的参数method

pad/ffill：向前填充值；
bfill/backfill：向后填充值；
nearest：从距离最近的索引值开始填充。
DataFrame:填入一个数组，会使数组与填入的数据的行标签相同


import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randint(10, 20, size=(6, 3)), columns=['col1', 'col2', 'col3'])
df2 = pd.DataFrame(np.random.randint(10, 20, size=(2, 3)), columns=['col1', 'col2', 'col3'])
# 使df2和df1行标签相同
print(df1)
print(df2.reindex_like(df1))
# 向前填充
print("fill方法的填充形式为：\n",df2.reindex_like(df1, method='ffill'))
print("backfill方法的填充形式为：\n", df2.reindex_like(df1, method='backfill'))


代码运行的结果为：
   col1  col2  col3
0    15    14    15
1    13    12    16
2    14    12    19
3    14    19    14
4    19    10    17
5    14    16    16
   col1  col2  col3
0  12.0  16.0  12.0
1  19.0  10.0  11.0
2   NaN   NaN   NaN
3   NaN   NaN   NaN
4   NaN   NaN   NaN
5   NaN   NaN   NaN
fill方法的填充形式为：
    col1  col2  col3
0    12    16    12
1    19    10    11
2    19    10    11
3    19    10    11
4    19    10    11
5    19    10    11
backfill方法的填充形式为：
    col1  col2  col3
0  12.0  16.0  12.0
1  19.0  10.0  11.0
2   NaN   NaN   NaN
3   NaN   NaN   NaN
4   NaN   NaN   NaN
5   NaN   NaN   NaN

限制填充行数

import pandas as pd
import numpy as np

df1 = pd.DataFrame(np.random.randint(10, 20, size=(6, 3)), columns=['col1', 'col2', 'col3'])
df2 = pd.DataFrame(np.random.randint(10, 20, size=(2, 3)), columns=['col1', 'col2', 'col3'])
# 使df2和df1行标签相同
print(df1)
print(df2)
print(df2.reindex_like(df1))
# 向前填充
print(df2.reindex_like(df1, method='ffill', limit=2))


代码的运行结果为：
   col1  col2  col3
0    10    10    13
1    12    14    18
2    19    17    15
3    19    12    17
4    19    10    10
5    17    12    13
   col1  col2  col3
0    16    16    15
1    18    13    12
   col1  col2  col3
0  16.0  16.0  15.0
1  18.0  13.0  12.0
2   NaN   NaN   NaN
3   NaN   NaN   NaN
4   NaN   NaN   NaN
5   NaN   NaN   NaN
   col1  col2  col3
0  16.0  16.0  15.0
1  18.0  13.0  12.0
2  18.0  13.0  12.0
3  18.0  13.0  12.0
4   NaN   NaN   NaN
5   NaN   NaN   NaN

reindex_like() 还提供了一个额外参数 limit，该参数用来控制填充的最大行数

2.3 重命名标签

rename() 方法允许您使用某些映射(dict或Series)或任意函数来对行、列标签重新命名

import pandas as pd

dict_data = {'Name': pd.Series(['张三', '李四', '王五', '赵六']),
             'Age': pd.Series([25, 26, 25, 23]),
             'height': pd.Series([114.23, 123.24, 153.98, 172.56])
             }

df = pd.DataFrame(dict_data)
print(df)
# 对行和列重新命名
print(df.rename(columns={'Name': '姓名', 'Age': '年龄', "height": "身高"}, index={0: 'first', 1: 'second', 2: 'third'}))

代码运行的结果为：
  Name  Age  height
0   张三   25  114.23
1   李四   26  123.24
2   王五   25  153.98
3   赵六   23  172.56
        姓名  年龄      身高
first   张三  25  114.23
second  李四  26  123.24
third   王五  25  153.98
3       赵六  23  172.56

2.4 内置迭代方法

如果想要遍历 DataFrame 的每一行，我们下列函数：

1. tems()：以键值对 (key,value) 的形式遍历；

import pandas as pd

dict_data = {'Name': pd.Series(['张三', '李四', '王五', '赵六']),
             'Age': pd.Series([25, 26, 25, 23]),
             'height': pd.Series([114.23, 123.24, 153.98, 172.56])
             }

df = pd.DataFrame(dict_data)
for data in df.items():
    print(data[1])


代码的运行结果为：
0    张三
1    李四
2    王五
3    赵六
Name: Name, dtype: object
0    25
1    26
2    25
3    23
Name: Age, dtype: int64
0    114.23
1    123.24
2    153.98
3    172.56
Name: height, dtype: float64

1. iterrows()：以 (row_index,row) 的形式遍历行;

import pandas as pd

dict_data = {'Name': pd.Series(['张三', '李四', '王五', '赵六']),
             'Age': pd.Series([25, 26, 25, 23]),
             'height': pd.Series([114.23, 123.24, 153.98, 172.56])
             }

df = pd.DataFrame(dict_data)
print(df)
for data in df.iterrows():
    print(data[1])


代码运行的结果为：
  Name  Age  height
0   张三   25  114.23
1   李四   26  123.24
2   王五   25  153.98
3   赵六   23  172.56
Name          张三
Age           25
height    114.23
Name: 0, dtype: object
Name          李四
Age           26
height    123.24
Name: 1, dtype: object
Name          王五
Age           25
height    153.98
Name: 2, dtype: object
Name          赵六
Age           23
height    172.56
Name: 3, dtype: object

1. itertuples()：使用已命名元组的方式对行遍历。

import pandas as pd

dict_data = {'Name': pd.Series(['张三', '李四', '王五', '赵六']),
             'Age': pd.Series([25, 26, 25, 23]),
             'height': pd.Series([114.23, 123.24, 153.98, 172.56])
             }

df = pd.DataFrame(dict_data)
for data in df.itertuples():
    print(data)


代码运行的结果为：
Pandas(Index=0, Name='张三', Age=25, height=114.23)
Pandas(Index=1, Name='李四', Age=26, height=123.24)
Pandas(Index=2, Name='王五', Age=25, height=153.98)
Pandas(Index=3, Name='赵六', Age=23, height=172.56)

3 sorting排序

Pands 提供了两种排序方法，分别是按标签排序和按数值排序

3.1 标签排序

import pandas as pd
import numpy as np

# 行标签乱序排列，列标签乱序排列
df = pd.DataFrame(np.arange(1, 21).reshape(10, 2),
                  index=[1, 6, 4, 2, 3, 5, 9, 8, 0, 7],
                  columns=['first', 'second'])
print("排序前的df：\n", df)
sorted_df = df.sort_index()
print("排序后的df：\n", sorted_df)

代码运行的结果为：
排序前的df：
    first  second
1      1       2
6      3       4
4      5       6
2      7       8
3      9      10
5     11      12
9     13      14
8     15      16
0     17      18
7     19      20
排序后的df：
    first  second
0     17      18
1      1       2
2      7       8
3      9      10
4      5       6
5     11      12
6      3       4
7     19      20
8     15      16
9     13      14

通过将布尔值传递给ascending参数，可以控制排序的顺序（行号顺序，False为倒序输出，Ture为正序输出）

import pandas as pd
import numpy as np

# 行标签乱序排列，列标签乱序排列
df = pd.DataFrame(np.arange(1, 21).reshape(10, 2),
                  index=[1, 6, 4, 2, 3, 5, 9, 8, 0, 7],
                  columns=['first', 'second'])

sorted_df = df.sort_index(ascending=False)
sorted1_df = df.sort_index(ascending=True)
print("ture:\n", sorted1_df)
print("False:\n", sorted_df)

代码的运行结果为：
ture:
    first  second
0     17      18
1      1       2
2      7       8
3      9      10
4      5       6
5     11      12
6      3       4
7     19      20
8     15      16
9     13      14
False:
    first  second
9     13      14
8     15      16
7     19      20
6      3       4
5     11      12
4      5       6
3      9      10
2      7       8
1      1       2
0     17      18

3.2 列标签排序

通过给 axis 轴参数传递 0 或 1，可以对列标签进行排序。默认情况下，axis=0 表示按行排序；而 axis=1 则表示按列排序。

import pandas as pd
import numpy as np

# 行标签乱序排列，列标签乱序排列
df = pd.DataFrame(np.arange(1, 21).reshape(10, 2),
                  index=[1, 6, 4, 2, 3, 5, 9, 8, 0, 7],
                  columns=[2, 1])

sorted_df = df.sort_index(axis=1)
sorted1_df = df.sort_index(axis=0)
print("axis=0:\n", sorted1_df)
print("axis=1:\n", sorted_df)


代码的运行结果为：
axis=0:
     2   1
0  17  18
1   1   2
2   7   8
3   9  10
4   5   6
5  11  12
6   3   4
7  19  20
8  15  16
9  13  14
axis=1:
     1   2
1   2   1
6   4   3
4   6   5
2   8   7
3  10   9
5  12  11
9  14  13
8  16  15
0  18  17
7  20  19

3.3 按值排序

与标签排序类似，sort_values() 表示按值排序。它接受一个by参数，该参数值是要排序数列的 DataFrame 列名

sort_values() 提供了参数kind

mergesort
heapsort
quicksort

默认为 quicksort(快速排序) ，其中 Mergesort 归并排序是最稳定的算法。

import pandas as pd

df = pd.DataFrame({'col1': [2, 1, 1, 1], 'col2': [1, 3, 2, 4]})
print(df)

sorted_df = df.sort_values(by=['col1', 'col2'], kind="mergesort")
print(sorted_df)


代码的运行结果为：
   col1  col2
0     2     1
1     1     3
2     1     2
3     1     4
   col1  col2
2     1     2
1     1     3
3     1     4
0     2     1

这里的by参数可以传入一个列表，也可以传入其中一个列，如果传入一个列表，他将会将一个列表中所有的列全部进行排序，如果指定传入一个列，他将会排序这一个列。

4 处理缺失值

为什么会存在缺失值

前面章节的示例中，我们遇到过很多 NaN 值，关于缺失值您可能会有很多疑问，数据为什么会丢失数据呢，又是从什么时候丢失的呢？通过下面场景，您会得到答案。

其实在很多时候，人们往往不愿意过多透露自己的信息。假如您正在对用户的产品体验做调查，在这个过程中您会发现，一些用户很乐意分享自己使用产品的体验，但他是不愿意透露自己的姓名和联系方式；还有一些用户愿意分享他们使用产品的全部经过，包括自己的姓名和联系方式。因此，总有一些数据会因为某些不可抗力的因素丢失，这种情况在现实生活中会经常遇到。

什么是稀疏数据

稀疏数据，指的是在数据库或者数据集中存在大量缺失数据或者空值，我们把这样的数据集称为稀疏数据集。稀疏数据不是无效数据，只不过是信息不全而已，只要通过适当的方法就可以“变废为宝”。稀疏数据的来源与产生原因有很多种

由于调查不当产生的稀疏数据；

由于天然限制产生的稀疏数据；

文本挖掘中产生的稀疏数据。

4.1 缺失值处理

通过使用 reindex（重构索引），我们创建了一个存在缺少值的 DataFrame 对象。


import pandas as pd
import numpy as np

df = pd.DataFrame(np.arange(15).reshape(5, 3), index=['a', 'c', 'e', 'f', 'h'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df)


代码的运行结果为：
      0     1     2
a   0.0   1.0   2.0
b   NaN   NaN   NaN
c   3.0   4.0   5.0
d   NaN   NaN   NaN
e   6.0   7.0   8.0
f   9.0  10.0  11.0
g   NaN   NaN   NaN
h  12.0  13.0  14.0

为了使检测缺失值变得更容易，Pandas 提供了 isnull() 和 notnull() 两个函数，它们同时适用于 Series 和 DataFrame 对象。

import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(15).reshape(5, 3), index=['a', 'c', 'e', 'f', 'h'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df)

print(df.isnull())

print(df.notnull())


代码的运行结果为：
      0     1     2
a   0.0   1.0   2.0
b   NaN   NaN   NaN
c   3.0   4.0   5.0
d   NaN   NaN   NaN
e   6.0   7.0   8.0
f   9.0  10.0  11.0
g   NaN   NaN   NaN
h  12.0  13.0  14.0
       0      1      2
a  False  False  False
b   True   True   True
c  False  False  False
d   True   True   True
e  False  False  False
f  False  False  False
g   True   True   True
h  False  False  False
       0      1      2
a   True   True   True
b  False  False  False
c   True   True   True
d  False  False  False
e   True   True   True
f   True   True   True
g  False  False  False
h   True   True   True

使用isnull，如果数据中有空值，将会把所有的空值填为True，使用nonull，如果数据中有空值，将会把所有的空值填为False。
清理并填充缺失值

Pandas 提供了多种方法来清除缺失值。fillna() 函数可以实现用非空数据“填充”NaN 值。

import pandas as pd
import numpy as np

df = pd.DataFrame(np.arange(15).reshape(5, 3), index=['a', 'c', 'e', 'f', 'h'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print(df)

print(df.fillna(0))



代码的运行结果为：
      0     1     2
a   0.0   1.0   2.0
b   NaN   NaN   NaN
c   3.0   4.0   5.0
d   NaN   NaN   NaN
e   6.0   7.0   8.0
f   9.0  10.0  11.0
g   NaN   NaN   NaN
h  12.0  13.0  14.0
      0     1     2
a   0.0   1.0   2.0
b   0.0   0.0   0.0
c   3.0   4.0   5.0
d   0.0   0.0   0.0
e   6.0   7.0   8.0
f   9.0  10.0  11.0
g   0.0   0.0   0.0
h  12.0  13.0  14.0

删除缺失值

如果想删除缺失值，那么使用 dropna() 函数与参数 axis 可以实现。

import pandas as pd
import numpy as np

df = pd.DataFrame(np.arange(15).reshape(5, 3), index=['a', 'c', 'e', 'f', 'h'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])

print(df)

print(df.dropna())


代码的运行结果为：
      0     1     2
a   0.0   1.0   2.0
b   NaN   NaN   NaN
c   3.0   4.0   5.0
d   NaN   NaN   NaN
e   6.0   7.0   8.0
f   9.0  10.0  11.0
g   NaN   NaN   NaN
h  12.0  13.0  14.0
      0     1     2
a   0.0   1.0   2.0
c   3.0   4.0   5.0
e   6.0   7.0   8.0
f   9.0  10.0  11.0
h  12.0  13.0  14.0

5 drop_duplicates()去重

“去重”通过字面意思不难理解，就是删除重复的数据，不仅可以节省内存空间，提高写入性能，还可以提升数据集的精确度，使得数据集不受重复数据的影响。

5.1 函数格式

df.drop_duplicates(subset=['A','B','C'],keep='first',inplace=True)

# subset：表示要进去重的列名，默认为 None。
# keep：有三个可选参数，分别是 first、last、False，默认为 first，表示只保留第一次出现的重复项，删除其余重复项，last 表示只保留最后一次出现的重复项，False 则表示删除所有重复项。
# inplace：布尔值参数，默认为 False 表示删除重复项后返回一个副本，若为 Ture 则表示直接在原数据上删除重复项。

5.2 实际应用

保留第一次出现的重复项

import pandas as pd

data = {
    'A': [1, 0, 1, 1],
    'B': [0, 2, 5, 0],
    'C': [4, 0, 4, 4],
    'D': [1, 0, 1, 1]
}
df = pd.DataFrame(data=data)

print(df.drop_duplicates())

代码的运行结果为：
   A  B  C  D
0  1  0  4  1
1  0  2  0  0
2  1  5  4  1
3  1  0  4  1
   A  B  C  D
0  1  0  4  1
1  0  2  0  0
2  1  5  4  1

keep=False删除所有重复项

import pandas as pd

data = {
    'A': [1, 0, 1, 1],
    'B': [0, 2, 5, 0],
    'C': [4, 0, 4, 4],
    'D': [1, 0, 1, 1]
}
df = pd.DataFrame(data=data)
print(df)
print("-*-"*30)
print(df.drop_duplicates(keep=False))


代码的运行结果为：
   A  B  C  D
0  1  0  4  1
1  0  2  0  0
2  1  5  4  1
3  1  0  4  1
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
   A  B  C  D
1  0  2  0  0
2  1  5  4  1

哈哈哈，感觉上面这个方法好鸡肋，大家要慎用！！
根据指定列标签去重

import pandas as pd

data = {

    'A': [1, 3, 3, 3],
    'B': [0, 1, 2, 0],
    'C': [4, 5, 4, 4],
    'D': [3, 3, 3, 3]
}
df = pd.DataFrame(data=data)
print(df)
# 去除所有重复项，对于B列来说两个0是重复项
# df.drop_duplicates(subset=['B'], keep=False)
# 简写，省去subset参数
df = df.drop_duplicates(['B'], keep=False)
print(df)


代码的运行结果为：
   A  B  C  D
0  1  0  4  3
1  3  1  5  3
2  3  2  4  3
3  3  0  4  3
   A  B  C  D
1  3  1  5  3
2  3  2  4  3

6 分组操作

数据的分组与聚合是关系型数据库中比较常见术语。使用数据库时，我们利用查询操作对各列或各行中的数据进行分组，可以针对其中的每一组数据进行各种不同的操作。

6.1 groupby分组操作

在数据分析中，经常会遇到这样的情况：根据某一列（或多列）标签把数据划分为不同的组别，然后再对其进行数据分析。比如，某网站对注册用户的性别或者年龄等进行分组，从而研究出网站用户的画像（特点）。在 Pandas 中，要完成数据的分组操作，需要使用 groupby() 函数，它和 SQL 的GROUP BY操作非常相似

在划分出来的组（group）上应用一些统计函数，从而达到数据分析的目的，比如对分组数据进行聚合、转换，或者过滤。这个过程主要包含以下三步：

拆分（Spliting）：表示对数据进行分组；
应用（Applying）：对分组数据应用聚合函数，进行相应计算；
合并（Combining）：最后汇总计算结果。

import pandas as pd
import numpy as np

data = {
    "country": ["China"] * 10,
    "year": np.random.randint(1990, 2000, size=10),
    "GDP": np.random.randint(25000, 30000, size=10)
}
df = pd.DataFrame(data)
print(df)

# 计算每一年的GDP的平均值
print(df.groupby("year")["GDP"].mean())

# 计算每一年，中国GDP的平均值
print(df.groupby(["year", "country"])["GDP"].mean())

# 统计每个州出现的国家数
print(df.groupby("year")["country"].count())


代码的运行结果为：
  country  year    GDP
0   China  1991  25486
1   China  1992  27092
2   China  1993  25128
3   China  1999  27032
4   China  1992  26344
5   China  1994  26808
6   China  1996  29409
7   China  1994  27957
8   China  1991  27928
9   China  1994  29473
year
1991    26707.000000
1992    26718.000000
1993    25128.000000
1994    28079.333333
1996    29409.000000
1999    27032.000000
Name: GDP, dtype: float64
year  country
1991  China      26707.000000
1992  China      26718.000000
1993  China      25128.000000
1994  China      28079.333333
1996  China      29409.000000
1999  China      27032.000000
Name: GDP, dtype: float64
year
1991    2
1992    2
1993    1
1994    3
1996    1
1999    1
Name: country, dtype: int64

创建groupby分组对象

使用 groupby() 可以沿着任意轴分组。您可以把分组时指定的键（key）作为每组的组名

df.groupby('year')

查看分组结果

通过调用groups属性查看分组结果

print(df.groupby('year').groups)

计算每一年的GDP平均值

print(df.groupby("year")["GDP"].mean())

多个列标签分组

指定多个列标签进行分组

print(df.groupby(["country", "year"]).groups)

才不是小emo的小杨

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
pandas数据计算

稀疏数据，指的是在数据库或者数据集中存在大量缺失数据或者空值，我们把这样的数据集称为稀疏数据集。稀疏数据不是无效数据，只不过是信息不全而已，只要通过适当的方法就可以“变废为宝”。稀疏数据的来源与产生原因有很多种由于调查不当产生的稀疏数据；由于天然限制产生的稀疏数据；文本挖掘中产生的稀疏数据。
复制链接

扫一扫