首页 > 其他分享 >Pandas学习笔记

Pandas学习笔记

时间：2024-03-31 14:04:00浏览次数：28  
标签：df 笔记 学习 DataFrame pd print import data Pandas

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()

标签：df,笔记,学习,DataFrame,pd,print,import,data,Pandas
From： https://blog.csdn.net/JKQ8525350/article/details/137198767

相关文章

  • Open CASCADE学习|GeomFill_Frenet
    GeomFill_Frenet继承自GeomFill_TrihedronLaw类。GeomFill_Frenet类主要用于实现Frenet标架的计算。Frenet标架是一个沿曲线移动的局部坐标系，它由切向量、法向量和副法向量组成，常用于机器人学、计算机图形学等领域。 classGeomFill_Frenet:publicGeomFill_TrihedronLaw......
  • QTP/UFT 学习笔记：函数方法等记录
    ​原记录在CSDN上的，后来被自动转VIP了，我搬过来免费看看，小东西没必要VIP，主打一个知识无价，朴实无华。1、Back效果等同于浏览器窗口上的【回退】按钮，使浏览器返回上一个页面​​![](https://img2024.cnblogs.com/blog/1202750/202403/1202750-20240331130946866-2132113900.png)......
  • 机器学习 实验一
    一、实验名称感知学习算法（PerceptionLearningAlgorithm，PLA）二、实验目的及任务要求在本地python环境或aistudio私有云环境中，熟悉感知学习算法（PerceptionLearningAlgorithm，PLA），体会理论转为实践操作。三、实验环境Aistudio或者本地python学习环境六、实验小结请写一......
  • JavaScript高级 —— 学习（二）
    目录一、深入对象（一）创建对象三种方式1.利用对象字面量创建2.利用newObject()创建3.利用构造函数创建（二）利用构造函数创建对象1.构造函数介绍2.约定3.实例化执行过程（三）实例成员&静态成员1.实例成员说明：2.静态成员说明：（四）内置构造函数1.包装类型：String：lengt......
  • 【JavaParser笔记02】JavaParser解析Java源代码中的类字段信息（javadoc注释、字段​​
    这篇文章，主要介绍如何使用JavaParser解析Java源代码中的类字段信息（javadoc注释、字段名称）。目录一、JavaParser依赖库1.1、引入依赖1.2、获取类成员信息（1）案例代码<......
  • FFmpeg开发笔记（十）Linux环境给FFmpeg集成vorbis和amr
    ​FFmpeg内置了aac音频格式，在《FFmpeg开发实战：从零基础到短视频上线》一书的“5.2.2 Linux环境集成mp3lame”又介绍了如何给FFmpeg集成mp3格式，常见的音频文件除了这两种之外，还有ogg和amr两种格式也较常用。其中ogg格式的编解码依赖于libogg和libvorbis，而amr格式的编解码依赖于op......
  • 吴恩达2022机器学习专项课程(一） 4.4 学习率
    问题预览/关键词学习率太小有什么影响？学习率太大有什么影响？如果成本函数达到局部最小值，使用梯度下降还能继续最小化吗？为什么学习率固定，而最小化成本函数的步幅却越来越缓？如何选择合适的学习率？笔记1.学习率太小学习率太小，导数项会乘以非常小的数，梯度下降速度过慢，不符合尽......
  • m基于深度学习的64QAM调制解调系统频偏估计和补偿算法matlab仿真
    1.算法仿真效果matlab2022a仿真结果如下：  算法涉及理论知识概要   2.2基于深度学习的频偏估计和补偿算法       基于深度学习的频偏估计和补偿算法利用深度神经网络来建立接收信号与频偏之间的非线性映射关系,通过训练网络模型来实现频偏的估计和补......
  • JC3509人工智能机器学习
    人工智能2023-2024年人工智能理学学士请仔细阅读以下所有信息**评估I简报文件——单独评估（无团队合作）课程：JC3509–机器学习注意：这部分评估说明课程总分的30%。学习成果成功完成此部分后，学生将具备以下区域：•能够识别、准备和管理适当的数据集进行分析。•能够适当地呈现数据分析的......
  • 政安晨：【Keras机器学习实践要点】（十）—— 自定义保存和序列化
    目录导言涵盖的APISetup状态保存自定义构建和编译保存自定义结论政安晨的个人主页：政安晨欢迎 ......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99