Pandas学习笔记

已于 2024-03-31 22:58:33 修改
阅读量951 收藏 14
点赞数 16
文章标签： pandas 学习 笔记
于 2024-03-31 13:50:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jkq8525350/article/details/137198767
版权

Pandas学习笔记

Pandas官方文档非常全面，但从希望快速上手使用的角度，过于全面，不过Pandas官方提供了Cheet Sheet，概要总结了Pandas的核心功能，相对于官方文档来说更加简明，不过缺点则是从刚上手使用的角度来说过于简明

于是本篇文章就围绕Cheet Sheet，增加相应的样例代码，从而在不丢失简明的基础上，逐步深入，从而能快速掌握Pandas，如果工作需要更高级的功能，再深入研究官方文档即可

创建DataFrames

通过指定每列数据构造

import pandas as pd

df = pd.DataFrame(
   {"a": [4, 5, 6],
    "b": [7, 8, 9],
    "c": [10, 11, 12]},
   index=[1, 2, 3])

print(df)

   a  b   c
1  4  7  10
2  5  8  11
3  6  9  12

可以简单理解为字典的键作为了列名，而idnex则作为了行号

通过指定每行数据构造

import pandas as pd

df = pd.DataFrame(
    [[4, 7, 10],
     [5, 8, 11],
     [6, 9, 12]],
    index=[1, 2, 3],
    columns=['a', 'b', 'c'])

print(df)

   a  b   c
1  4  7  10
2  5  8  11
3  6  9  12

对于双层列表（矩阵）形式的数据，通过columns参数指定列名

创建多层索引

import pandas as pd

df = pd.DataFrame(
    {"a": [4, 5, 6],
     "b": [7, 8, 9],
     "c": [10, 11, 12]},
    index=pd.MultiIndex.from_tuples([('d', 1), ('d', 2), ('e', 2)], 
                                    names=['n', 'v']))

print(df)

     a  b   c
n v          
d 1  4  7  10
  2  5  8  11
e 2  6  9  12

第一层索引名为n，包括d、e，第二层索引名为v，包括1、2

方法链

大多数Pandas方法的返回值还是DataFrame，于是可以通过链式调用的形式，增加代码的可读性

df = (pd.melt(df)
      .rename(columns={'variable': 'var', 'value': 'val'})
      .query('val >= 200')
      )

变形数据

宽格式转换为长格式

import pandas as pd

# 创建示例DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Cathy'],
    'Math': [90, 85, 95],
    'Physics': [88, 82, 90],
    'Chemistry': [87, 80, 92]
}
df = pd.DataFrame(data)

# 使用melt函数将数据从宽格式转换为长格式
melted_df = df.melt(id_vars='Name', value_vars=['Math', 'Physics', 'Chemistry'], var_name='Subject', value_name='Score')

# 打印转换后的长格式数据
print(melted_df)

    Name    Subject  Score
0  Alice       Math     90
1    Bob       Math     85
2  Cathy       Math     95
3  Alice    Physics     88
4    Bob    Physics     82
5  Cathy    Physics     90
6  Alice  Chemistry     87
7    Bob  Chemistry     80
8  Cathy  Chemistry     92

长格式：典型的包括3列，每一行就代表某一行某一列对应的某个值，从而也可以将一张表的信息全部装下

长格式转换为宽格式

import pandas as pd

# 创建示例DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Cathy', 'Alice', 'Bob', 'Cathy', 'Alice', 'Bob', 'Cathy'],
    'Subject': ['Math', 'Math', 'Math', 'Physics', 'Physics', 'Physics', 'Chemistry', 'Chemistry', 'Chemistry'],
    'Score': [90, 85, 95, 88, 82, 90, 87, 80, 92]
}
df = pd.DataFrame(data)

# 使用pivot函数将数据从长格式转换为宽格式
pivot_df = df.pivot(index='Name', columns='Subject', values='Score').reset_index()

# 打印转换后的宽格式数据
print(pivot_df)

Subject   Name  Chemistry  Math  Physics
0        Alice         87    90       88
1          Bob         80    85       82
2        Cathy         92    95       90

宽格式：将一个东西的所有信息都放在一行上，和常规数据库的表类似

垂直拼接

import pandas as pd

# 创建两个示例DataFrame
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                    'B': ['B0', 'B1', 'B2'],
                    'C': ['C0', 'C1', 'C2']})

df2 = pd.DataFrame({'A': ['A3', 'A4', 'A5'],
                    'B': ['B3', 'B4', 'B5'],
                    'C': ['C3', 'C4', 'C5']})

# 使用concat函数在垂直方向上合并这两个DataFrame
result = pd.concat([df1, df2])

# 打印合并结果
print(result)

    A   B   C
0  A0  B0  C0
1  A1  B1  C1
2  A2  B2  C2
0  A3  B3  C3
1  A4  B4  C4
2  A5  B5  C5

水平拼接

import pandas as pd

# 创建两个示例DataFrame
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                    'B': ['B0', 'B1', 'B2']})

df2 = pd.DataFrame({'C': ['C0', 'C1', 'C2'],
                    'D': ['D0', 'D1', 'D2']})

# 使用concat函数在水平方向上合并这两个DataFrame
result = pd.concat([df1, df2], axis=1)

# 打印合并结果
print(result)

    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2

根据某列进行排序

import pandas as pd

# 创建示例数据
data = {
    'brand': ['Ford', 'Toyota', 'BMW', 'Audi'],
    'mpg': [25, 30, 27, 23]
}
df = pd.DataFrame(data)

# 使用 sort_values() 方法按照mpg列对 DataFrame 进行排序
sorted_df = df.sort_values('mpg')
print(sorted_df)

    brand  mpg
3    Audi   23
0    Ford   25
2     BMW   27
1  Toyota   30

根据索引进行排序

import pandas as pd

# 创建示例数据
data = {
    'col1': [3, 2, 1],
    'col2': ['A', 'B', 'C']
}
df = pd.DataFrame(data)

# 对 DataFrame 根据索引进行排序
sorted_df = df.sort_index()
print(sorted_df)

   col1 col2
0     3    A
1     2    B
2     1    C

重命名列名

import pandas as pd

# 创建示例数据
data = {
    'x': [1, 2, 3],
    'y': [4, 5, 6],
    'z': [7, 8, 9]
}
df = pd.DataFrame(data)

# 使用 rename() 方法重命名列
df_renamed = df.rename(columns={'y': 'year'})

print(df_renamed)

   x  year  z
0  1     4  7
1  2     5  8
2  3     6  9

重置索引

import pandas as pd

# 创建示例数据
data = {
    'index': ['A', 'B', 'C'],
    'value': [1, 2, 3]
}
df = pd.DataFrame(data)

# 对 DataFrame 进行重置索引
reset_df = df.reset_index()
print(reset_df)

   level_0 index  value
0        0     A      1
1        1     B      2
2        2     C      3

将当前的索引列变为普通的数据列，并重新生成默认整数索引

删除指定的列

import pandas as pd

# 创建示例数据
data = {
    'Length': [2, 3, 4],
    'Height': [3, 4, 5],
    'Width': [1, 1, 1]
}
df = pd.DataFrame(data)

# 使用 drop() 方法删除指定的列
new_df = df.drop(columns=['Length', 'Height'])
print(new_df)

   Width
0      1
1      1
2      1

筛选

筛选行

筛选符合条件的行

import pandas as pd

# 创建示例DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Cathy', 'David'],
    'Age': [25, 30, 22, 28],
    'Gender': ['F', 'M', 'F', 'M']
}
df = pd.DataFrame(data)

# 过滤年龄大于25岁的行
filtered_df = df[df['Age'] > 25]

# 打印过滤后的DataFrame
print(filtered_df)

    Name  Age Gender
1    Bob   30      M
3  David   28      M

去除重复行

import pandas as pd

# 创建示例DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Cathy', 'Alice', 'Bob'],
    'Age': [25, 30, 22, 25, 30]
}
df = pd.DataFrame(data)

# 删除重复行
deduplicated_df = df.drop_duplicates()

# 打印删除重复行后的DataFrame
print(deduplicated_df)

    Name  Age
0  Alice   25
1    Bob   30
2  Cathy   22

通过query筛选符合条件的行

import pandas as pd

# 创建示例DataFrame
data = {
    'Width': [3, 4, 2, 5],
    'Length': [7, 6, 8, 5]
}
df = pd.DataFrame(data)

# 使用query来筛选行
filtered_df = df.query('Length > 7 and Width < 8')

# 打印筛选后的DataFrame
print(filtered_df)

   Width  Length
2      2       8

除了上面的，还有：随机取出某个比例的行、随机取出指定数量的行，取出最大的n行，取出最小的n行，取出前n行，取出后n行

筛选列

筛选多列

import pandas as pd

# 创建示例DataFrame
data = {
    'id': [1, 2, 3, 4],
    'width': [3, 4, 2, 5],
    'length': [7, 6, 8, 5],
    'species': ['a', 'b', 'a', 'c']
}
df = pd.DataFrame(data)

# 选择特定列
selected_columns = df[['width', 'length', 'species']]

# 打印选择的列
print(selected_columns)

   width  length species
0      3       7       a
1      4       6       b
2      2       8       a
3      5       5       c

筛选单列

import pandas as pd

# 创建示例DataFrame
data = {
    'width': [3, 4, 2, 5],
    'length': [7, 6, 8, 5],
    'species': ['a', 'b', 'a', 'c']
}
df = pd.DataFrame(data)

# 选择特定列
selected_column = df['width']

# 打印选择的列
print(selected_column)

0    3
1    4
2    2
3    5
Name: width, dtype: int64

筛选符合正则表达式的列

import pandas as pd

# 创建示例DataFrame
data = {
    'apple': [3, 4, 2, 5],
    'banana': [7, 6, 8, 5],
    'cherry': [2, 8, 5, 7],
    'date': [11, 12, 13, 14]
}
df = pd.DataFrame(data)

# 使用正则表达式选择列名
selected_columns = df.filter(regex='^a')  # 选择以字母 'a' 开头的列

# 打印选择的列
print(selected_columns)

   apple
0      3
1      4
2      2
3      5

筛选行和列

iloc：通过索引数字定位的形式

import pandas as pd

# 创建示例DataFrame
data = {
    'A': [1, 2, 3, 4],
    'B': [5, 6, 7, 8],
    'C': [9, 10, 11, 12],
    'D': [13, 14, 15, 16],
    'E': [17, 18, 19, 20]
}
df = pd.DataFrame(data)

# 使用iloc来选择特定的行和列
selected_data = df.iloc[:, [1, 2, 4]]

# 打印选择的行和列
print(selected_data)

   B   C   E
0  5   9  17
1  6  10  18
2  7  11  19
3  8  12  20

loc：通过列名定位的形式

import pandas as pd

# 创建示例DataFrame
data = {
    'a': [15, 8, 12, 20],
    'b': [25, 18, 22, 30],
    'c': [35, 28, 32, 40]
}
df = pd.DataFrame(data)

# 使用 loc 来选择符合特定条件的行和指定的列
selected_data = df.loc[df['a'] > 10, ['a', 'c']]

# 打印选择的行和列
print(selected_data)

    a   c
0  15  35
2  12  32
3  20  40

总结：可以看到无论是iloc，还是loc都可以传递两个参数，第一个参数代表过滤行，第二个条件代表过滤列，如果只有一个参数，那么只会过滤行，同时参数支持多种类型，比如

  • 冒号，代表整行，如df.iloc[:, [1, 2, 5]]
  • 索引列表，代表列号，df.iloc[:, [1, 2, 5]]
  • 索引1：索引2，代表列范围，如df.iloc[10:20]
  • 列名1：列名2，代表列范围，如df.loc[:, ‘x2’:‘x4’]
  • 比较运算，代表符合条件的行，如df.loc[df[‘a’] > 10, ['a’, ‘c’]]

iat、at类似，不过是筛选单个值

汇总数据

获得各个值的次数

import pandas as pd

# 创建示例数据
data = {
    'w': ['A', 'B', 'A', 'C', 'A', 'A', 'B']
}
df = pd.DataFrame(data)

# 使用 value_counts() 方法统计 'w' 列中各个取值的出现次数
value_counts_result = df['w'].value_counts()
print(value_counts_result)

w
A    4
B    2
C    1

获得行数

import pandas as pd

# 创建示例数据
data = {
    'A': [1, 2, 3],
    'B': ['a', 'b', 'c']
}
df = pd.DataFrame(data)

# 使用 len(df) 获取 DataFrame 的行数
rows_count = len(df)
print(rows_count)

3

获得行数和列数

import pandas as pd

# 创建示例数据
data = {
    'A': [1, 2, 3],
    'B': ['a', 'b', 'c']
}
df = pd.DataFrame(data)

# 使用 shape 属性获取 DataFrame 的行数和列数
shape = df.shape
print(shape)

(3, 2)

获得唯一值的个数

import pandas as pd

# 创建示例数据
data = {
    'w': ['A', 'B', 'A', 'C', 'A', 'A', 'B']
}
df = pd.DataFrame(data)

# 使用 nunique() 方法获取 'w' 列的唯一值个数
unique_values_count = df['w'].nunique()
print(unique_values_count)

3

获得每一列的统计信息

import pandas as pd

# 创建示例数据
data = {
    'A': [1, 2, 3, 4, 5],
    'B': [10, 20, 30, 40, 50]
}
df = pd.DataFrame(data)

# 使用 describe() 方法生成描述性统计信息
description = df.describe()
print(description)

              A          B
count  5.000000   5.000000
mean   3.000000  30.000000
std    1.581139  15.811388
min    1.000000  10.000000
25%    2.000000  20.000000
50%    3.000000  30.000000
75%    4.000000  40.000000
max    5.000000  50.000000

其他

import pandas as pd

# 创建示例DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Cathy', 'David'],
    'Age': [25, 30, 22, 28],
    'Score': [80, 75, 90, 85]
}
df = pd.DataFrame(data)

# 计算年龄的均值
average_age = df['Age'].mean()

# 计算分数的总和
total_score = df['Score'].sum()

# 打印汇总结果
print("Average Age:", average_age)
print("Total Score:", total_score)

Average Age: 26.25
Total Score: 330

出了上面的形式，还可以取出某一列数据，求和、计算平均值、最大值、最小值、百分位数、标准差、中位数等

分组数据

根据某一列来分组

import pandas as pd

# 创建示例数据
data = {
    'col1': ['A', 'B', 'A', 'B', 'A', 'A'],
    'col2': [1, 2, 2, 3, 3, 4],
    'col3': [10, 20, 30, 40, 50, 60]
}
df = pd.DataFrame(data)

# 按 'col1' 列进行分组并计算平均值
grouped = df.groupby(by='col1').mean()
print(grouped)

      col2  col3
col1            
A      2.5  37.5
B      2.5  30.0

按指定的列进行分组，然后计算每一列，每个分组

根据某一个索引来分组

import pandas as pd

# 创建示例DataFrame（带有多层索引）
arrays = [['A', 'A', 'B', 'B'], [1, 2, 1, 2]]
index = pd.MultiIndex.from_arrays(arrays, names=('ind', 'sub_ind'))
df = pd.DataFrame({'values': [10, 20, 30, 40]}, index=index)
print(df)

# 按照第一级索引 "ind" 进行分组，并计算每组的总和
grouped = df.groupby(level="ind").sum()

# 打印分组计算的结果
print(grouped)

             values
ind sub_ind        
A   1            10
    2            20
B   1            30
    2            40

     values
ind        
A        30
B        70

按指定的行索引分组，然后计算每一列、每个分组

下移/上移

import pandas as pd

# 创建示例数据
data = {
    'value': [10, 20, 30, 40, 50]
}
df = pd.DataFrame(data)

# 使用 shift(1) 方法将数据向下移动一个位置
shifted_df = df.shift(1)
print(shifted_df)

   value
0    NaN
1   10.0
2   20.0
3   30.0
4   40.0

秩

import pandas as pd

# 创建示例数据
data = {
    'A': [10, 20, 20, 30, 30, 30]
}
df = pd.DataFrame(data)

# 使用 rank(method='dense') 方法计算 'A' 列中各个元素的秩
ranked_values = df['A'].rank(method='dense')
print(ranked_values)

0    1.0
1    2.0
2    2.0
3    3.0
4    3.0
5    3.0
Name: A, dtype: float64

累计值

比如累加和、累加最大值、最小值、累加乘积

import pandas as pd

# 创建示例数据
data = {
    'A': [1, 2, 3, 4, 5]
}
df = pd.DataFrame(data)

# 使用 cumsum() 方法计算 'A' 列中各个元素的累积和
cumulative_sum = df['A'].cumsum()
print(cumulative_sum)

0     1
1     3
2     6
3    10
4    15
Name: A, dtype: int64

处理缺失值

删除缺失值

import pandas as pd

# 创建示例数据
data = {
    'A': [1, 2, None, 4],
    'B': [None, 5, 6, 7],
    'C': [8, 9, 10, 11]
}
df = pd.DataFrame(data)

# 删除包含缺失值的行
cleaned_df = df.dropna()
print(cleaned_df)

     A    B   C
1  2.0  5.0   9
3  4.0  7.0  11

填充缺失值

import pandas as pd

# 创建示例数据
data = {
    'A': [1, 2, None, 4],
    'B': [None, 5, 6, 7],
    'C': [8, 9, 10, 11]
}
df = pd.DataFrame(data)

# 用指定值填充缺失值
filled_df = df.fillna(value=0)
print(filled_df)

     A    B   C
0  1.0  0.0   8
1  2.0  5.0   9
2  0.0  6.0  10
3  4.0  7.0  11

构建新列

使用assign增加新的列

import pandas as pd

# 创建示例数据
data = {
    'Length': [2, 3, 4, 5],
    'Height': [3, 4, 5, 6]
}
df = pd.DataFrame(data)

# 使用 assign() 方法计算面积并创建新的列
df_with_area = df.assign(Area=lambda x: x['Length'] * x['Height'])
print(df_with_area)

   Length  Height  Area
0       2       3     6
1       3       4    12
2       4       5    20
3       5       6    30

通过数据运算增加单列

import pandas as pd

# 创建示例数据
data = {
    'Length': [2, 3, 4, 5],
    'Height': [3, 4, 5, 6],
    'Depth': [1, 2, 1, 3]
}
df = pd.DataFrame(data)

# 通过对现有列进行运算创建新列
df['Volume'] = df['Length'] * df['Height'] * df['Depth']
print(df)

   Length  Height  Depth  Volume
0       2       3      1       6
1       3       4      2      24
2       4       5      1      20
3       5       6      3      90

使用qcut进行分箱

import pandas as pd

# 创建示例数据
data = {
    'col': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
}
df = pd.DataFrame(data)

# 使用 pd.qcut() 方法对数据进行分箱
df['bin'] = pd.qcut(df['col'], 3, labels=False)
print(df)

   col  bin
0   10    0
1   20    0
2   30    0
3   40    1
4   50    1
5   60    1
6   70    2
7   80    2
8   90    2
9  100    2

每行的最大值

import pandas as pd

# 创建示例数据
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9]
}
df = pd.DataFrame(data)

# 使用 max(axis=1) 方法计算每行的最大值
max_values = df.max(axis=1)
print(max_values)

0    7
1    8
2    9
dtype: int64

将值限制在某个范围内

import pandas as pd

# 创建示例数据
data = {
    'A': [15, 5, -8, 12, 20]
}
df = pd.DataFrame(data)

# 使用 clip(lower=-10, upper=10) 方法将值限制在 -10 和 10 之间
clipped_df = df.clip(lower=-10, upper=10)
print(clipped_df)

    A
0  10
1   5
2  -8
3  10
4  10

计算某列各个元素的绝对值

import pandas as pd

# 创建示例数据
data = {
    'A': [1, -2, 3, -4, 5]
}
df = pd.DataFrame(data)

# 使用 abs() 方法计算 'A' 列中各个元素的绝对值
absolute_values = df['A'].abs()
print(absolute_values)

0    1
1    2
2    3
3    4
4    5
Name: A, dtype: int64

合并数据集

标准连接

包括和数据库类似的：左连接、右连接、内连接、外连接，这里以外连接为例

import pandas as pd

# 创建示例数据
data_a = {
    'x1': ['A', 'B', 'C'],
    'value_a': [1, 2, 3]
}
data_b = {
    'x1': ['A', 'B', 'D'],
    'value_b': [4, 5, 6]
}
adf = pd.DataFrame(data_a)
bdf = pd.DataFrame(data_b)

# 使用 pd.merge() 方法进行外连接
merged_df = pd.merge(adf, bdf, how='outer', on='x1')
print(merged_df)

  x1  value_a  value_b
0  A      1.0      4.0
1  B      2.0      5.0
2  C      3.0      NaN
3  D      NaN      6.0

过滤连接

从a中找到那些在b中有配对的行

import pandas as pd

# 创建示例数据
data_a = {
    'x1': ['A', 'B', 'C', 'D'],
    'value': [1, 2, 3, 4]
}
data_b = {
    'x1': ['A', 'C'],
    'value': [5, 6]
}
adf = pd.DataFrame(data_a)
bdf = pd.DataFrame(data_b)

# 使用 isin() 方法选择满足条件的行
selected_rows = adf[adf['x1'].isin(bdf['x1'])]
print(selected_rows)

  x1  value
0  A      1
2  C      3

从a从找到那些在b中没有配对的行

import pandas as pd

# 创建示例数据
data_a = {
    'x1': ['A', 'B', 'C', 'D'],
    'value': [1, 2, 3, 4]
}
data_b = {
    'x1': ['A', 'C'],
    'value': [5, 6]
}
adf = pd.DataFrame(data_a)
bdf = pd.DataFrame(data_b)

# 使用 isin() 方法进行反向条件选择
selected_rows = adf[~adf['x1'].isin(bdf['x1'])]
print(selected_rows)

  x1  value
1  B      2
3  D      4

Set-like操作

内连接

import pandas as pd

# 创建示例数据
data_y = {
    'key': ['K0', 'K1', 'K2', 'K3'],
    'value_y': ['Y0', 'Y1', 'Y2', 'Y3']
}
data_z = {
    'key': ['K1', 'K2', 'K3', 'K4'],
    'value_z': ['Z0', 'Z1', 'Z2', 'Z3']
}
ydf = pd.DataFrame(data_y)
zdf = pd.DataFrame(data_z)

# 使用 merge 方法进行内连接
merged_df = pd.merge(ydf, zdf)
print(merged_df)

  key value_y value_z
0  K1      Y1      Z0
1  K2      Y2      Z1
2  K3      Y3      Z2

外连接

import pandas as pd

# 创建示例数据
data_y = {
    'key': ['K0', 'K1', 'K2', 'K3'],
    'value_y': ['Y0', 'Y1', 'Y2', 'Y3']
}
data_z = {
    'key': ['K1', 'K2', 'K3', 'K4'],
    'value_z': ['Z0', 'Z1', 'Z2', 'Z3']
}
ydf = pd.DataFrame(data_y)
zdf = pd.DataFrame(data_z)

# 使用 merge 方法进行外连接
merged_df = pd.merge(ydf, zdf, how='outer')
print(merged_df)

  key value_y value_z
0  K0      Y0     NaN
1  K1      Y1      Z0
2  K2      Y2      Z1
3  K3      Y3      Z2
4  K4     NaN      Z3

窗口

计算累计求和

import pandas as pd

# 创建示例数据
data = {
    'value': [1, 2, 3, 4, 5]
}
df = pd.DataFrame(data)

# 使用 expanding() 方法计算累计求和
expanding_sum = df['value'].expanding().sum()
print(expanding_sum)


0     1.0
1     3.0
2     6.0
3    10.0
4    15.0
Name: value, dtype: float64

滚动窗口内的均值

import pandas as pd

# 创建示例数据
data = {
    'value': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}
df = pd.DataFrame(data)

# 使用 rolling(n) 方法计算滚动窗口内的均值
rolling_mean = df['value'].rolling(window=3).mean()
print(rolling_mean)

0    NaN
1    NaN
2    2.0
3    3.0
4    4.0
5    5.0
6    6.0
7    7.0
8    8.0
9    9.0
Name: value, dtype: float64

绘图

直方图

import matplotlib.pyplot as plt
import pandas as pd

# 创建示例数据
data = {
    'value': [3, 5, 7, 7, 8, 5, 9, 10, 6, 7, 8, 11, 12, 13, 14]
}
df = pd.DataFrame(data)

# 使用 plot.hist() 方法绘制直方图
df.plot.hist(bins=5, alpha=0.5)
plt.show()

散点图

import pandas as pd
import matplotlib.pyplot as plt

# 创建示例数据
data = {
    'w': [65, 75, 80, 85, 90, 95],
    'h': [150, 160, 170, 165, 180, 175]
}
df = pd.DataFrame(data)

# 使用 plot.scatter() 方法绘制散点图
df.plot.scatter(x='w', y='h')
plt.show()
白酒永远的神
关注
  • 16
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
pandas学习笔记
weixin_62313535的博客
11-12 1047
pandas
pandas 学习笔记
sky0Lan的博客
04-19 1096
pandas中最主要的两个数据结构：Series、DataFrame Series 一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。 import pandas as pd obj = pd.Series([4, 7, -5, 3]) obj """ 输出 0 4 1 7 2 -5 3 3 dtype: int64 """ Series 的字符串表现形式为：索引在左边，值在右边。由于我们没有为数据指定索引，会自动创.
Pandas学习笔记整理.pdf
03-06
Pandas学习笔记整理
numpy与pandas学习笔记
01-20
#导入numpy库 import numpy as np （1）创建矩阵： a=np.array([ [1,2,3], [2,3,4], [4,5,6]],dtype=np.int64) 函数 说明 np.ones((3,4)) ...左闭右开，步长为2 生成列表，reshape()改变行列形状为
Pandas学习笔记1-Pandas基础
01-17
Pandas含有使数据分析工作变得更快更简单的高级数据结构和操作工具。 Pandas基于NumPy构建，让以NumPy为中心的应用变得更加简单。 1. Pandas数据结构 2. 索引对象
党务学习|基于SprinBoot+vue的大学生党务学习平台(源码+数据库+文档)
伟庭的博客
04-27 695
大学生党务学习平台管理系统按照操作主体分为管理员和用户。用户的功能等。该系统采用了Mysql数据库，Java语言，Spring Boot框架等技术进行编程实现。大学生党务学习平台管理系统可以提高大学生党务学习平台信息管理问题的解决效率，优化大学生党务学习平台信息处理流程，保证大学生党务学习平台信息数据的安全，它是一个非常可靠，非常安全的应用程序。大学生党务学习平台管理系统；入党申请,党课Mysql数据库；Java语言。
集成学习算法学习笔记
m0_46521579的博客
04-27 399
三个臭皮匠顶一个诸葛亮集成学习会考虑多个评估器的建模结果，汇总后得到一个综合的结果，以此来获取比单个模型更好的回归或分类表现。很多独立的机器学习算法：决策树、神经网络、支持向量机集成学习构建了一组基学习器，并将它们综合起来作为最终的模型。在很多集成学习模型中，对基学习器的要求很低。集成学习适用于机器学习的几乎所有领域：回归、分类、推荐和排序。相同的多个基学习器不会带来任何提升，不同的模型取长补短，每个基学习器都会犯不同的错误，综合起来犯错的可能性不大。
web学习
MptRe的博客
04-23 299
day03-01day03-02day03-03day03-05day03-07。
TypeScript学习笔记7-枚举
STATICHIT静砸的博客
04-23 332
如果中断了，那么下面的就从中断的地方继续增长。如果是字符串，那么定义的时候就要全部写上。主要作用就是节省因为枚举带来的性能消耗。如果是纯数字，下面的会进行自动增长。
FreeRTOS学习 -- 任务
不积跬步，无以至千里
04-23 416
单片机裸跑的时候一般都是在main函数里面用 while (1) 做一个大循环来完成所有的处理，即应用程序是一个无限的循环，循环中调用相应的函数完成所需的处理。这个就是单任务系统，也称为前后台系统，中断服务函数作为前台程序，大循环 while (1) 作为后台程序。FreeRTOS是一个抢占式的实时多任务系统。高优先级的任务可以打断低优先级任务的运行而取得CPU的使用权。高优先级的任务执行完成以后重新把CPU的使用权归还给低优先级的任务，这个就是抢占式多任务系统的基本原理。
电源小白入门学习6——锂离子电池特性及充电电路
weixin_67907028的博客
04-26 1016
电源小白入门学习6——锂离子电池特性及充电电路
学习 Rust 的第十二天：如何使用向量
代码说，代码让世界更美好。
04-26 414
学习 Rust 的第十二天：如何使用向量
NumPy简单学习（需要结合书本）
lenard-lhz的博客
04-25 501
需要之后来填坑😓😓😓简单使用numpy💕💕💕。
javaweb学习（day13-数据交换和异步请求)
weixin_51580177的博客
04-23 897
主要介绍了数据的交换以及异步请求，json就是一种规范性的数据传递格式，ajax解决了局部更新等操作
设计模式学习笔记 - 项目实战一：设计实现一个支持各种算法的限流框架（分析）
chenjian723122704的专栏
04-27 858
本章，我们主要对限流框架做了大的项目背景、需求背景介绍，以及更加具体的需求分析，明确了解要做什么，为下面两篇文章（设计和实现）做准备。本章的讲解中，基本的功能需求其实没有多少，但将非功能性需求考虑进去之后，明显就复杂多了。还是那句老话，写出能用的代码简单，写出好用的代码很难。对于限流框架来说，非功能性需求是设计与实现的难点。怎么做到易用、灵活、可扩展、低延迟、高容错，才是开发的重点。此外，本章还提到了一些需求分析的方法，比如画线框图、写用户用例、测试驱动开发等等。
从0开始学习制作一个微信小程序 前端学习部分（7）数据控制操作，修改、判断等
最新发布
m0_74475812的博客
04-29 854
本文将继续讲解小程序中的各种数据操作，非常重要，请务必动手尝试！以后页面中的传参、做判断要用的!!
python pandas库学习笔记
07-28
抱歉，你的问题不够清晰，请提供更具体的问题。 #### 引用[.reference_title] - *1* *3* [Python---pandas的学习笔记](https://blog.csdn.net/A_BIG_DREAMER/article/details/107684032)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Pandas学习笔记](https://blog.csdn.net/qq_44732742/article/details/124660350)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值