Python笔记----DataFrame

import numpy as np
import pandas as pd
import numpy.ma as nm

'''
DataFrame 是由多种类型的列构成的二维标签数据结构，类似于 Excel 、SQL 表，或 Series 对象构成的字典。
DataFrame 是最常用的 Pandas 对象，与 Series 一样，DataFrame 支持多种类型的输入数据：
    一维ndarray、列表、字典、Series 字典
    二维numpy.ndarray
    结构多维数组或记录多维数组
    Series
    DataFrame

除了数据，还可以有选择地传递 index（行标签）和 columns（列标签）参数。
传递了索引或列，就可以确保生成的 DataFrame 里包含索引或列。
Series 字典加上指定索引时，会丢弃与传递的索引不匹配的所有数据
没有传递轴标签时，按常规依据输入数据进行构建。
数据是字典，且未指定 columns 参数时，DataFrame 的列按字典的插入顺序排序。。
'''

'''
用 Series 字典或字典生成 DataFrame
生成的索引是每个 Series 索引的并集。
先把嵌套字典转换为 Series。如果没有指定列，DataFrame 的列就是字典键的有序列表。
'''
d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
# print(pd.DataFrame(d))
# index 和 columns 属性分别用于访问行、列标签
# print(pd.DataFrame(d, index=['d', 'a', 'c']))
# 指定列与数据字典一起传递时，传递的列会覆盖字典的键
# print(pd.DataFrame(d, index=['d', 'b', 'a'], columns=['two', 'three']))

'''
用多维数组字典、列表字典生成 DataFrame
多维数组的长度必须相同。如果传递了索引参数，index 的长度必须与数组一致。如果没有传递索引参数，生成的结果是 range(n)，n 为数组长度。
'''

# d = {'one': [1., 2., 3., 4.],
#     'two': [2., 4., 1., 3.]}
# df = pd.DataFrame(d)
# print(df)

'''
用结构多维数组或记录多维数组生成 DataFrame
'''
# data = np.zeros((2, ), dtype=[('A', 'i4'), ('B', 'f4'), ('C', 'a10')])
# data[:] = [(1, 2., 'Hello'), (2, 3., 'World')]
# df = pd.DataFrame(data)
# print(df)
# print(pd.DataFrame(data, index=['first', 'second']))
# print(pd.DataFrame(data, columns=['C', 'A', 'B']))

'''
用列表字典生成 DataFrame
'''
data2 = [{'a': 1, 'b': 2, 'c': 3},
         {'a': 4, 'b': 5, 'c': 6}]
df2 = pd.DataFrame(data2)
# print(df2)
# print(pd.DataFrame(data2, index=['一', '二']))
# print(pd.DataFrame(data2, columns=('a', 'c', 'b')))

'''
用元组字典生成 DataFrame
'''
# print(pd.DataFrame({('a', 'b'): {('A', 'B'): 1, ('A', 'C'): 2},
#                    ('a', 'a'): {('A', 'C'): 3, ('A', 'B'): 4},
#                    ('a', 'c'): {('A', 'B'): 5, ('A', 'C'): 6},
#                    ('b', 'a'): {('A', 'C'): 7, ('A', 'B'): 8},
#                    ('b', 'b'): {('A', 'D'): 9, ('A', 'B'): 10}}))

'''
用 Series 创建 DataFrame
生成的 DataFrame 继承了输入的 Series 的索引，如果没有指定列名，默认列名是输入 Series 的名称。
DataFrame 里的缺失值用 np.nan 表示。
DataFrame 构建器以 numpy.MaskedArray 为参数时 ，被屏蔽的条目为缺失数据。
'''

'''
numpy.MaskedArray:掩码数组
在许多情况下，数据集可能不完整或因无效数据的存在而受到污染。 例如，传感器可能无法记录数据或记录无效值。 numpy.ma模块通过引入掩码数组提供了一种解决此问题的便捷方法
例如:
>>> x = np.array([1, 2, 3, -1, 5])
如果我们希望-1被标记为无效
则可以：
>>> mx = ma.masked_array(x, mask=[0, 0, 0, 1, 0])
当计算平均值时，不会考虑无效
>>> mx.mean()
2.75
'''
x = np.array([1, 2, 3, 5, 7, 4, 3, 2, 8, 0])
mask = x < 5
# 屏蔽小于5的值
mx = nm.array(x, mask=mask)
# print(mask)
# print(mx)
# 用填充值替换屏蔽数据。
# print(mx.filled())

'''
备选构建器
'''
# DataFrame.from_dict
# DataFrame.from_dict 接收字典组成的字典或数组序列字典，并生成 DataFrame。
# 除了 orient 参数默认为 columns，本构建器的操作与 DataFrame 构建器类似。
# 把 orient 参数设置为 'index'， 即可把字典的键作为行标签。
# print(pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])])))

# orient='index' 时，键是行标签。
# print(pd.DataFrame.from_dict(dict([('A', [1, 2, 3]), ('B', [4, 5, 6])]), orient='index', columns=['one', 'two', 'three']))

# DataFrame.from_records
# DataFrame.from_records 构建器支持元组列表或结构数据类型（dtype）的多维数组。
# 本构建器与 DataFrame 构建器类似，只不过生成的 DataFrame 索引是结构数据类型指定的字段。
# print(pd.DataFrame.from_records(data, index='C'))

'''
提取、添加、删除列
'''
# DataFrame 就像带索引的 Series 字典，提取、设置、删除列的操作与字典类似
# 提取
# print(df['one'])
df['three'] = df['two'] * df['one']
# print(df['three'])
# 添加
df['flag'] = df['one'] > 2
# print(df)
# 删除
del df['flag']
# print(df)

# 标量值以广播的方式填充列
df['foo'] = 'bar'
# print(df)

# 插入与 DataFrame 索引不同的 Series 时，以 DataFrame 的索引为准
df['five'] = df['one'][:2]
# print(df)

# 可以插入原生多维数组，但长度必须与 DataFrame 索引长度一致。
# 默认在 DataFrame 尾部插入列。insert 函数可以指定插入列的位置。
df.insert(1, 'bar', df['two'])
# print(df)

'''
用方法链分配新列
DataFrame 提供了 assign() 方法，可以利用现有的列创建新列。
assign 返回的都是数据副本，原 DataFrame 不变。
assign 函数签名就是 **kwargs。键是新字段的列名，值为是插入值（例如，Series 或 NumPy 数组），或把 DataFrame 当做调用参数的函数。
返回结果是插入新值的 DataFrame 副本。
'''

# 在数据处理，如果不注意：pandas会自己帮忙加上行和列的名称。
# 这是由于pandas中to_excel生成的数据是各种拼接之后的最终数据（默认index=True,column=True）
# index=False必须加，不然又生成一列新的Unnamed列。行处理也是一样，有参数column=False。
# index_col为指定数据中哪一列作为Dataframe的行索引，也可以可指定多列，形成层次索引，默认为None,即不指定行索引，这样系统会自动加上行索引（0-）
# 关于read_csv()更多详情请查看https://blog.csdn.net/hellocsz/article/details/79623142
df.to_csv('demo.csv', index=False)
iris = pd.read_csv('demo.csv')
# head()?---------------------------------------------------------------------------------------------------------------
# print(iris.head())
# print(iris.assign(six=iris['two'] * 1.25).head())

# 还可以传递带参数的函数，在 assign 的 DataFrame 上求值。
# print(iris.assign(demo=lambda x: (x['two'] / x['bar'])).head())

# Python 可以保存 **kwargs 顺序。这种操作允许依赖赋值，**kwargs 后的表达式，可以引用同一个 assign() 函数里之前创建的列 。
dfa = pd.DataFrame({'A': [1, 2, 3],
                    'B': [4, 5, 6]})
# print(dfa.assign(C=lambda x: x['A'] + x['B'], D=lambda x: x['A'] - x['B']))

'''
索引 / 选择
'''

# 选择行返回 Series，索引是 DataFrame 的列
print(df.loc['b'])
print(df.iloc[2])

'''
数据对齐和运算
支持布尔运算符
'''
# DataFrame 对象可以自动对齐列与索引(行标签)的数据。生成的结果是列和行标签的并集。
df3 = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])
df4 = pd.DataFrame(np.random.randn(7, 3), columns=['A', 'B', 'C'])
# print(df3 + df4)

# DataFrame 和 Series 之间执行操作时，默认操作是在 DataFrame 的列上对齐 Series 的索引，按行执行广播操作
# 什么是按列广播-----------------------------------------------------------------------------------------------------
# print(df3 - df3.iloc[0])

'''
转置
类似于多维数组，T 属性（即 transpose 函数）可以转置 DataFrame
'''
# print(df[:5])
# print(df[:5].T)

'''
DataFrame 应用 NumPy 函数
Series 与 DataFrame 可使用 log、exp、sqrt 等多种元素级 NumPy 通用函数（ufunc）
'''
# print(np.exp(df3))
# array和asarray都可以将结构数据转化为ndarray，但是主要区别就是当数据源是ndarray时，array仍然会copy出一个副本，占用新的内存，但asarray不会。
# print(np.array(df3))
# print(np.asarray(df3))

# DataFrame 不是多维数组的替代品，它的索引语义和数据模型与多维数组都不同。
# Series 应用 __array_ufunc__，支持 NumPy 通用函数。
# 通用函数应用于 Series 的底层数组。
# Pandas 可以自动对齐 ufunc 里的多个带标签输入数据。
# 例如，两个标签排序不同的 Series 运算前，会先对齐标签。
ser1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
ser2 = pd.Series([1, 3, 5], index=['b', 'c', 'a'])
# numpy.remainder()是另一个用于在numpy中进行数学运算的函数，
# 它返回两个数组arr1和arr2之间的除法元素余数，即 arr1 % arr2 当arr2为0且arr1和arr2都是整数数组时，返回0。
# print(np.remainder(ser1, ser2))

# 一般来说，Pandas 提取两个索引的并集，不重叠的值用缺失值填充。
ser3 = pd.Series([5, 6, 7], index=['b', 'c', 'd'])
# print(np.remainder(ser1, ser3))

# 对 Series 和 Index 应用二进制 ufunc 时，优先执行 Series，并返回的结果也是 Series 。
# np.max(a, axis=None, out=None, keepdims=False)
# 接收一个参数a
# 取a 在 axis方向上的最大值
# np.maximum(x, y)
# 接收两个参数x，y
# x，y逐位比较取最大值
idx = pd.Index([4, 5, 6])
# print(np.maximum(ser1, idx))

'''
控制台显示
控制台显示大型 DataFrame 时，会根据空间调整显示大小。info()函数可以查看 DataFrame 的信息摘要。
'''
# print(iris.info())

# 尽管 to_string 有时不匹配控制台的宽度，但还是可以用 to_string 以表格形式返回 DataFrame 的字符串表示形式
# 默认情况下，过宽的 DataFrame 会跨多行输出
# print(iris.iloc[10:].to_string())

# display.width 选项可以更改单行输出的宽度,默认值为80
pd.set_option('display.width', 40)
# print(pd.DataFrame(np.random.randn(3, 12)))

# 还可以用 display.max_colwidth 调整最大列宽。
pd.set_option('display.max_colwidth', 30)
# print(pd.DataFrame(iris))