devbox
神奇cpp
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

pandas增删改查_pandas表加一行

作者：神奇cpp | 2024-08-20 23:39:54

赞

踩

pandas表加一行

文章目录

1.增加       

1.增加数据

new_row={'列名':数据}

df._append(new_row)

  1. import pandas as pd
  2. # 创建一个空的数据库
  3. df=pd.DataFrame()
  4. # 增加一行数据
  5. new_row = {'A':1,'B':2,'C':3}
  6. df = df._append(new_row, ignore_index=True)
  7. print(df)

         结果:

                            A  B  C
                        0  1  2  3

2.新增一列数据

        df['新增列名'] =[数据]
  1. mport pandas as pd
  2. # 创建一个空的数据库
  3. df=pd.DataFrame()
  4. # 增加一行数据
  5. new_row = {'A':1,'B':2,'C':3}
  6. df = df._append(new_row, ignore_index=True)
  7. #print(df)
  8. df['D'] =[4]
  9. print(df)
  10. # 结果
  11. #    A  B  C  D
  12. # 0  1  2  3  4

3.根据条件来增加数据

                query('条件')

  1. import pandas as pd
  2. # 创建一个空的数据库
  3. df=pd.DataFrame()
  4. # 增加一行数据
  5. new_row = {'A':1,'B':2,'C':3}
  6. df = df._append(new_row, ignore_index=True)
  7. print(df)
  8. #   A  B  C
  9. # 0  1  2  3
  10. df = df.query('B >4')
  11. print(df)
  12. # Empty DataFrame
  13. # Columns: [A, B, C]
  14. # Index: []
  15. df['D'] =[4]
  16. print(df)
  17. #    A   B   C  D
  18. # 0 NaN NaN NaN  4

4.根据索引来增加数据

        1.加了fd.loc['行名']，就是添加行名的数据
        new_row = {'列名'：数据}
        fd.loc['行名'] = new_row
        2.fd.loc[n],n是对第几行进行操作，
        fd.loc[n] = new_row
        3.fd['列名']没有加loc,就是添加列名的数据
        d['列名']=[数据]

  1. # import pandas as pd
  2. # # 创建一个空的数据库
  3. # df=pd.DataFrame()
  4. # # 增加一行数据
  5. # new_row = {'A':1,'B':2,'C':3}
  6. # df = df._append(new_row, ignore_index=True)
  7. # print(df)
  8. # #   A  B  C
  9. # # 0  1  2  3
  10. # df = df.query('B >4')
  11. # print(df)
  12. # # Empty DataFrame
  13. # # Columns: [A, B, C]
  14. # # Index: []
  15. # df['D'] =[4]
  16. # print(df)
  17. # #    A   B   C  D
  18. # # 0 NaN NaN NaN  4
  19. import pandas as pd
  20.  
  21. # 创建一个数据框
  22. df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
  23. print(df)
  24. #    A  B
  25. # 0  1  4
  26. # 1  2  5
  27. # 2  3  6
  28. # 在索引为0的位置添加一行
  29. # new_row = {'A': 10, 'B': 20}
  30. # df.loc[0] = new_row
  31. # print(df)
  32. # #    A   B
  33. # # 0  10  20
  34. # # 1   2   5
  35. # # 2   3   6
  36. # 前面注释，不然一二行都变成10,20
  37. # 说明里面是的几个【n】,就注释第n行
  38. # 在索引为1的位置添加一行
  39. new_row = {'A': 10, 'B': 20}
  40. df.loc[1] = new_row
  41. print(df)
  42. #     A   B
  43. # 0   1   4
  44. # 1  10  20
  45. # 2   3   6
  46.  
  47. # 在索引为'new_index'的位置添加一行
  48. # 加了loc['行名']，就是添加行名的数据
  49. # 没有加就是添加列名的数据
  50. new_row = {'A': 100, 'B': 200}
  51. df.loc['new_index'] = new_row
  52. print(df)
  53. #              A    B
  54. # 0            1    4
  55. # 1           10   20
  56. # 2            3    6
  57. # new_index  100  200
  58.  
  59. # 在'C'列末尾添加一列
  60. new_col = [1, 2, 3, 4]  # 数据的长度应与索引的长度相匹配
  61. df['C'] = new_col
  62. print(df)
  63. #              A    B  C
  64. # 0            1    4  1
  65. # 1           10   20  2
  66. # 2            3    6  3
  67. # new_index  100  200  4

 2.删除

1.删除数据整个数据框

        # 使用del关键字删除整个数据框

        del df

        # 使用drop()方法删除整个数据框

        df.drop(df.index, inplace=True)

2.删除指定的数据

movie.drop(movie[movie['指定的列'] == '指定值'].index,axis=1)

        # 删除指定的行（索引为0和1）

        df.drop([0, 1], inplace=True)

         # 删除指定的列（'A'和'B'列）

         df.drop(['A', 'B'], axis=1, inplace=True)

 3.删除有条件的数据

    # 使用query方法删除满足特定条件的行
    df = df.query('B != "apple"')  # 删除'B'列值为'apple'的行

  1. import pandas as pd
  2. # 创建一个示例数据框
  3. df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
  4.                    'B': ['apple', 'banana', 'cherry', 'apple', 'orange'],
  5.                    'C': [True, False, True, True, False]})
  6. # 使用query方法删除满足特定条件的行
  7. df = df.query('B != "apple"')  # 删除'B'列值为'apple'的行
  8. print(df)
  9. #    A       B      C
  10. # 1  2  banana  False
  11. # 2  3  cherry   True
  12. # 4  5  orange  False

        # 使用 query 方法筛选满足条件的行，并通过 loc 方法选择特定的列

        result = df.query('条件').loc[ : ,  ['列名'] ]

  1. # 假设有一个数据框 df，包含列 A、B 和 C
  2. df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
  3.                    'B': [10, 20, 30, 40, 50],
  4.                    'C': [100, 200, 300, 400, 500]})
  5.  
  6. # 使用 query 方法筛选满足条件的行，并通过 loc 方法选择特定的列
  7. result = df.query('A > 2').loc[:, ['B', 'C']]
  8. print(result)
  9. #     B    C
  10. # 2  30  300
  11. # 3  40  400
  12. # 4  50  500

3.修改

1.修改指定的数据

df.loc[行数，‘列名’] = 数据

  1. # 假设有一个数据框 df，包含列 A、B 和 C
  2. df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
  3.                    'B': [10, 20, 30, 40, 50],
  4.                    'C': [100, 200, 300, 400, 500]})
  5.  
  6. # 修改指定位置的数据
  7. df.loc[2, 'B'] = 35
  8. print(df)
  9. #   A   B    C
  10. # 0  1  10  100
  11. # 1  2  20  200
  12. # 2  3  35  300
  13. # 3  4  40  400
  14. # 4  5  50  500

2.修改有条件的数据

df.loc[df['列名']>（行的条件），‘修改的列’] = 列的数据

  1. # 假设有一个数据框 df，包含列 A、B 和 C
  2. df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
  3.                    'B': [10, 20, 30, 40, 50],
  4.                    'C': [100, 200, 300, 400, 500]})
  5.  
  6. # 根据条件修改数据
  7. df.loc[df['A'] > 2, 'C'] = 999
  8. print(df)
  9. #   A   B    C
  10. # 0  1  10  100
  11. # 1  2  20  200
  12. # 2  3  30  999
  13. # 3  4  40  999
  14. # 4  5  50  999

4.查询

1.指定查询

quer(‘条件’)[ [查询的字段] ]

  1. # 假设有一个数据框 df，包含列 A、B 和 C
  2. df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
  3.                    'B': [10, 20, 30, 40, 50],
  4.                    'C': [100, 200, 300, 400, 500]})
  5.  
  6. # 查询指定列
  7. df_query = df.query('A > 2')[['A', 'C']]
  8. print(df_query)
  9. #    A    C
  10. # 2  3  300
  11. # 3  4  400
  12. # 4  5  500

2.条件查询           

  1. # 假设有一个数据框 df，包含列 A、B 和 C
  2. df = pd.DataFrame({'A': [1, 2, 3, 4, 5],
  3.                    'B': [10, 20, 30, 40, 50],
  4.                    'C': [100, 200, 300, 400, 500]})
  5.  
  6. # 条件查询
  7. df_filtered = df[(df['A'] > 2) & (df['C'] < 400)]
  8. print(df_filtered)
  9. #  A   B    C
  10. # 2  3  30  300

 3.分组和聚合查询

df.groupby('列名').聚会函数

  1. df = pd.DataFrame({'A': [1, 1, 2, 2, 3],
  2.                    'B': [10, 20, 30, 40, 50],
  3.                    'C': [100, 200, 300, 400, 500]})
  4.  
  5. # 按列 A 进行分组，并计算每个分组的均值
  6. grouped = df.groupby('A').mean()
  7.  
  8. # 输出结果
  9. print(grouped)
  10. #       B      C
  11. # A             
  12. # 1  15.0  150.0
  13. # 2  35.0  350.0
  14. # 3  50.0  500.0

4.合表查询

                1.按方向合并
                        pd.concat((a,b), axis=)

  1. # 假设有两个数据框 a 和 b
  2. a = pd.DataFrame({'A': [1, 2, 3],
  3.                   'B': [4, 5, 6]})
  4.  
  5. b = pd.DataFrame({'C': [7, 8, 9],
  6.                   'D': [10, 11, 12]})
  7.  
  8. # 按行方向合并（纵向合并）
  9. concatenated = pd.concat((a, b), axis=0)
  10.  
  11. # 输出结果
  12. print(concatenated)
  13. #      A    B    C     D
  14. # 0  1.0  4.0  NaN   NaN
  15. # 1  2.0  5.0  NaN   NaN
  16. # 2  3.0  6.0  NaN   NaN
  17. # 0  NaN  NaN  7.0  10.0
  18. # 1  NaN  NaN  8.0  11.0
  19. # 2  NaN  NaN  9.0  12.0

                2.按索引合并
                        pd.merge(left,right,how='inner', on=[索引])
 

  1. # 假设有两个数据框 df1 和 df2，包含列 key、A 和 B
  2. df1 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'],
  3.                     'A': [1, 2, 3, 4],
  4.                     'B': [5, 6, 7, 8]})
  5.  
  6. df2 = pd.DataFrame({'key': ['foo', 'bar', 'baz', 'qux'],
  7.                     'C': [9, 10, 11, 12],
  8.                     'D': [13, 14, 15, 16]})
  9.  
  10. # 合并两个数据框，根据 key 列进行合并
  11. merged = pd.merge(df1, df2, on='key')
  12.  
  13. # 输出结果
  14. print(merged)
  15. #    key  A  B   C   D
  16. # 0  foo  1  5   9  13
  17. # 1  bar  2  6  10  14
  18. # 2  baz  3  7  11  15
  19. # 3  qux  4  8  12  16

5.交叉表查询

pd.crosstab() 函数用于创建交叉表（cross-tabulation），也称为列联表。它可以统计两个或多个变量之间的频数或频率，并以表格形式展示。

函数的语法如下：

pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None)
其中：

index 是要在行方向上进行分组的变量；
columns 是要在列方向上进行分组的变量；
values 是可选的，用于指定要聚合的数据列；
rownames 和 colnames 是可选的，用于指定行和列的名称；
aggfunc 是可选的，用于定义对聚合值进行计算的函数，默认为计数。

  1. # 假设有一个数据框 df，包含列 A、B、C 和 D
  2. df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
  3.                    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
  4.                    'C': np.random.randn(8),
  5.                    'D': np.random.randn(8)})
  6.  
  7. # 创建透视表，按 A 和 B 列分组，并计算 C 和 D 列的均值
  8. pivot_table = df.pivot_table(values=['C', 'D'], index='A', columns='B', aggfunc=np.mean)
  9.  
  10. # 输出结果
  11. print(pivot_table)
  12. #             C                             D                    
  13. # B         one     three       two       one     three       two
  14. # A                                                              
  15. # bar  1.821440 -0.407843  0.114514  0.337398 -1.026214 -0.418785
  16. # foo  0.677367  0.889548 -0.128189 -0.747733 -1.760644 -0.286292

6.透视表查询

df.pivot_table(values, index, columns, aggfunc='mean', fill_value=None)
其中：

values 是要进行聚合的字段或字段列表；
index 是用作新表格的索引的字段；
columns 是用作新表格列的字段；
aggfunc 是指定聚合函数的参数，默认为 'mean'；
fill_value 是可选的，用于指定替换缺失值的值。
 

  1. # 假设有一个数据框 df，包含列 A、B 和 C
  2. df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
  3.                    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
  4.                    'C': np.random.randn(8)})
  5.  
  6. # 创建交叉表，按 A 和 B 列进行分组，并计算 C 列的频次
  7. cross_table = pd.crosstab(index=df['A'], columns=df['B'], values=df['C'], aggfunc='count')
  8.  
  9. # 输出结果
  10. print(cross_table)
  11. # B    one  three  two
  12. # A                   
  13. # bar    1      1    1
  14. # foo    2      1    2

1.交叉表和透视表的差别

交叉表（crosstab）和透视表（pivot table）是在 Pandas 中用于数据分析和汇总的两种常见操作。它们之间有一些差别，主要体现在以下几个方面：

  1. 数据结构：交叉表是一个用于计算频率或统计指标的特殊数据表格，其中行和列分别表示不同的分类变量，并显示它们之间的交叉计数。透视表是根据一个或多个列中的值对数据进行聚合，并将它们重塑为新的数据表格，其中行和列表示不同的指标变量。

  2. 聚合方式：交叉表主要用于计算分类变量之间的频率或交叉计数。它默认使用计数作为聚合函数，但也可以使用其他聚合函数，如求和、均值等。透视表则是根据需要选择不同的聚合函数，可以使用各种聚合函数进行数据聚合，如求和、均值、最大值、最小值等。

  3. 灵活性：透视表在对数据进行聚合时更加灵活，可以根据需求自定义聚合函数、添加过滤条件、设置多级索引等。而交叉表相对简单，主要用于计算频率或统计指标，对数据的灵活处理能力较弱。

下面是交叉表和透视表的示例代码：

交叉表示例:

pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None)

  1. # 创建示例数据
  2. data = {'Gender': ['Male', 'Female', 'Male', 'Female', 'Male'],
  3.         'Age': [20, 25, 30, 35, 40],
  4.         'Smoker': ['Yes', 'No', 'No', 'No', 'Yes']}
  5.  
  6. df = pd.DataFrame(data)
  7.  
  8. # 计算交叉表
  9. cross_tab = pd.crosstab(df['Gender'], df['Smoker'])
  10.  
  11. # 输出结果
  12. print('-'*28)
  13. print(cross_tab)
  14. # Smoker  No  Yes
  15. # Gender         
  16. # Female   2    0
  17. # Male     1    2
  18.

透视表示例：

df.pivot_table(values, index, columns, aggfunc='mean', fill_value=None)

  1. # 创建示例数据
  2. data = {'Gender': ['Male', 'Female', 'Male', 'Female', 'Male'],
  3.         'Age': [20, 25, 30, 35, 40],
  4.         'Smoker': ['Yes', 'No', 'No', 'No', 'Yes']}
  5.  
  6. df = pd.DataFrame(data)
  7.  
  8. # 计算透视表
  9. pivot_table = df.pivot_table(index='Gender', columns='Smoker', values='Age', aggfunc='mean')
  10.  
  11. # 输出结果
  12. print('_'*34)
  13. print(pivot_table)
  14. # Smoker    No   Yes
  15. # Gender            
  16. # Female  30.0   NaN
  17. # Male    30.0  30.0

在上面的示例中，交叉表计算了性别和吸烟情况之间的频率统计，而透视表根据性别和吸烟情况对年龄进行了平均值的汇总。

希望这个解释有助于理解交叉表和透视表的差异。如果还有其他问题，请随时提问！

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号