dataframe数据常用python操作

于 2024-05-14 08:16:58 发布
阅读量470 收藏 6
点赞数 4
分类专栏： 统计分析软件 文章标签： python 信息可视化 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s1164548515/article/details/138835301
版权

dataframe数据常用python操作

dataframe数据常用知识点

DataFrame是Python中pandas库中一个非常重要的数据结构，它类似于电子表格或SQL表格，可以存储和操作带标签的二维数据。DataFrame的重要知识点如下：

  • 1.创建DataFrame：可以通过读取外部文件、手动创建或从其他数据结构中创建DataFrame。常用的函数包括pandas.DataFrame()、pandas.read_csv()、pandas.read_excel()等。

  • 2.DataFrame数据存取：可以通过不同的函数保存到txt、csv、excel等文件中，同样也可以利用不同的函数从不同的文件中读取数据。常用的函数包括.to_csv()、.to_excel()等。

  • 3.数据查看和选择：可以使用.head()和.tail()方法查看前几行和后几行数据，使用.iloc[]和.loc[]方法选择数据。

  • 4.数据查询：常见的 DataFrame 查询操作包括条件查询、模糊查询和多条件查询等。

  • 5.数据清洗：包括数据的缺失值处理、重复值处理、数据类型转换等。常用的函数包括dropna()、fillna()、drop_duplicates()、astype()等。

  • 6.数据运算：可以进行多种数据运算，包括列之间的运算、行之间的运算、元素级运算等。常用的运算包括加减乘除、apply()、groupby()、merge()等。

  • 7.时间序列操作：pandas提供了多种时间序列处理和分析的工具，包括resample()、rolling()等。这些工具可以用于处理时间序列数据，如时间序列数据的重采样、平滑处理等。

  • 8.数据可视化：可以使用pandas自带的可视化工具进行数据可视化。常用的函数包括plot()、hist()、boxplot()等。此外，还有其他专业的可视化库（如matplotlib和seaborn）。

总之，DataFrame是Python中非常重要的数据结构之一，可以用于处理和分析各种类型的数据，掌握这些知识点可以更好地使用DataFrame进行数据处理和分析。

1.创建dataframe

三种常用的创建DataFrame的方式，分别是使用字典、列表和numpy数组：

1.1使用字典创建DataFrame：

  • 1.直接转换，字典所有的key均为列
import pandas as pd

#创建字典
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}

#将字典转换成DataFrame
df = pd.DataFrame(data)

#打印DataFrame
print(df)
  • 2.字典所有的key为数据框的索引（index），值转换为数据框的列

可以通过pd.DataFrame.from_dict()将字典的键转换为数据框的索引（index），将字典的值转换为数据框的列，然后使用columns参数为列指定名称。

import pandas as pd

# 创建一个示例字典
data = {'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}

# 将字典转换为数据框，键为index，值为列，列名为A、B、C
df = pd.DataFrame.from_dict(data, orient='index', columns=['col1', 'col2', 'clo3'])
print(df)

在上面的代码中，orient='index’参数指定将字典的键用作索引（即行标签），将字典的值用作列。通过columns参数指定列的名称。输出：

   col1 col2 col3
A  1  4  7
B  2  5  8
C  3  6  9

1.2使用列表创建DataFrame：

import pandas as pd

#创建列表
data = [['Tom', 28, 'M'], ['Jack', 14, 'M'], ['Steve', 19, 'M'], ['Lucky', 22, 'F']]

#将列表转换成DataFrame
df = pd.DataFrame(data, columns=['name', 'age', 'gender'])

#打印DataFrame
print(df)

1.3使用numpy数组创建DataFrame：

import pandas as pd
import numpy as np

#创建numpy数组
data = np.array([['Tom', 28, 'M'], ['Jack', 14, 'M'], ['Steve', 19, 'M'], ['Lucky', 22, 'F']])

#将numpy数组转换成DataFrame
df = pd.DataFrame(data, columns=['name', 'age', 'gender'])

#打印DataFrame
print(df)

实际应用中，还可以通过读取外部文件、从数据库中读取数据等方式创建DataFrame：

上次学习了python数据的存取，我们先将上面的dataframe数据分别存到txt、csv、excel文件中：

import pandas as pd

df.to_csv('./data/data_df.txt', index=False, sep='\t')#保存到txt
df.to_csv('./data/data_df.csv', index=False, sep='\t')#保存到csv

#保存到excel
writer = pd.ExcelWriter('./data/data_df.xlsx')
df.to_excel(writer, index=False, sheet_name='Sheet1')
writer.save()

再分别从不同的外部文件中读取数据：

1.4从TXT文件中创建DataFrame：

import pandas as pd

从CSV文件中读取数据
df = pd.read_csv('./data/data_df.txt')

# 打印DataFrame
print(df)

1.5从CSV文件中创建DataFrame：

import pandas as pd

从CSV文件中读取数据
df = pd.read_csv('./data/data_df.csv')

# 打印DataFrame
print(df)

1.6从Excel文件中创建DataFrame：

import pandas as pd

#从Excel文件中读取数据
df = pd.read_excel('./data/data_df.xlsx')

#打印DataFrame
print(df)

此外还可以从MySQL数据库中创建DataFrame：

import pandas as pd
import mysql.connector

#连接MySQL数据库
cnx = mysql.connector.connect(user='root', password='password', host='127.0.0.1', database='test')

#从数据库中读取数据
df = pd.read_sql('SELECT * FROM data', con=cnx)

#关闭数据库连接
cnx.close()

#打印DataFrame
print(df)

上面这些是在实际应用中如何直接创建或通过读取外部文件、从数据库中读取数据等方式创建DataFrame。需要注意的是，不同的数据格式和数据源需要使用不同的读取函数，例如读取JSON文件需要使用pd.read_json()函数，读取SQLite数据库需要使用pd.read_sqlite()函数等等。同时，对于一些大型数据集，可以使用分块读取的方式进行处理，以避免内存不足的问题。

2.dataframe数据保存

  • 保存Dataframe到txt文件
import pandas as pd

data = {'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 35]}

data_df = pd.DataFrame(data)
data_df.to_csv('data_df.txt', index=False, sep='\t')
  • 保存Dataframe到csv文件
import pandas as pd

data = {'name': ['apple', 'banana', 'orange'], 'price': [1, 2, 3]}
data_df = pd.DataFrame(data)
data_df.to_csv('data_df.csv', index=False)
  • 保存Dataframe到Excel文件
import pandas as pd

data = {'name': ['apple', 'banana', 'orange'], 'price': [1, 2, 3]}
data_df = pd.DataFrame(data)
writer = pd.ExcelWriter('data_df.xlsx')
data_df.to_excel(writer, index=False, sheet_name='Sheet1')
writer.save()

3.dataframe数据查看和选择

创建一个dataframe，后续操作均基于这个df进行：

#创建DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}
df = pd.DataFrame(data)

3.1查看前/后n行：

  • 查看DataFrame的前n行:df.head(n)
#查看前2行数据
print(df.head(2))
  • 查看DataFrame的后n行:df.tail(n)
#查看后2行数据
print(df.tail(2))

3.2选择DataFrame中的某列/某行：

  • 选择DataFrame中的某列:df[‘列名’]
#选择name列
name = df['name']

#打印name列
print(name)
  • 选择DataFrame中的某行： df.loc[n]
#选择第2行
row = df.iloc[1]

# 打印第2行
print(row)

3.3选择DataFrame中的多列/多行

  • 选择DataFrame中的多列:df[[‘列名1’, ‘列名2’]]
# 选择name和age列
cols = df[['name', 'age']]

# 打印name和age列
print(cols)
  • 选择DataFrame中的多行：df.iloc[a:b]
# 选择第2-3行
rows = df.iloc[1:2]

# 打印第2-3行
print(rows)

3.4选择DataFrame中的特定行和列

df.at[行数, ‘列名’]

#选择第2行和name列
cell = df.at[1, 'name']

#打印第2行和name列的值
print(cell)

3.5选择DataFrame中的特定列组成子数据框

#选择name列构成新的子数据框，索引列不变
df_new = df[['name']]

#打印新的子数据框
print(df_new )

4.dataframe数据查询

常见的 DataFrame 查询操作包括条件查询、模糊查询和多条件查询等，下面给出一些示例：

4.1条件查询

假设有一个 DataFrame df，其中有 name、age、gender 等列，可以使用如下方式进行条件查询：

#查询 age 大于等于20 岁的行
df[df['age'] >= 20]

#查询 name 是 'Tom' 的行
df[df['name'] == 'Tom']

4.2模糊查询

模糊查询一般使用 str.contains() 方法，可以匹配包含某个字符串的行。

#查询 name 中包含 'Tom' 的行
df[df['name'].str.contains('Tom')]

#查询 name 中以 'T' 开头的行
df[df['name'].str.startswith('T')]

4.3多条件查询

可以通过 & 和 | 连接多个条件进行查询。

#查询 age 大于等于 20 岁且 gender 是女性的行
df[(df['age'] >= 20) & (df['gender'] == 'F')]

#查询 age 小于 20 岁或者 gender 是男性的行
df[(df['age'] < 20) | (df['gender'] == 'M')]

4.4查询数据框的元素是否在指定列表中

查询数据框的元素是否在指定列表中，若在返回对应的行
isin是pandas库中的一个函数，它用于检查数据框中的每个元素是否存在于给定的列表中。下面是一个示例：

# 使用isin函数选取age列中值为25或27的行
df[df['age'].isin([19,22,27])]

5.dataframe数据预处理

数据清洗是数据分析的重要步骤之一，可以帮助我们提高数据质量和准确性。在Python中，pandas库提供了丰富的函数和方法，可以方便地进行数据清洗和处理。以下是几个常用的数据清洗示例：

5.1删除缺失值

  • (1)删除含有缺失值的行:df.dropna()默认为行
import pandas as pd

#创建含有缺失值的DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, None, 19, 22], 
        'gender': ['M', 'M', None, 'F']}
df = pd.DataFrame(data)

#查看含有缺失值的行
null_rows = df[df.isnull().any(axis=1)]
print('含有缺失值的行为：'，null_rows)

#删除含有缺失值的行
df = df.dropna()

#查看删除后的DataFrame数据
print('删除缺失数行后的DataFrame数据为：')
print(df)
  • (2)删除含有缺失值的列:df.dropna(axis=1)
#查看含有缺失值的列
print('含有缺失值的列为：')
print(df.isnull().any())

#删除含有缺失值的列
df = df.dropna(axis=1)

#查看删除后的DataFrame数据
print('删除缺失数列后的DataFrame数据为：')
print(df)
  • (3)删除DataFrame中缺失值达到一定比例的列：
import pandas as pd

#创建一个示例数据框
df = pd.DataFrame({
    'A': [1, 2, 3, 4, 5],
    'B': [5, 4, 3, 2, 1],
    'C': [1, 2, 3, None, None],
    'D': [None, None, None, None, None],
    'E': [None, 1, 2, 3, 4]
})

#计算每一列中缺失值的比例
na_ratio = df.isna().sum() / len(df)

#选出缺失值比例小于0.3的列
cols_to_keep = na_ratio[na_ratio < 0.3].index

#删除缺失值比例大于等于0.3的列
df_clean = df[cols_to_keep].dropna(axis=1)

print(df_clean)

5.2填充缺失值

  • (1)使用常数填充缺失值:df.fillna(value=xx, inplace=True)

可以使用fillna()函数的value参数来填充缺失值。

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, np.nan, 8]})
print(df)

#使用常数填充缺失值
df.fillna(value=0, inplace=True)
print(df)
  • (2)使用均值填充缺失值:df.fillna(value=df.mean(), inplace=True)

可以使用fillna()函数的mean()方法来填充缺失值，将缺失值替换成对应列的均值。

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, np.nan, 8]})
print(df)

#使用均值填充缺失值
df.fillna(value=df.mean(), inplace=True)
print(df)
  • (3)使用前一个/后一个非缺失值填充缺失值:df.fillna(method=‘ffill’/‘bfill’, inplace=True)

可以使用fillna()函数的method参数来指定填充方法，method='ffill’表示使用前一个非缺失值填充缺失值。

import pandas as pd
import numpy as np

df = pd.DataFrame({'A': [1, 2, np.nan, 4], 'B': [5, np.nan, np.nan, 8]})
print(df)

#使用前一个非缺失值填充缺失值
df.fillna(method='ffill', inplace=True)
##使用后一个非缺失值填充缺失值
#df.fillna(method='bfill', inplace=True)
print(df)

5.3数据替换:

df[‘列名’].replace(‘旧值’, ‘新值’)

import pandas as pd

#创建DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}    
df = pd.DataFrame(data)

#将'F'替换为'Female'
df['gender'] = df['gender'].replace('F', 'Female')

#打印清洗后的DataFrame
print(df)

5.4去除重复数据:

df.drop_duplicates()

import pandas as pd

# 创建含有重复数据的DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky', 'Tom'], 
        'age': [28, 14, 19, 22,28], 
        'gender': ['M', 'M', 'M', 'F','M']}       
df = pd.DataFrame(data)

# 去除重复数据
df = df.drop_duplicates()

# 打印清洗后的DataFrame
print(df)

5.5更改数据类型:

df[‘列名’].astype(类型)

import pandas as pd

# 创建DataFrame
data = {'name': ['Tom', 'Jack', 'Steve', 'Lucky'], 
        'age': [28, 14, 19, 22], 
        'gender': ['M', 'M', 'M', 'F']}    
df = pd.DataFrame(data)

# 将'age'列的数据类型更改为int
df['age'] = df['age'].astype(int)

# 打印清洗后的DataFrame
print(df)

5.6删除指定的某一列/某一行

在 Pandas 中，可以使用 drop() 方法删除指定列或行。drop() 方法会返回一个新的 DataFrame，原始的 DataFrame 不会被修改。

如果要删除列，可以将 axis 参数设置为 1。如果要删除行，则将 axis 参数设置为 0。删除列时，需要指定列名，删除行时，需要指定行的索引。

以下是删除指定列或行的示例代码：

import pandas as pd

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

# 删除列
df = df.drop('A', axis=1)  # 删除名为 'A' 的列

# 删除行
df = df.drop(0, axis=0)  # 删除索引为 0 的行

在上述示例代码中，先创建了一个包含3行3列的 DataFrame 对象。然后使用 drop() 方法删除了名为 ‘A’ 的列和索引为 0 的行。

注意，drop() 方法会返回一个新的 DataFrame，而原始的 DataFrame 不会被修改。如果要在原始的 DataFrame 上进行修改，则可以将 inplace 参数设置为 True。例如：

# 删除列并在原始 DataFrame 上进行修改
df.drop('A', axis=1, inplace=True)

5.7删除指定的某多列/某多行

要删除多列或多行，可以将列名或行索引放入列表中，然后传递给 drop() 方法的 labels 参数。还需要将 axis 参数设置为 1（删除列）或 0（删除行）。

以下是删除指定多列或多行的示例代码：

import pandas as pd

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

# 删除多列
df = df.drop(['A', 'B'], axis=1)  # 删除名为 'A' 和 'B' 的列

# 删除多行
df = df.drop([0, 1], axis=0)  # 删除索引为 0 和 1 的行

使用 drop() 方法删除了名为 ‘A’ 和 ‘B’ 的列，以及索引为 0 和 1 的行。

**再次强调**，drop() 方法会返回一个新的 DataFrame，而原始的 DataFrame 不会被修改。如果要在原始的 DataFrame 上进行修改，则可以将 inplace 参数设置为 True。例如：

# 删除多列并在原始 DataFrame 上进行修改
df.drop(['A', 'B'], axis=1, inplace=True)

以上示例代码将在原始的 DataFrame 上删除名为 ‘A’ 和 ‘B’ 的列。

5.8 dataframe某列或多列或所有列重命名

在 Pandas 中，可以使用 rename() 方法对 DataFrame 的某列或多列或所有列进行重命名。rename() 方法会返回一个新的 DataFrame，原始的 DataFrame 不会被修改。

以下是对某列或多列或所有列进行重命名的示例代码：

  • (1)对某一列进行重命名：
import pandas as pd

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

# 对名为 'A' 的列进行重命名
df = df.rename(columns={'A': 'new_A'})

在上述示例代码中，先创建了一个包含3行3列的 DataFrame 对象。然后使用 rename() 方法将名为 ‘A’ 的列重命名为 ‘new_A’。

  • (2)对多列进行重命名：
# 对名为 'A' 和 'B' 的列进行重命名
df = df.rename(columns={'A': 'new_A', 'B': 'new_B'})

在上述示例代码中，使用 rename() 方法将名为 ‘A’ 的列重命名为 ‘new_A’，将名为 ‘B’ 的列重命名为 ‘new_B’。

  • (3)对所有列进行重命名：
# 对所有列进行重命名
df.columns = ['new_A', 'new_B', 'new_C']

在上述示例代码中，使用 columns 属性将所有列名修改为 ‘new_A’、‘new_B’ 和 ‘new_C’。

注意，rename() 方法会返回一个新的 DataFrame，而原始的 DataFrame 不会被修改。如果要在原始的 DataFrame 上进行修改，则可以将 inplace 参数设置为 True inplace=True。例如：

# 对所有列进行重命名并在原始 DataFrame 上进行修改
df.rename(columns={'A': 'new_A', 'B': 'new_B', 'C': 'new_C'}, inplace=True)

以上示例代码将在原始的 DataFrame 上将所有列名修改为 ‘new_A’、‘new_B’ 和 ‘new_C’。

5.9 dataframe索引列相关操作

在 Pandas 中，索引列（Index）是一种非常重要的数据结构，可以用来对数据进行标识、分组、合并等操作。以下是一些常用的索引列相关操作：

  • （1）设置索引列：使用 set_index() 函数可以设置某一列为索引列，例如：
import pandas as pd

# 创建一个 DataFrame
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
print(df)

# 设置索引列
df = df.set_index('A')
print(df)

输出：

   A  B  C
0  1  4  7
1  2  5  8
2  3  6  9

   B  C
A      
1  4  7
2  5  8
3  6  9
  • （2）重置索引列：使用 reset_index() 函数可以将索引列恢复为普通列，例如：
# 重置索引列
df = df.reset_index()
print(df)

输出：

   A  B  C
0  1  4  7
1  2  5  8
2  3  6  9
  • （3）获取索引列：使用 df.index 属性可以获取 DataFrame 的索引列，例如：
# 获取索引列
index_col = df.index
print(index_col)

输出：

Int64Index([1, 2, 3], dtype='int64', name='A')
  • （4）重命名索引列：使用 rename_axis() 函数可以重命名索引列的名称，例如：
# 重命名索引列
df = df.rename_axis('ID')
print(df)

输出：

    B  C
ID      
1   4  7
2   5  8
3   6  9
  • （5）多级索引：：可以使用多个列作为索引列，形成多级索引，例如：
# 创建一个 DataFrame
df = pd.DataFrame({'A': ['a', 'a', 'b', 'b'], 'B': ['c', 'd', 'c', 'd'], 'C': [1, 2, 3, 4]})
print(df)

# 设置多级索引
df = df.set_index(['A', 'B'])
print(df)

输出：

   A  B  C
0  a  c  1
1  a  d  2
2  b  c  3
3  b  d  4

       C
A B    
a c   1
  d   2
b c   3
  d

5.10 dataframe排序相关操作

在 Pandas 中，可以使用 sort_values() 函数对 DataFrame 进行排序，以下是一些常用的排序操作：

  • （1）索引排序：可以使用 sort_index() 函数对 DataFrame 进行索引排序，例如：
# 创建一个 DataFrame
df = pd.DataFrame({'A': [3, 2, 1], 'B': [6, 5, 4], 'C': [9, 8, 7]})

# 索引排序
df = df.sort_index()
print(df)

输出：

   A  B  C
0  3  6  9
1  2  5  8
2  1  4  7
  • （2）按某列升序排序：使用 sort_values() 函数，并指定 ascending=True，可以进行升序排序，例如：
# 升序排序
df = df.sort_values(by='A', ascending=True)
print(df)

输出：

   A  B  C
2  1  4  7
1  2  5  8
0  3  6  9
  • （3）按某列降序排序：使用 sort_values() 函数，并指定 ascending=False，可以进行降序排序，例如：
# 降序排序
df = df.sort_values(by='B', ascending=False)
print(df)

输出：

   A  B  C
0  3  6  9
1  2  5  8
2  1  4  7
  • （4）多列排序：使用 sort_values() 函数，并指定多个列名，可以对多个列进行排序，例如：
# 多列排序
df = df.sort_values(by=['A', 'B'], ascending=[True, False])
print(df)

输出：

   A  B  C
2  1  4  7
1  2  5  8
0  3  6  9
  • （5）按照指定值排序：可以使用 nlargest() 或 nsmallest() 函数，按照指定列中的最大或最小值进行排序，例如：
# 按照值排序
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
df = df.set_index('A')

# 按照 B 列中的最大值进行排序
df = df.nlargest(3, 'B')
print(df)

# 按照 C 列中的最小值进行排序
df = df.nsmallest(3, 'C')
print(df)

输出：

# 按照 B 列中的最大值进行排序
   B  C
A      
3  6  9
2  5  8
1  4  7

# 按照 C 列中的最小值进行排序
   B  C
A      
1  4  7
2  5  8
3  6  9

其中，nlargest()、nsmallest()函数的参数说明如下：
n：指定返回的行数；
columns：指定用于排序的列；
frac：指定返回的行数所占原 DataFrame 的比例；
replace：指定是否允许重复采样，默认为 False；

  • （6）随机排序：可以使用 sample() 函数对 DataFrame 进行随机排序，例如：
# 随机排序
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})

# 随机排序
df = df.sample(frac=1)
print(df)

输出：

   A  B  C
2  3  6  9
1  2  5  8
0  1  4  7

sample() 函数的参数random_state：指定随机种子，用于复现随机结果。

如果上述排序要在原dataframe上操作inplace：是否在原数据框排序，即是否覆盖原 DataFrame，默认为 False。
注意，排序同样是返回一个新的 DataFrame，而原始的 DataFrame 不会被修改。inplace：是否在原数据框排序，即是否覆盖原 DataFrame，默认为 False。如果要在原始的 DataFrame 上进行修改，则可以将 inplace 参数设置为 True inplace=True。

6.dataframe数据运算

pandas中DataFrame数据运算主要包括以下几类：

6.1算术运算

加、减、乘、除等运算符号用于数据框之间的运算。

import pandas as pd

df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df2 = pd.DataFrame({'A': [10, 20, 30], 'B': [40, 50, 60]})

#加法运算
df_add = df1 + df2
print(df_add)

#减法运算
df_sub = df1 - df2
print(df_sub)

#乘法运算
df_mul = df1 * df2
print(df_mul)

#除法运算
df_div = df1 / df2
print(df_div)

6.2统计运算

  • (1)pandas库来进行描述性统计分析

pandas 提供了多种方法来进行描述性统计分析，以下是一些常用的方法：

  • describe(): 生成一份包含统计信息的 DataFrame，包括计数、均值、标准差、最小值、下四分位数、中位数、上四分位数和最大值。
  • mean(): 计算每个数值列的平均值。
  • median(): 计算每个数值列的中位数。
  • mode(): 计算每个数值列的众数。
  • std(): 计算每个数值列的标准差。
  • min(): 计算每个数值列的最小值。
  • max(): 计算每个数值列的最大值。
  • quantile(): 计算每个数值列的分位数。
    这些方法都是基于 Pandas DataFrame 的列进行操作的，可以对整个 DataFrame 或部分 DataFrame 的列进行操作。

例如，以下代码将使用 describe() 方法对 DataFrame 的数值列进行描述性统计分析：

import pandas as pd

# 创建一个 DataFrame
data = {'A': [1, 2, 3, 4, 5],
        'B': [2, 4, 6, 8, 10],
        'C': [3, 6, 9, 12, 15]}
df = pd.DataFrame(data)

# 使用 describe() 方法进行描述性统计分析
print(df.describe())

输出：

              A          B          C
count  5.000000   5.000000   5.000000
mean   3.000000   6.000000   9.000000
std    1.581139   3.162278   4.743416
min    1.000000   2.000000   3.000000
25%    2.000000   4.000000   6.000000
50%    3.000000   6.000000   9.000000
75%    4.000000   8.000000  12.000000
max    5.000000  10.000000  15.000000

该结果展示了 DataFrame 中数值列的计数、均值、标准差、最小值、下四分位数、中位数、上四分位数和最大值。

  • (2)对数据框中的数据进行统计分析，例如求和、均值、方差、标准差等。示例代码如下：
import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

#求和
df_sum = df.sum()
print(df_sum)

#均值
df_mean = df.mean()
print(df_mean)

#方差
df_var = df.var()
print(df_var)

#标准差
df_std = df.std()
print(df_std)

6.3行列运算

  • (1)可以对数据框的所有行列进行运算。
import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})

#对列求和
df_sum_columns = df.sum(axis=0)
print(df_sum_columns)

#对行求和
df_sum_rows = df.sum(axis=1)
print(df_sum_rows)
  • (2)指定列之间的运算

DataFrame中可以对不同列进行加减乘除等运算，结果将保存为一个新的列。

import pandas as pd

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

#对A列和B列进行加法运算
df['C'] = df['A'] + df['B']

#对A列和B列进行乘法运算
df['D'] = df['A'] * df['B']

#打印结果
print(df)
  • (3)指定行之间的运算

可以使用apply()方法对DataFrame中的每一行进行运算，结果将保存为一个新的列。

import pandas as pd

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

#对每一行进行加法运算
df['C'] = df.apply(lambda row: row['A'] + row['B'], axis=1)

#对每一行进行乘法运算
df['D'] = df.apply(lambda row: row['A'] * row['B'], axis=1)

#打印结果
print(df)
  • (4)元素级运算

DataFrame中的元素级运算可以使用类似NumPy中的函数进行运算，例如numpy.sin()等。

import pandas as pd
import numpy as np

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

#对A列进行元素级sin函数运算
df['C'] = np.sin(df['A'])

#对B列进行元素级cos函数运算
df['D'] = np.cos(df['B'])

#打印结果
print(df)

6.4聚合运算

可以对数据框进行分组聚合计算。

  • (1)groupby运算

groupby可以将DataFrame中的数据按照指定的列进行分组，然后对分组后的数据进行聚合运算。

import pandas as pd

#创建DataFrame
data = {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], 'C': [1, 2, 3, 4, 5, 6, 7, 8], 'D': [9, 10, 11, 12, 13, 14, 15, 16]}
df = pd.DataFrame(data)

#对A列进行groupby运算，并对C列和D列进行聚合运算（求平均值）
grouped = df.groupby(['A']).agg({'C': 'mean', 'D': 'mean'})

#打印结果
print(grouped)
  • (2)merge运算

merge运算可以将两个DataFrame按照指定的列进行合并，类似于SQL中的JOIN操作。

import pandas as pd

#创建DataFrame
df1 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'], 'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'], 'value': [5, 6, 7, 8]})

#合并DataFrame
merged = pd.merge(df1, df2, on='key')

#打印结果
print(merged)

6.5merge运算扩展

在pandas中，可以使用merge()函数实现DataFrame的合并。下面给出几个示例：

  • (1)纵向合并两个DataFrame：pd.concat([df1, df2])
import pandas as pd

#创建两个DataFrame
df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                    'B': ['B4', 'B5', 'B6', 'B7'],
                    'C': ['C4', 'C5', 'C6', 'C7'],
                    'D': ['D4', 'D5', 'D6', 'D7']})

#纵向合并两个DataFrame
df = pd.concat([df1, df2])
  • (2)横向合并两个DataFrame:pd.merge(df1, df2, on=‘key’)
import pandas as pd

#创建两个DataFrame
df1 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})

df2 = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})

#横向合并两个DataFrame
df = pd.merge(df1, df2, on='key')
  • (3)使用多个键合并DataFrame:pd.merge(df1, df2, on=[‘key1’, ‘key2’])
import pandas as pd

#创建两个DataFrame
df1 = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                    'key2': ['K0', 'K1', 'K0', 'K1'],
                    'A': ['A0', 'A1', 'A2', 'A3'],
                    'B': ['B0', 'B1', 'B2', 'B3']})

df2 = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                    'key2': ['K0', 'K0', 'K0', 'K0'],
                    'C': ['C0', 'C1', 'C2', 'C3'],
                    'D': ['D0', 'D1', 'D2', 'D3']})

#使用多个键合并DataFrame
df = pd.merge(df1, df2, on=['key1', 'key2'])

pandas中的merge()函数还支持多种合并方式（如左连接、右连接、内连接、外连接等）。下面是每种连接方式的示例：

  • (4)左连接(left join):pd.merge(df1, df2, on=‘key’, how=‘left’)

左连接返回左侧数据集中所有的行，同时返回与右侧数据集中匹配的行。如果在右侧数据集中没有匹配的行，则返回空值。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7, 8]})

left_join = pd.merge(df1, df2, on='key', how='left')
print(left_join)
  • (5)右连接(right join): pd.merge(df1, df2, on=‘key’, how=‘right’)

右连接返回右侧数据集中所有的行，同时返回与左侧数据集中匹配的行。如果在左侧数据集中没有匹配的行，则返回空值。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7, 8]})

right_join = pd.merge(df1, df2, on='key', how='right')
print(right_join)
  • (6)内连接(inner join):pd.merge(df1, df2, on=‘key’, how=‘inner’)

内连接返回左侧和右侧数据集中都存在的行。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7, 8]})

inner_join = pd.merge(df1, df2, on='key', how='inner')
print(inner_join)
  • (7)外连接(outer join):pd.merge(df1, df2, on=‘key’, how=‘outer’)

外连接返回左侧和右侧数据集中所有的行，如果某一侧数据集中没有匹配的行，则返回空值。

import pandas as pd

df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
                   'value': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'],
                   'value': [5, 6, 7,8]})

outer_join = pd.merge(df1, df2, on='key', how='outer')
print(outer_join)

6.6其他运算

包括透视表运算、窗口函数运算等。

import pandas as pd

df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})

#透视表运算
df_pivot = pd.pivot_table(df, values=['B', 'C'], index='A', aggfunc='sum')
print(df_pivot)

#窗口函数运算
df_roll_mean = df.rolling(window=2).sum()
print(df_roll_mean)

7.dataframe 时间序列基本操作

DataFrame在时间序列分析中是非常重要的工具，可以轻松处理时间序列数据，如按时间排序、统计时间范围内的数据、时间偏移等等。以下是一些时间序列分析的示例：

7.1生成时间序列数据

import pandas as pd
import numpy as np

rng = pd.date_range('1/1/2020', periods=10, freq='D')
# rng = pd.date_range(start='2022-01-01', end='2022-12-31', freq='D')
df = pd.DataFrame({'date': rng, 'value': np.random.randn(10)})

这里生成了一个包含10天数据的DataFrame，其中date列为时间序列，value列为随机数列。

7.2按时间排序

#按照date列升序排列
df_ascend = df.sort_values('date')

#按照date列降序排列
df_descend = df.sort_values('date', ascending=False)

#打印排序结果
print("df_ascend:")
print(df_ascend)
print("df_descend:")
print(df_descend)

7.3统计时间范围内的数据

df.loc[(df['date'] >= '2020-01-03') & (df['date'] <= '2020-01-07')]

这里选取了2020年1月3日至7日之间的数据。

7.4时间偏移

df['shifted'] = df['value'].shift(1)

这里将value列向下平移了一个单位，生成了一个新的列shifted。

7.5时间重采样

df.set_index('date').resample('W').mean()

这里按照每周对数据进行重采样，并计算每周的平均值。

7.6移动窗口函数

df['rolling_mean'] = df['value'].rolling(window=3).mean()

这里计算了value列的移动平均值，窗口大小为3。

7.7时间差

df['diff'] = df['date'].diff()

#计算两个日期之间的天数
#df['diff'] = (df['date2'] - df['date1']).dt.days

这里计算了每一天和前一天之间的时间差。

7.8时间索引

df = df.set_index('date')

这里将date列设置为索引。

7.9时间戳转换

-(1)pd.to_datetime() 是 pandas 中的一个函数，用于将字符串或数值型的时间数据转换为 pandas 中的 datetime 类型。该函数的常用参数如下：

arg：表示需要转换的时间数据，可以是单个时间数据或时间数据列表或 Series 或 DataFrame。
format：表示需要转换的时间数据的格式，通常只有在时间数据的格式与默认格式不一致时才需要指定。
errors：表示错误处理方式，有两个可选值，分别是 raise 和 coerce，默认值为 raise。如果为 raise，则在转换出现错误时抛出异常；如果为 coerce，则将转换错误的数据设置为 NaT（pandas 中的缺失值）。
下面是几个示例：

import pandas as pd

# 示例1：将字符串型时间数据转换为 datetime 类型
str_time = '2023-03-10 12:00:00'
datetime_time = pd.to_datetime(str_time)
print(datetime_time)

# 示例2：将数值型时间数据转换为 datetime 类型
int_time = 20230310
datetime_time = pd.to_datetime(int_time, format='%Y%m%d')
print(datetime_time)

# 示例3：将时间数据列表转换为 datetime 类型
time_list = ['2023-03-03 12:00:00', '2023-03-10 13:00:00', '2023-03-17 14:00:00']
datetime_list = pd.to_datetime(time_list)
print(datetime_list)

# 示例4：将 DataFrame 中的某一列int列转换为 datetime 类型
df = pd.DataFrame({'Date': [20230303, 20230310', '20230317'], 
                   'value': [1, 2, 3]})
df['Date'] = pd.to_datetime(df['Date'], format='%Y%m%d')
print(df)

在上面的示例中，分别使用 pd.to_datetime() 函数将不同类型的时间数据转换为 datetime 类型，其中 format 参数用于指定时间数据的格式。

  • 第一个示例中的时间数据格式默认符合 datetime 标准格式，因此无需指定 format 参数。

  • 第二个示例中的时间数据为整型，需要指定时间格式。

  • 第三个示例中的时间数据为列表，直接调用 pd.to_datetime() 函数即可。

  • 最后一个示例中，将 DataFrame 中的某一列转换为 datetime 类型，并将结果更新到原 DataFrame 中。

  • (2)在 Python 中，可以使用 datetime 模块将时间数据从 int 或字符串类型转换为 datetime 类型。datetime 类型表示一个具体的日期和时间，可以方便地进行日期和时间的计算和比较。

下面是一个将 int 类型时间数据转换为 datetime 类型的示例：

import datetime

# 将 int 类型时间数据转换为 datetime 类型
int_time = 20220313  # 表示 2022 年 3 月 13 日
datetime_time = datetime.datetime.strptime(str(int_time), '%Y%m%d')
print(datetime_time)

在上面的代码中，首先定义了一个 int 类型的时间数据 int_time，表示 2022 年 3 月 13 日。然后使用 strptime() 函数将 int_time 转换为 datetime 类型的数据。其中 %Y%m%d 是 datetime 类型的时间格式，对应的是 int_time 的格式。转换后，将结果打印输出。

需要注意的是，strptime() 函数将字符串解析成 datetime 对象时，需要指定正确的时间格式。上面的示例中，%Y%m%d表示年月日的顺序，如果时间数据的格式与此不同，需要根据实际情况修改时间格式。

如果时间数据的类型是字符串，可以直接使用 datetime.datetime.strptime() 函数将其转换为 datetime 类型。例如：

# 将字符串类型时间数据转换为 datetime 类型
str_time = '2022-03-13 12:00:00'
datetime_time = datetime.datetime.strptime(str_time, '%Y-%m-%d %H:%M:%S')
print(datetime_time)

在上面的代码中，将一个字符串类型的时间数据 str_time 转换为 datetime 类型的数据，时间格式为 %Y-%m-%d %H:%M:%S，转换后将结果打印输出。

7.10按照时间周期进行统计

df.groupby(pd.Grouper(freq='M')).sum()

这里按照每个月进行数据统计。

7.11提取年、月、日等信息

  • 1.若date为索引且格式为datetime，则可直接进行年、月、日、周、季等信息的提取
df['year'] = df.index.year
df['month'] = df.index.month
df['day'] = df.index.day
df['weekday'] = df.index.weekday
df['quarter'] = df.index.quarter
  • 2.若date为dataframe的一列且格式不为datetime，则可按照如下方式进行年、月、日、周、季等信息的提取
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day
df['weekday'] = df['date'].dt.weekday
df['quarter'] = df['date'].dt.quarter

7.12按照日期数据进行分组

df.groupby('year').mean()

7.13时区转换

df = df.tz_localize('UTC').tz_convert('US/Pacific')

这里将时区从UTC转换为美国太平洋时区。

7.14绘制时间序列图

df.plot(x='date', y='value')

7.15时间运算

1.在pandas中，可以使用pd.Timedelta对象来进行时间加减运算。下面是一些示例：

假设有一个日期时间列df[‘datetime’]，可以使用pd.Timedelta对象将其加上一定的时间：

import pandas as pd

# 创建一个示例DataFrame
df = pd.DataFrame({'datetime': ['2023-03-14 12:00:00', '2023-03-14 13:00:00', '2023-03-14 14:00:00']})
df['datetime'] = pd.to_datetime(df['datetime'])  # 将字符串转换为日期时间格式

# 将日期时间列加上10分钟
df['datetime'] = df['datetime'] + pd.Timedelta(minutes=10)
print(df)

输出：

             datetime
0 2023-03-14 12:10:00
1 2023-03-14 13:10:00
2 2023-03-14 14:10:00

同样，也可以将日期时间列减去一定的时间：

# 将日期时间列减去5天
df['datetime'] = df['datetime'] - pd.Timedelta(days=5)
print(df)

输出：

             datetime
0 2023-03-09 12:10:00
1 2023-03-09 13:10:00
2 2023-03-09 14:10:00

除了分钟和天数，还可以使用其他的时间单位，例如秒、小时、周等等。具体的时间单位可以参考pd.Timedelta的文档。

2.在Python中，还可以使用datetime模块和timedelta类来进行日期和时间的相关运算。以下是一些示例：

  • (1)日期加减
from datetime import datetime, timedelta

# 当前时间
now = datetime.now()

# 昨天
yesterday = now - timedelta(days=1)

# 明天
tomorrow = now + timedelta(days=1)

# 一周后
next_week = now + timedelta(weeks=1)
  • (2)时间差计算
from datetime import datetime

# 两个时间之差
start_time = datetime(2022, 3, 14, 12, 0, 0)
end_time = datetime(2022, 3, 14, 14, 30, 0)
duration = end_time - start_time
print(duration.total_seconds())  # 输出时间差的总秒数

  • (1)日期加减

  • (1)日期加减

以上是一些时间序列分析的示例，pandas在时间序列分析中提供了丰富的功能，可以满足不同的需求。

8.dataframe数据可视化

8.1使用pandas自带的可视化工具

在Python中，pandas自带了一些可视化工具，可以方便地对DataFrame数据进行可视化。下面给出几个使用pandas自带可视化工具绘制图表的示例：

  • 1.绘制折线图
import pandas as pd

#创建数据集
data = {'year': [2010, 2011, 2012, 2013, 2014, 2015],
        'sales': [5, 7, 3, 4, 6, 8]}
df = pd.DataFrame(data)

#绘制折线图
df.plot(x='year', y='sales')
  • 2.绘制柱状图
import pandas as pd

#创建数据集
data = {'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'],
        'population': [2154, 2424, 1404, 1211]}
df = pd.DataFrame(data)

# 绘制柱状图
df.plot(kind='bar', x='city', y='population')
  • 3.绘制散点图
import pandas as pd

#创建数据集
data = {'height': [165, 170, 175, 180, 185],
        'weight': [55, 60, 65, 70, 75]}
df = pd.DataFrame(data)

#绘制散点图
df.plot(kind='scatter', x='height', y='weight')
  • 4.绘制箱线图
import pandas as pd

#创建数据集
data = {'gender': ['Male', 'Male', 'Female', 'Female'],
        'height': [180, 175, 165, 170]}
df = pd.DataFrame(data)

#绘制箱线图
df.boxplot(by='gender', column='height')

pandas自带的可视化工具可以方便地对DataFrame数据进行可视化，但其可视化效果可能不如其他专业的可视化库（如matplotlib和seaborn）。因此，在实际使用中，我们需要根据具体情况选择合适的可视化工具。

8.2使用matplotlib库

import pandas as pd
import matplotlib.pyplot as plt

#创建DataFrame数据
data = {'name': ['Tom', 'Jerry', 'Mike', 'Lucy'],
        'score': [80, 75, 90, 85],
        'age': [20, 21, 22, 20]}
df = pd.DataFrame(data)

#绘制柱状图
plt.bar(df['name'], df['score'])
plt.xlabel('Name')
plt.ylabel('Score')
plt.title('Student Scores')
plt.show()

#绘制散点图
plt.scatter(df['age'], df['score'])
plt.xlabel('Age')
plt.ylabel('Score')
plt.title('Student Scores')
plt.show()

#绘制折线图
plt.plot(df['name'], df['score'], marker='o')
plt.xlabel('Name')
plt.ylabel('Score')
plt.title('Student Scores')
plt.show()

8.3使用seaborn库

  • 1.使用seaborn库绘制柱状图
import pandas as pd
import seaborn as sns

#创建数据集
data = {'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'],
        'population': [2154, 2424, 1404, 1211]}
df = pd.DataFrame(data)

#绘制柱状图
sns.barplot(x='city', y='population', data=df)
plt.title('Population Data')
plt.show()
  • 2.使用seaborn库绘制散点图
import pandas as pd
import seaborn as sns

#创建数据集
data = {'height': [165, 170, 175, 180, 185],
        'weight': [55, 60, 65, 70, 75]}
df = pd.DataFrame(data)

#绘制散点图
sns.scatterplot(x='height', y='weight', data=df)
plt.title('Height and Weight Data')
plt.show()
  • 3.使用seaborn库绘制箱线图
import pandas as pd
import seaborn as sns

#创建数据集
data = {'gender': ['Male', 'Male', 'Female', 'Female'],
        'height': [180, 175, 165, 170]}
df = pd.DataFrame(data)

#绘制箱线图
sns.boxplot(x='gender', y='height', data=df)
plt.title('Height Data')
plt.show()

8.4 使用matplotlib库绘制拼接子图

在 Python 中，可以使用 Matplotlib 库来绘制拼接子图。Matplotlib 提供了 subplot() 函数，该函数可以将画布分割为多个子区域，并在每个子区域中绘制图形。

以下是一个简单的示例，演示如何使用 subplot() 函数绘制拼接子图：

import matplotlib.pyplot as plt
import numpy as np

# 生成数据
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)
y3 = np.tan(x)
y4 = np.arcsin(x)
# 绘制子图
plt.figure(figsize=(8, 6))

plt.subplot(2, 2, 1)
plt.plot(x, y1)
plt.title('sin(x)')

plt.subplot(2, 2, 2)
plt.plot(x, y2)
plt.title('cos(x)')

plt.subplot(2, 2, 3)
plt.plot(x, y3)
plt.title('tan(x)')

plt.subplot(2, 2, 4)
plt.plot(x, y4)
plt.title('arcsin(x)')

plt.tight_layout()
plt.show()

上述代码中，我们首先使用 NumPy 库生成了三个函数曲线的数据。然后，我们使用 subplot() 函数将画布分割为 2 行 2 列的四个子区域，并在每个子区域中绘制一个函数曲线。subplot() 函数的前两个参数分别指定子区域的行数和列数，第三个参数指定当前子区域的索引（从左上角开始计数）。在循环中，我们先使用 plot() 函数绘制曲线，然后使用 title() 函数设置子图的标题。最后，我们使用 tight_layout() 函数调整子图之间的间距，并使用 show() 函数显示图形。输出结果如下图所示：

在这里插入图片描述

以上示例只是其中一部分，数据可视化的方式和种类非常多，具体使用哪种方式取决于数据的特点和需要展示的内容。

shlay
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python中dict数据转DataFrame，pandas实现类似sql查询语句
qq_29220369的博客
04-04 1753
将一组dict字典数据转为pandas的DataFrame格式，然后用pandas实现类似sql语句中select * from xxx where condition的功能。转换方法有多种，看需求的DataFrame格式是什么样的。我采用的是将dict中key作为列，值作为行的方法。同时使用df.value_counts()或者len()可以统计查询结果的数量。第二步由pd.DataFrame()转格式。(3) 多个条件查询时，sql中语法为and和or。pandas中使用符号“&”和“|”实现。
Python通过字典创建DataFrame 的方法
Meggie35的博客
04-02 889
Python 多种用字典创建dataframe的方法
python中DataFrame对象
meimei169500的博客
12-06 932
DataFrame是Pandas库中的一种数据结构，它是由多种类型的列组成的二维表数据结构，类似于Excel、SQL或Series对象构成的字典。DataFrame是最常用的Pandas对象，它与Series对象一样支持多种类型的数据。
DataFrame的基本用法
Billie使劲学的博客
11-06 3896
定义一个空的DataFramedf = pd.DataFrame(data=None,columns=range(1,5),index=[0,1]) # 从列表定义,定义列名和行名dfdf = pd.DataFrame(columns={"a":"","b":""},index=[0,1,2]) #从字典定义df。
4.2 掌握DataFrame的常用操作
我走的每一步都算数
04-04 2173
【代码】4.2 掌握DataFrame的常用操作。
python数据分析报告.docx
06-12
python数据分析报告全文共3页，当前为第1页。python数据分析报告全文共3页，当前为第1页。python数据分析报告 ...将数据集加载到DataFrame中，进行各种数据处理操作，如数据过滤、去除重复项、数据转换等。 python
python数据分析与可视化.docx
最新发布
06-03
Pandas： Pandas是Python中用于数据分析的重要库，提供了快速、灵活、易于使用的数据结构，如Series（一维数组）和DataFrame（二维表），以及数据操作和处理工具。 NumPy： NumPy是Python中用于科学计算的核心库，...
Python操作Excel相关教程
04-10
Python是一种强大的编程语言，它提供了多个库来操作Excel文件，使得处理电子表格数据变得简单高效。以下是一些常用的Python库及其功能的简介： openpyxl: 专门用于读写.xlsx文件，可以访问Excel文件的每一个属性，...
python数据分析与可视化常用函数介绍与使用.docx
06-01
python数据分析与可视化 Python在数据分析与可视化领域非常...Pandas提供了高性能、易用的数据结构和数据分析工具，主要数据结构是DataFrame和Series。 - **读写数据**: - `pd.read_csv()`：读取CSV文件。 - `df.
python数据分析与可视化.doc
05-22
以下是一些常用的Python库和工具，以及如何使用它们进行数据分析和可视化的基本步骤： ### 数据分析 1. **Pandas**: Pandas是一个强大的数据处理和分析库。它提供了DataFrame对象，非常适合处理结构化数据。 - ...
Pandas 数据处理基础4---数据删减及其用法
qq_38530648的博客
12-16 388
数据删减 虽然我们可以通过数据选择方法从一个完整的数据集中拿到我们需要的数据，但有的时候直接删除不需要的数据更加简单直接。Pandas 中，以 .drop 开头的方法都与数据删减有关。 DataFrame.drop 可以直接去掉数据集中指定的列和行。一般在使用时，我们指定 labels 标签参数，然后再通过 axis 指定按列或按行删除即可。当然，你也可以通过索引参数删除数据，具体查看官方文档。 ...
dataframe常用操作
pp_lan的博客
06-13 580
1. 数组转dataframe import pandas as pd input = [{"trainModelName": "东南 V6菱仕", "BaseModelName": "东南 V6菱仕", "label": "0"}, {"trainModelName": "福特 经典全顺 ", "BaseModelName": "福特 经典全顺", ...
【数据处理包Pandas】DataFrame数据的基本操作
Morse_Chen的博客
03-31 1148
本文讲解数据处理包Pandas，围绕DataFrame数据的基本操作，包括增删改查。
python笔记（二）dataframe操作
weixin_43479815的博客
07-18 769
x2 = df.loc[(df['利润中心（项目编号）']==i)&(df['品类']==j), ['方向','时间']]df.loc[(df['利润中心（项目编号）']==i)&(df['品类']==j), 'ans'] = '小'df.loc[(df['利润中心（项目编号）']==i)&(df['品类']==j), 'ans'] = '大'# data2[(data2['利润中心（项目编号）']==i)]['ans']=a['ans']但是， apply() 只允许与函数一起使用。
数据预处理 1.4 DataFrame查询
pmr0528的博客
11-29 1698
seies也可以使用sort_values和sort_index函数进行排序，只不过series的sort_values方法没有by参数。df.sort_values(by=['列标签'],ascending=True)loc和query如果跟多个条件可以用&、|表示条件之间的关系。指定列分组，并对分组数据的相应列进行行相应的聚合操作。按照columns指定的列进行降序，并取前n行数据。ascending参数默认是True表示升序。获取DataFrame中满足条件的数据。
python数据分析(二)——DataFrame
Vapus的博客
08-08 1422
python数据分析(二)——DataFrame
Pandas DataFrame
Claroja
05-24 1万+
http://pandas.pydata.org/pandas-docs/stable/api.html#dataframe 构造函数 方法 描述 DataFrame([data, index, columns, dtype, copy]) 构造数据框 属性和数据 方法 描述 Axes index: row labels
spark dataframe操作集锦（提取前几行，合并，入库等）
热门推荐
大数据挖掘SparkExpert的博客
04-02 9万+
spark dataframe派生于RDD类，但是提供了非常强大的数据操作功能。当然主要对类SQL的支持。 在实际工作中会遇到这样的情况，主要是会进行两个数据集的筛选、合并，重新入库。 首先加载数据集，然后在提取数据集的前几行过程中，才找到limit的函数。 而合并就用到union函数，重新入库，就是registerTemple注册成表，再进行写入到HIVE中。
用python写代码展示DataFrame的常用操作
06-01
好的，以下是Python代码展示DataFrame的常用操作： ```python import pandas as pd # 创建DataFrame df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}) # 显示DataFrame print(df) # 查看...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值