当前位置：首页 > article >正文

Pandas库学习Day21

article 2024/10/27 22:51:29

Pandas库

1. 函数

1.1 重置索引

可以更改原DataFrame的行标签或列标签，使更改后的行、列标签与DataFrame中的数据逐一匹配。若重置的索引标签在原DataFrame中不存在，那么该标签对应的元素值将全部填充为NaN。

1.1.1 reindex

语法

DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=np.nan, limit=None, tolerance=None)

参数：

labels：
- 类型：数组或列表，默认为 None。
- 描述：新的索引标签。
index：
- 类型：数组或列表，默认为 None。
- 描述：新的行索引标签。
columns：
- 类型：数组或列表，默认为 None。
- 描述：新的列索引标签。
axis：
- 类型：整数或字符串，默认为 None。
- 描述：指定重新索引的轴。0 或 ‘index’ 表示行，1 或 ‘columns’ 表示列。
method：
- 类型：字符串，默认为 None。
- 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
copy：
- 类型：布尔值，默认为 True。
- 描述：是否返回新的 DataFrame 或 Series。
level：
- 类型：整数或级别名称，默认为 None。
- 描述：用于多级索引（MultiIndex），指定要重新索引的级别。
fill_value：
- 类型：标量，默认为 np.nan。
- 描述：用于填充缺失值的值。
limit：
- 类型：整数，默认为 None。
- 描述：指定连续填充的最大数量。
tolerance：
- 类型：标量或字典，默认为 None。
- 描述：指定重新索引时的容差。

# reindex：重置DataFrame索引,可以变相添加行或列
# index：新的行索引
# columns：新的列索引
# method：当新的行或列有缺值时，可以填充指定的值。
# ‘ffill’向前填充，用前一行的或列的数据填充当前行或列，‘bfill'：向后填充，用前一行或列的数据填充当前行或列
# fill_value：当新的行或列有缺值时，可以使用指定的值填充

# 重置行或列时，如果新的行或列索引和原来的索引不一致，则新的行或列的数据默认填充NaN，一致的行或列则填充原来DataFrame中对应的数据
def pd_df_reindex():
    df = pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]},index = ['a','b','c'])
    new_index = ['a','b','c','d']
    df1 = df.reindex(new_index,axis=0)
    print(df1)
    new_column = ['A','B','C','D']
    df2 = df.reindex(columns=new_column,method='ffill')
    print(df2)
    df3 = df.reindex(new_index,fill_value=0)
    print(df3)


# pd_df_reindex()

1.1.2 reindex_like

语法：

DataFrame.reindex_like(other, method=None, copy=True, limit=None, tolerance=None)

参数：

other：
- 类型：DataFrame 或 Series。
- 描述：用于对齐索引和列的参考对象。
method：
- 类型：字符串，默认为 None。
- 描述：用于填充缺失值的方法。可选值包括 ‘ffill’（前向填充）、‘bfill’（后向填充）等。
copy：
- 类型：布尔值，默认为 True。
- 描述：是否返回新的 DataFrame 或 Series。
limit：
- 类型：整数，默认为 None。
- 描述：指定连续填充的最大数量。
tolerance：
- 类型：标量或字典，默认为 None。
- 描述：指定重新索引时的容差。

# reindex_like：用其他DataFrame中的索引来重置自己的索引
# 如果新索引和原来的索引一致，则填充对应的数据，如果有新的索引，则该索引对应的值为NaN
def pd_df_reindex_like():
    df1 = pd.DataFrame({'A':[1,2,3],'B':[4,5,6]},index=['a','b','c'])
    df2 = pd.DataFrame({'A': [7, 8, 9], 'B': [10, 11, 12]},index=['b','c','d'])

    df3 =df1.reindex_like(df2)
    print(df3)

    df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['a', 'b', 'c'])
    df2 = pd.DataFrame({'B': [7, 8, 9], 'C': [10, 11, 12]}, index=['a','b', 'c'])
    df4 = df1.reindex_like(df2)
    print(df4)

# pd_df_reindex_like()

2. 遍历

2.1 Series遍历

def pd_Series_item():
    # 遍历Series可以像遍历一维数组一样操作
    s = pd.Series([1,2,3])
    for i in s:
        print(i)
    # 遍历DataFrame不能直接遍历，打印结果只是列的名称
    df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
    for i in df:
        print(i)

    # 1.通过items遍历
    for index,value in s.items():
        print(f'index:{index},value:{value}')
    # 2.通过index遍历
    for index in s.index:
        print(f'index:{index},value:{s[index]}')
    # 3.通过value遍历
    for value in s.values:
        print(f'value:{value}')

pd_Series_item()

2.2 DataFrame

def pd_df_iter():
    df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
    # 通过iterrows遍历，返回index和row两个变量，遍历返回的row为Series对象
    for index,row in df.iterrows():
        print(f'index:{index},row:{row}')
    #通过itertuples遍历，返回row一个遍历，遍历返回值为元组对象
    for row in df.itertuples():
        print(f'row:{row}')
    #列遍历
    #通过items遍历列，返回列索引名和列的Series对象
    for col_index,col_values in df.items():
        print(f'col:{col_index},value:{col_values}')
    #通过loc和iloc遍历，按索引或位置遍历 DataFrame 的行和列。
    for index in df.index:
        for col in df.columns:
            print(f'index:{index},column:{col},value:{df.loc[index,col]}')

    print(df.columns)
    for i in range(df.index.stop):
        for j in range(len(df.columns)):
            print(f'value:{df.iloc[i,j]}')

pd_df_iter()

3. 排序

3.1 sort_index

sort_index 方法用于对 DataFrame 或 Series 的索引进行排序。

语法：

DataFrame.sort_index(axis=0, ascending=True, inplace=False)
Series.sort_index(axis=0, ascending=True, inplace=False)

参数：

axis：指定要排序的轴。默认为 0，表示按行索引排序。如果设置为 1，将按列索引排序。
ascending：布尔值，指定是升序排序（True）还是降序排序（False）。
inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。

3.2 sort_values

sort_values 方法用于根据一个或多个列的值对 DataFrame 进行排序。

语法：

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

参数：

by：列的标签或列的标签列表。指定要排序的列。
axis：指定沿着哪个轴排序。默认为 0，表示按列排序。如果设置为 1，将按行排序。
ascending：布尔值或布尔值列表，指定是升序排序（True）还是降序排序（False）。可以为每个列指定不同的排序方向。
inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的排序后的对象。
kind：排序算法。默认为 ‘quicksort’，也可以选择 ‘mergesort’ 或 ‘heapsort’。
na_position：指定缺失值（NaN）的位置。可以是 ‘first’ 或 ‘last’。

# sort_index：按行标签排序
# axis：排序的轴，0为行，1为列
# ascending：True升序，False降序
# inplace：True为修改原DataFrame，False为返回一个新的DataFrame

# sort_values：按列标签排序
# by：指定要排序的列，可以时单个列名或多个列名
# axis：默认0，表示按列排序(by为列名)，1为按行排序(by为行名)
# ascending：True升序，False降序
# inplace：True为修改原DataFrame，False为返回一个新的DataFrame
def pd_df_sort():
    df = pd.DataFrame({'A': [1, 1, 7], 'B': [5, 1, 6]},index=['b','c','a'])
    df1 = df.sort_index(ascending=False)
    print(df1)

    df.sort_index(ascending=True,inplace=True)
    print(df)

    df3 = df.sort_values('A',ascending=False)
    print(df3)
    df4 = df.sort_values(['c','a'],axis=1,ascending=True)
    print(df4)

pd_df_sort()

4. 去重

drop_duplicates 方法用于删除 DataFrame 或 Series 中的重复行或元素。

语法：

drop_duplicates(by=None, subset=None, keep='first', inplace=False)
Series.drop_duplicates(keep='first', inplace=False)

参数：

by：用于标识重复项的列名或列名列表。如果未指定，则使用所有列。
subset：与 by 类似，但用于指定列的子集。
keep：指定如何处理重复项。可以是：
- ‘first’：保留第一个出现的重复项（默认值）。
- ‘last’：保留最后一个出现的重复项。
- False：删除所有重复项。
inplace：布尔值，指定是否在原地修改数据。如果为 True，则会修改原始数据；如果为 False，则返回一个新的删除重复项后的对象。

import pandas as pd
from pyparsing import oneOf

# drop_duplicates：去重
# by：指定重复的列名或列名列表，未指定则表示所有
# keep：处理重复项 -'first'保留第一项，-'last'保留最后一项，-False删除所有重复项
def pd_df_drop():
    df = pd.DataFrame({'A':[1,2,2,3],
                       'B':[4,5,5,6],
                       'C':[7,8,8,9]
                       })

    df1 = df.drop_duplicates()
    print(df1)

    df2 = df.drop_duplicates(keep='last')
    print(df2)

    df3 = df.drop_duplicates(keep=False)
    print(df3)

# pd_df_drop()

5. 分组

5.1 groupby

groupby 方法用于对数据进行分组操作，这是数据分析中非常常见的一个步骤。通过 groupby，你可以将数据集按照某个列（或多个列）的值分组，然后对每个组应用聚合函数，比如求和、平均值、最大值等。

语法：

DataFrame.groupby(by, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

参数：

by：用于分组的列名或列名列表。
axis：指定沿着哪个轴进行分组。默认为 0，表示按行分组。
level：用于分组的 MultiIndex 的级别。
as_index：布尔值，指定分组后索引是否保留。如果为 True，则分组列将成为结果的索引；如果为 False，则返回一个列包含分组信息的 DataFrame。
sort：布尔值，指定在分组操作中是否对数据进行排序。默认为 True。
group_keys：布尔值，指定是否在结果中添加组键。
squeeze：布尔值，如果为 True，并且分组结果返回一个元素，则返回该元素而不是单列 DataFrame。
observed：布尔值，如果为 True，则只考虑数据中出现的标签。

5.2 filter

通过 filter() 函数可以实现数据的筛选，该函数根据定义的条件过滤数据并返回一个新的数据集

def pd_df_groupby():
    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': [10, 20, 30, 40, 50, 60, 70, 80]
    }

    df = pd.DataFrame(data)

    grouped = df.groupby('A')

    # for name,group in grouped:
    #     print(f"name:{name},Group:\n {group}")
    #
    # mean = df.groupby('A')['C'].mean()
    # print(mean)

    # mean = df.groupby('A')['C'].transform('mean')#transform也可以使用np.mean
    mean = df.groupby('A')['C'].transform(lambda x:x.mean())
    print(mean)
    df['group_mean'] = mean
    print(df)

    normal = df.groupby('A')['C'].transform(lambda x:(x-x.mean())/x.std())
    df['normal'] = normal
    print(df)

    df1 = df.groupby('A').filter(lambda x:x['C'].mean()>4)
    print(df1)

pd_df_groupby()

6. 合并

merge 函数用于将两个 DataFrame 对象根据一个或多个键进行合并，类似于 SQL 中的 JOIN 操作。这个方法非常适合用来基于某些共同字段将不同数据源的数据组合在一起，最后拼接成一个新的 DataFrame 数据表。

函数：

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

参数：

left：左侧的 DataFrame 对象。
right：右侧的 DataFrame 对象。
how

：合并方式，可以是 ‘inner’、‘outer’、‘left’ 或 ‘right’。默认为 ‘inner’。
- ‘inner’：内连接，返回两个 DataFrame 共有的键。
- ‘outer’：外连接，返回两个 DataFrame 的所有键。
- ‘left’：左连接，返回左侧 DataFrame 的所有键，以及右侧 DataFrame 匹配的键。
- ‘right’：右连接，返回右侧 DataFrame 的所有键，以及左侧 DataFrame 匹配的键。
on：用于连接的列名。如果未指定，则使用两个 DataFrame 中相同的列名。
left_on 和 right_on：分别指定左侧和右侧 DataFrame 的连接列名。
left_index 和 right_index：布尔值，指定是否使用索引作为连接键。
sort：布尔值，指定是否在合并后对结果进行排序。
suffixes：一个元组，指定当列名冲突时，右侧和左侧 DataFrame 的后缀。
copy：布尔值，指定是否返回一个新的 DataFrame。如果为 False，则可能修改原始 DataFrame。
indicator：布尔值，如果为 True，则在结果中添加一个名为 __merge 的列，指示每行是如何合并的。
validate：验证合并是否符合特定的模式。

# pd.merge：两个DataFrame，按照公共列进行合并
# left：左边的DataFrame
# right：右边的DataFrame
# on：指定两个DataFrame的公共列，如不指定，则按照相同的列名作为公共列
# how：连接的方式
# -'inner':内连接，默认；
# -'outer'：外连接，并集；
# -'left'：左连接，以左边的DataFrame为准，右边DataFrame如果有缺失值，则补充为NaN；
# -'right'：右连接，以右边的DataFrame为准，左边DataFrame如果有缺失值，则补充为NaN；
def pd_df_merge():
    left = pd.DataFrame({
        'key':[1,2,3,4,5],
        'A':['A1','A2','A3','A4','A5'],
        'B':['B1','B2','B3','B4','B5']
    })

    right = pd.DataFrame({
        'key': [1, 2, 3, 4, 6],
        'C': ['C1', 'C2', 'C3', 'C4', 'C5'],
        'D': ['D1', 'D2', 'D3', 'D4', 'D5']
    })

    df = pd.merge(left,right,on='key')
    print(df)

    df1 = pd.merge(left,right ,on='key',how='left')
    print(df1)

    df2 = pd.merge(left, right,on='key',how='right')
    print(df2)

    df3 = pd.merge(left, right, on='key', how='outer')
    print(df3)

# pd_df_merge()

7. 时间

import datetime as dt
def pd_df_datatime():
    datatime = dt.datetime(2024,10,25,16,3,30)
    print(datatime)
    data = dt.date(2024,10,25)
    time = dt.time(16,5,42)
    print(data)
    print(time)
    print(datatime.date())
    print(datatime.time())

    # datatime1 = pd.Timestamp()
    # print(datatime1)

    s = '2024-10-25 16:30:29'
    d2 = pd.to_datetime(s)
    print(d2)

    print(datatime.now())


    d3 = pd.date_range(start='2024-10-01',end='2024-10-25',freq='D')
    print(d3)

    d4 = pd.date_range(start='2024-10-25',periods=24,freq='h')
    print(d4)

# pd_df_datatime()