Python---数据分析(Pandas九:二维数组DataFrame数据操纵二： 数据排序，数 ...

一、数据排序

1.1、 sort_values()

        用于根据一个或多个列的值对 DataFrame 举行排序。

1. DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)

复制代码

描述说明by用于排序的列名或列名列表。axis{0 or ‘index’, 1 or ‘columns’}，默认为 0。沿着哪个轴举行排序。ascending排序的方向，True表现升序，False表现降序， 默认为True。inplace是否在原地修改 DataFrame。kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}，默认为 ‘quicksort’。排序 算法。na_position{‘first’, ‘last’}，默认为 ‘last’。缺失值的放置位置。ignore_index布尔值，默认为 False。是否忽略原来的索引，重新生成一个 新的默认整数索引。key函数，默认为None。应用于 by 中每个列的函数，排序将基于函数的返回 值。

1. import numpy as np
2. import pandas as pd
4. # 创建一个示例 DataFrame
5. df = pd.DataFrame({
6.     'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],
7.     'col2': [2, 1, 9, 8, 7, 4],
8.     'col3': [3, 1, 9, 4, 2, 3],
9.     'col4': ['a', 'B', 'c', 'D', 'e', 'F']
10. })
12. # 打印原始DataFrame
13. print(df)
15. # 根据 'col1' 列对DataFrame进行排序
16. res1 = df.sort_values(by=['col1'])
17. # 打印排序后的DataFrame
18. print(res1)
20. # 根据 'col1' 和 'col2' 列对DataFrame进行排序
21. res2 = df.sort_values(by=['col1', 'col3'])
22. # 打印排序后的DataFrame
23. print(res2)

复制代码

 

1.2、sort_index()

        用于根据索引对 DataFrame 举行排序。

1. DataFrame.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None)

复制代码

描述说明axis{0 or ‘index’, 1 or ‘columns’}，默认为 0。表现沿着哪个轴举行排序。0按 照行标签排序，1按照列标签排序。level如果索引是多级索引，指定要排序的级别。可以是整数或整数列表。ascending默认为 True。表现排序是升序照旧降序。inplace是否在原地修改 DataFrame。kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}，默认为 ‘quicksort’。排序 算法。na_position{‘first’, ‘last’}，默认为 ‘last’。缺失值的放置位置。sort_remaining是否对剩余的级别举行排序。仅在多级索引时有效。默认值为True。ignore_index是否忽略原来的索引，重新生成一个新的默认整数索引。默认值 为 False。key函数，默认为 None。应用于索引的函数，排序将基于函数的返回值。

1. import pandas as pd
2. import numpy as np
4. # 创建一个多级索引的DataFrame
5. arrays = [np.array(['qux', 'qux', 'foo', 'foo']),
6.           np.array(['two', 'one', 'two', 'one'])]
7. df = pd.DataFrame({'C': [1, 2, 3, 4], 'B': [4, 3, 2, 1]}, index=arrays)
9. print(df)
11. # # 按第一层索引升序排序
12. df_sorted_by_first_level = df.sort_index(level=0)
13. print(df_sorted_by_first_level)
15. # # 按第二层索引降序排序
16. df_sorted_by_second_level_desc = df.sort_index(level=1, ascending=False)
17. print(df_sorted_by_second_level_desc)
19. # 按整个索引升序排序
20. df_sorted_by_full_index = df.sort_index()
21. print(df_sorted_by_full_index)

复制代码

 

二、 数据筛选

        可以利用布尔数组举行索引，选择满足条件的数据。

1. import pandas as pd
3. data = {
4.     '姓名': ['小明', '小红', '小刚'],
5.     '年龄': [20, 18, 22],
6.     '成绩': [85, 90, 88]
7. }
9. df = pd.DataFrame(data)
11. print(df)
13. print(df['成绩'] >= 90)
15. # 使用布尔索引选择成绩大于或等于90的学生
16. high_scores = df[df['成绩'] >= 90]
18. print(high_scores)

复制代码

三、数据拼接

3.1、 concat()

        用于沿一个轴将多个 pandas 对象连接在一起。

1. pandas.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)

复制代码

描述说明objs要连接的对象列表。axis{0, 1, ‘index’, ‘columns’}，默认为 0。join 连接方式。可以是：
'outer'：取全部索引的并集。
'inner'：取全部索引的交集。
ignore_index是否忽略原来的索引，重新生成一个新的默认整数索引。默认值 为 False。keys用于生成多级索引的键列表。每个键对应一个对象。levels用于多级索引的级别列表。通常与 华清远见|元宇宙实验中央 yyzlab.com.cn keys 一起利用。names用于多级索引的名称列表。通常与 keys 一起利用。verify_integrity是否验证最终的 DataFrame 是否有重复的索引。默认值为Falsesort是否对效果按照列名举行升序排序。默认值为 False。copy是否复制数据。

1. import pandas as pd
3. # 创建两个 DataFrame
4. df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
5.                     'B': ['B0', 'B1', 'B2', 'B3'],
6.                     'C': ['C0', 'C1', 'C2', 'C3'],
7.                     'D': ['D0', 'D1', 'D2', 'D3']},
8.                    index=[0, 1, 2, 3])
10. df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
11.                     'B': ['B4', 'B5', 'B6', 'B7'],
12.                     'C': ['C4', 'C5', 'C6', 'C7'],
13.                     'F': ['F4', 'F5', 'F6', 'F7']},
14.                    index=[4, 5, 6, 7])
16. print(df1)
17. print(df2)
19. # 沿着竖直方向拼接两个DataFrame
20. result = pd.concat([df1, df2], axis=1, join='outer')
22. print(result)

复制代码

3.2、 merge()

        用于根据一个或多个键将两个 DataFrame 对象连接起来。

1. DataFrame.merge(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=None, indicator=False, validate=None)

复制代码

描述说明right另一个 DataFrame 对象。how {‘left’, ‘right’, ‘outer’, ‘inner’, ‘cross’}, 默认为 ‘inner’。确定连接的类型：
‘left’: 利用左侧（调用 merge的 DataFrame）的索引举行左连接。
‘right’: 利用右侧（参数 right 中的 DataFrame）的索引举行右连接。
‘outer’: 利用两个DataFrame的并集连接。
‘inner’: 利用两个DataFrame的交集连接。
on用于归并的列名。如果 left_on 和 right_on 都没有指定，则利用onleft_on左侧 DataFrame 中用于归并的列名。不与on同时利用。right_on右侧 DataFrame 中用于归并的列名。不与on同时利用。left_index是否利用左侧  DataFrame 的索引作为归并键。默认值为 False。不与on同时利用。right_index是否利用右侧 DataFrame 的索引作为归并键。默认值为 False。不与on同时利用。sort是否对效果举行排序。默认值为 False。suffixes用于重定名重复列的后缀。默认值为 ('_x', '_y')。copy是否复制数据。默认值为 None，表现根据必要自动决定是否复制。indicator是否添加一个指示器列，表现每行来自哪个DataFrame。默认值为 False。validate 检查归并键。可以是：
'one_to_one'：检查归并键在两者中是否唯一。
'one_to_many'：检查归并键在左侧是否唯一。
'many_to_one'：检查归并键在右侧是否唯一。 'many_to_many'：不检查。

1. import pandas as pd
3. # 创建两个 DataFrame
4. df1 = pd.DataFrame({'key1': ['A', 'B', 'C', 'D'],
5.                     'value': [1, 2, 3, 4]}, index=['a', 'b', 'c', 'd'])
6. df2 = pd.DataFrame({'key2': ['B', 'D', 'D', 'E'],
7.                     'value': [5, 6, 7, 8]}, index=['a', 'c', 'e', 'f'])
9. print(df1)
10. print(df2)
12. # 使用内连接（inner join）合并两个 DataFrame
13. result = df1.merge(df2, left_on='key1', right_on='key2', how='right', suffixes=('_left', '_right'), indicator=True,)
15. print(result)

复制代码

3.3、 join()

        用于将两个对象的列连接起来。

1. DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False, validate=None)

复制代码

描述说明other另一个 DataFrame 对象。on用于连接的列名。how {‘left’, ‘right’, ‘outer’, ‘inner’}, 默认为 ‘left’。确定连接的类型：
‘left’: 利用左侧（调用 join 的 DataFrame）的索引举行左连接。
‘right’: 利用右侧（参数 other 中的 DataFrame）的索引举行右连接。
‘outer’: 利用两个 DataFrame 的索引的并集举行全外连接。
‘inner’: 利用两个 DataFrame 的索引的交集举行内连接。
lsuffix用于重定名重复列的左后缀。默认值为空字符串 ''。rsuffix用于重定名重复列的右后缀。默认值为空字符串 ''。sort是否对效果举行排序。默认值为 False。validate 检查归并键。可以是：
'one_to_one'：检查归并键在两者中是否唯一。
'one_to_many'：检查归并键在左侧是否唯一。
'many_to_one'：检查归并键在右侧是否唯一。
'many_to_many'：不检查。

1. import pandas as pd
3. # 创建两个 DataFrame
4. df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'],
5.                     'value': [1, 2, 3, 4]},
6.                    index=['k0', 'k1', 'k2', 'k3'])
7. df2 = pd.DataFrame({'value': [5, 6, 7, 8]},
8.                    index=['k1', 'k2', 'k3', 'k4'])
10. print(df1)
11. print(df2)
13. # 使用左连接（left join）根据索引合并两个 DataFrame
14. result = df1.join(df2, how='left', rsuffix='_right', lsuffix='_left')
16. print(result)

复制代码

 

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。