Python之Pandas使用详解

Pandas用法介绍

1. 构建Series对象

def build_series():
    """
    使用pandas创建Series对象（一维的数组型对象）
    :return:
    """
    # 创建数组
    pd.Series(dict(names='Evan', id=66))  # 使用字典生成一个Series（字典的键是行索引）
    test = pd.Series(['aa', 'bb', 'cc', 'aa'], index=[1, 3, 5, 7])  # 使用列表生成一个Series，并指定行索引值（默认从0开始）
    test.name = 'Data'  # 指定数组名称
    test.index.name = 'Info'  # 指定行索引名称

    # 查看数组属性
    print('返回数组名称\n{}'.format(test.name))
    print('返回指定行索引内的值\n{}'.format(test[3]))
    print('返回数组的所有值\n{}'.format(test.values))
    print('返回数组的所有索引\n{}'.format(test.index))
    print('返回数组所有的唯一值（去重）\n{}'.format(test.unique()))
    print('返回数组所有值的出现次数（默认降序）\n{}'.format(test.value_counts()))
    print('计算数组中每个值是否包含于传入序列的值，返回一个布尔值\n{}'.format(test.isin(['aa', 'cc'])))

2. 构建DataFrame对象

def build_data_frame():
    """
    使用pandas创建DataFrame对象（二维的数组型对象）
    :return:
    """
    # 创建数组
    # 1. 使用嵌套字典格式创建DataFrame（字典的键作为列标签，内部字典的键作为行索引）
    data = {
        'Name': {'Evan': 1, 'Jane': 2},
        'Id': {'Evan': 11, 'Jane': 22}
    }
    print('使用嵌套字典构建DataFrame\n{}'.format(pd.DataFrame(data)))
    # 2. 使用字典列表格式创建DataFrame（字典的键为列标签，行索引默认从0开始，列表内的所有值是每一列的值）
    data = {
        'Name': ['Evan', 'Jane', 'Spring', 'Summer', 'Autumn', 'Winter'],
        'Id': [66, 77, 88, 99, 100, 110],
        'Stature': [177, 160, 150, 167, 180, 190],
        'Weight': [65, 45, 50, 60, 65, 70]
    }
    # 指定行索引值、列标签顺序（使用columns参数时，只会读取该列表内的列索引数据）
    frame = pd.DataFrame(data, columns=['Id', 'Name', 'Weight', 'Stature'], index=[3, 2, 1, 6, 5, 4])
    print('构建指定列标签顺序和行索引的DataFrame\n{}'.format(frame))

    # 查看数组属性
    print('返回数组的行索引是否唯一\n{}'.format(frame.index.is_unique))
    print('返回数组的头5行\n{}'.format(frame.head()))
    print('返回指定行索引内的指定列标签值（使用轴标签）\n{}'.format(frame.loc[2, ['Id', 'Weight']]))  # 使用行索引和列标签的值
    print('返回指定行索引内的指定列标签值（使用整数标签）\n{}'.format(frame.iloc[1, [0, 2]]))  # 使用行索引和列标签的位置
    print('返回指定行索引内的所有值\n{}'.format(frame.loc[2]))
    print('返回指定列标签内的所有值\n{}'.format(frame['Name']))
    print('返回数组所有的列标签\n{}'.format(frame.columns))
    print('返回数组所有的值\n{}'.format(frame.values))
    print('返回数组中所有值在每一列的出现次数（没有的默认为0）\n{}'.format(frame.apply(pd.value_counts).fillna(0)))
    print('返回数组中指定列标签内所有值的出现次数\n{}'.format(pd.value_counts(frame['Weight'])))
    print('返回数组中指定列标签内所有的唯一值（去重）\n{}'.format(pd.unique(frame['Weight'])))

3. 数组操作

def array_operations():
    """
    数组操作
    :return:
    """
    data = {
        'Name': ['Evan', 'Jane', 'Spring', 'Summer', 'Autumn', 'Winter'],
        'Id': [66, 77, 88, 99, 100, 110],
        'Stature': [177, 160, 150, 167, 180, 190],
        'Weight': [65, 45, 50, 60, 65, 70]
    }
    frame = pd.DataFrame(data, columns=['Id', 'Name', 'Weight', 'Stature'], index=[3, 2, 1, 6, 5, 4])
    # 对数组排序
    # inplace默认False，代表是否改变原数组，为True时返回None，False返回一个新数组
    print('根据行索引排序（默认升序）\n{}'.format(frame.sort_index(inplace=True)))
    print('根据行索引排序（降序）\n{}'.format(frame.sort_index(ascending=False)))  # 指定降序
    print('根据列标签排序\n{}'.format(frame.sort_index(axis='columns')))
    data = pd.Series([3, 6, -5, 8, 3])
    print('根据数组值排序\n{}'.format(data.sort_values()))
    print('根据指定列标签排序\n{}'.format(frame.sort_values(by=['Weight', 'Stature'])))

    # 对数组排名
    print('对所有值进行排名（默认升序）\n{}'.format(data.rank()))  # 默认升序排名，平级全部取平均值
    print('对所有值进行排名（降序）\n{}'.format(data.rank(ascending=False)))  # 降序排名，平级全部取平均值
    print('平级关系取最小值，占用坑位\n{}'.format(data.rank(method='min')))  # 平级关系全部取最小值，每个平级关系占用一个坑位
    print('平级关系取最小值，不占用坑位\n{}'.format(data.rank(method='dense')))  # 平级关系全部取最小值，平级关系不占用坑位
    print('平级关系取最大值，占用坑位\n{}'.format(data.rank(method='max')))  # 平级关系全部取最大值，每个平级关系占用一个坑位
    print('按观察顺序排名\n{}'.format(data.rank(method='first')))  # 按照值在数据中出现的次序分配排名

    # 重构数组
    # ffill向前填充（缺失值和其前面的值相同），bfill向后填充（缺失值和其后面的值相同）
    print('重新构建数组的行索引\n{}'.format(frame.reindex([1, 3, 5, 7], method='ffill')))
    # fill_value赋给缺失值
    print('重新构建数组的行索引\n{}'.format(frame.reindex([2, 4, 6, 8], fill_value='world')))
    print('重新构建数组的列标签\n{}'.format(frame.reindex(columns=['Id', 'Weight', 'happy'], fill_value='news')))

    # 删除指定的项目
    print('删除指定行\n{}'.format(frame.drop([1, 3])))
    print('删除指定列\n{}'.format(frame.drop(['Id', 'Weight'], axis='columns')))  # axis控制轴的位置，默认为index

4. 文件操作

def file_operations():
    """
    使用pandas载入存储文件
    :return:
    """
    data = pd.DataFrame([[1, 2, 3, '11'], [4, 5, 6, '22'], [7, 8, 9, None]], columns=['a', 'b', 'c', 'd'])
    # 写入读取CSV文件
    file_name = 'example.csv'
    # index：是否写入行索引，header：是否写入列标签
    # columns：可指定写入对应的列标签数据并且有顺序，na_rep会赋值给缺失值（默认为空）
    data.to_csv(file_name, index=False, header=False, columns=['b', 'd', 'a'], na_rep='NULL')  # 写入CSV文件
    data.to_csv(sys.stdout, sep='|')  # 输出到屏幕，sep为分隔符（可用于临时查看写入的数据）
    print('读取CSV文件')
    print('自动分配默认列标签（从0开始）\n{}'.format(pd.read_csv(file_name, header=None)))
    print('指定列标签\n{}'.format(pd.read_csv(file_name, names=['a', 'b', 'c'])))
    print('指定"a"列的值为行索引\n{}'.format(pd.read_csv(file_name, names=['a', 'b', 'c'], index_col='a')))
    print('指定"a"列和"b"列的值为行索引（分层索引）\n{}'.format(pd.read_csv(file_name, names=['a', 'b', 'c'], index_col=['a', 'b'])))
    print('使用缺失值替换文件内的指定值\n{}'.format(pd.read_csv(file_name, names=['a', 'b', 'c'], na_values={'b': [5, 8]})))
    # pd.options.display.max_rows = 5  # 设置文件读取显示的行数，多出的行数变为省略号显示
    print('跳过指定的行读取\n{}'.format(pd.read_csv(file_name, names=['a', 'b', 'c'], skiprows=[0, 2])))  # 跳过第0行和第2行
    print('读取指定的行范围\n{}'.format(pd.read_csv(file_name, names=['a', 'b', 'c'], nrows=2)))  # 只读取前2行
    os.remove(file_name)

    # 写入读取Excel文件
    file_name = 'example.xls'
    data.to_excel(file_name, index=True, header=True, sheet_name='sheet1', na_rep='NULL')
    print('读取Excel文件')
    print(pd.read_excel(file_name, sheet_name='sheet1'))
    os.remove(file_name)

    # 写入读取JSON文件
    file_name = 'example.json'
    data.to_json(file_name)
    print('读取JSON文件')
    print(pd.read_json(file_name))
    os.remove(file_name)

    # 读取TXT文件
    print('读取TXT文件')
    file_name = 'example.txt'
    with open(file_name, 'w', encoding='utf-8') as f:
        f.writelines(['A,B,C\n', '1,2,3\n', '4,5,6\n', '4,5,6\n'])
    print(pd.read_csv(file_name, sep=','))  # 使用sep根据逗号切分每个数据
    os.remove(file_name)

5. 数据清洗

def data_cleansing():
    """
    数据清洗
    :return:
    """
    nan = np.NAN
    # 过滤缺失值
    data = pd.DataFrame([[1, 2, 3], [4, 5, nan], [None, nan, nan], [1, 2, 3]], columns=['a', 'b', 'c'])
    print('过滤所有包含缺失值的行\n{}'.format(data.dropna()))  # 默认删除包含缺失值的行
    print('过滤所有包含缺失值的列\n{}'.format(data.dropna(axis='columns')))
    print('过滤所有值均为NA的行\n{}'.format(data.dropna(how='all')))  # 只删除所有值均为NA的行
    print('过滤并保留包含一定数量NA的行\n{}'.format(data.dropna(thresh=1)))  # 保留一行NA值

    # 补全缺失值
    print('补全所有缺失值\n{}'.format(data.fillna(0)))  # 全部的缺失值变为0
    print('只补全指定列标签内的缺失值\n{}'.format(data.fillna({'a': 0, 'b': 1})))  # 只补全"a"列和"b"列的缺失值
    print('补全所有缺失值（向前填充）\n{}'.format(data.fillna(method='ffill', limit=1)))  # 向前填充（缺失值和其前面的值相同），limit为最大填充范围
    print('补全所有缺失值（向后填充）\n{}'.format(data.fillna(method='bfill')))  # 向后填充（缺失值和其后面的值相同）

    # 删除重复值
    print('删除所有重复的行（默认保留第一个观测到的行）\n{}'.format(data.drop_duplicates()))
    print('删除所有重复的行（保留最后一个观测到的行）\n{}'.format(data.drop_duplicates(keep='last')))
    print('删除指定列标签下重复的行\n{}'.format(data.drop_duplicates(['b'])))

    # 替代值
    print('替换所有的NA为0\n{}'.format(data.replace(nan, 0)))
    print('替换指定数量的值\n{}'.format(data.replace({1: 10, 2: 20})))  # 1替换为10，2替换为20

    # 重命名轴索引
    print('重命名行索引\n{}'.format(data.rename(index={1: 10})))
    print('重命名列标签\n{}'.format(data.rename(columns={'c': 'cc'})))

6. 数据规整

def data_structured():
    """
    数据规整
    :return:
    """
    # Series分层索引
    data = pd.Series(np.random.randn(6), index=[['a', 'a', 'b', 'b', 'c', 'c'], [1, 2, 3, 1, 2, 3]])
    print('创建Series分层索引\n{}'.format(data))
    print('分层索引重新排列\n{}'.format(data.unstack()))  # 第二索引变为列标签（Series对象转化为DataFrame对象）
    print('分层索引复原\n{}'.format(data.unstack().stack()))

    # DataFrame分层索引
    data = pd.DataFrame(np.arange(12).reshape((4, 3)), index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
                        columns=[['one', 'one', 'two'], ['three', 'four', 'five']])
    # 定义层级行名称和列名称
    data.index.names = ['key1', 'key2']
    data.columns.names = ['number1', 'number2']
    print('创建DataFrame分层索引\n{}'.format(data))

    # 层级交换（数据不会跟着变）
    print('行层级名称交换（使用名称）\n{}'.format(data.swaplevel('key1', 'key2')))
    print('列层级名称交换（使用序号）\n{}'.format(data.swaplevel(0, 1, axis='columns')))

    # 层级排序（数据会跟着变）
    print('行层级名称排序\n{}'.format(data.sort_index(level=1)))
    print('列层级名称排序\n{}'.format(data.sort_index(level=1, axis='columns')))

    # 按层级进行汇总统计
    print('按行层级求和\n{}'.format(data.sum(level='key1')))
    print('按列层级求和\n{}'.format(data.sum(level='number2', axis='columns')))

    # 将DataFrame的列变为行索引
    data = pd.DataFrame(np.arange(12).reshape((4, 3)), columns=['a', 'b', 'c'])
    print('将DataFrame的列变为行索引（移除该列）\n{}'.format(data.set_index(['c'])))  # "c"会从数组中移除变为行索引
    print('将DataFrame的列变为行索引（保留该列）\n{}'.format(data.set_index(['c'], drop=False)))  # "c"会保留在数组中

Over~