zoukankan      html  css  js  c++  java
  • Pandas---2.内部数据结构(Index/MultiIndex/Series/DataFrame内部结构)

    (实线为普通属性,虚线为property属性或者getset_descriptor

    1.Index的结构 

    1. .name为普通属性,返回Index的名字
    2. .values/._valuesproperty属性,返回Index的内部数据的视图
    3. ._data为普通属性,返回Index的内部数据
    4. .shapeproperty属性,返回内部数据的形状
    5. ._engine为标签映射管理器,它负责管理label和下标之间的映射
    6. ObjectEngine对象使用一个哈希表对象PyObjectHashTable对象(由ObjectEngine对象的.mmaping属性给出,该属性是一个getset_descriptor)将标签映射到其对应的整数下标的。

    举例:

    import numpy as np
    import pandas as pd
    s = pd.Index(['a','b','c','d'],name='index1')
    s
    # Index(['a', 'b', 'c', 'd'], dtype='object', name='index1')
    
    s.name,s.values,s._values
    # ('index1',
     array(['a', 'b', 'c', 'd'], dtype=object),
     array(['a', 'b', 'c', 'd'], dtype=object))
    
    s._data,s.shape,
    # (array(['a', 'b', 'c', 'd'], dtype=object), (4,))
    
    s._engine
    # <pandas._libs.index.ObjectEngine at 0x1e1671803b8>

    2.MultiIndex的结构

    MultiIndex

    1. .name为普通属性,返回MultiIndex的名字。同Index
    2. .values/._valuesproperty属性,返回MultiIndex的内部数据的视图。同Index
      1. ._dataNone,这里是与Index不同。
    3. .shapeproperty属性,返回内部属性的形状 。同Index
    4. ._engine为标签映射管理器,它负责管理label和下标之间的映射。同Index
    5. .labelsproperty属性,它返回一个FrozenList(不可变列表),列表中存储每一级的label对应的下标(也就是创建MultiIndex时传入的labels参数),以FrozenNDArray的数据类型。
    6. .levelsproperty属性,它返回一个FrozenList(不可变列表),列表中存储每一级的label(也就是创建MultiIndex时传入的levels参数),以Index的数据类型。

    举例:

    import numpy as np
    import pandas as pd
    levels = [['a','b'],['c','d']]
    labels = [[0,1,0,1],[0,0,1,1]]
    s = pd.MultiIndex(levels=levels,labels=labels,name=['index1','index2'])
    s 
    # MultiIndex(levels=[['a', 'b'], ['c', 'd']],
               labels=[[0, 1, 0, 1], [0, 0, 1, 1]],
               names=['index1', 'index2'])
    
    s.values,s._values
    # (array([('a', 'c'), ('b', 'c'), ('a', 'd'), ('b', 'd')], dtype=object),
     array([('a', 'c'), ('b', 'c'), ('a', 'd'), ('b', 'd')], dtype=object))
    
    v1 = s.values
    v2 = s._values
    v1.base is v2.base,v1 is v2,s._data
    # (True, True, None)
    
    s.labels,s.labels[0]
    # (FrozenList([[0, 1, 0, 1], [0, 0, 1, 1]]),
     FrozenNDArray([0, 1, 0, 1], dtype='int8'))
    
    s.levels,s.levels[0]
    # (FrozenList([['a', 'b'], ['c', 'd']]),
     Index(['a', 'b'], dtype='object', name='index1'))

    3.Seris的结构

    Series

    1. ._name为普通属性,返回Seris的名字;.nameproperty属性,返回的也是Seris名字
    2. .dtype/.dtypesproperty属性,返回Series的数据类型。
    3. .ftype/ftypesproperty属性,返回一个字符串,说明Series是否稀疏数据。(二者返回的字符串的值相同,但不是同一个字符串对象)
    4. .values/._valuesproperty属性,返回Series的内部数据的视图
    5. .index为普通属性,返回Series的索引
    6. .shapeproperty属性,返回Series的数据的形状
    7. ._data为普通属性,它返回的是一个SingleBlockManager对象,该对象负责管理内部数据。
    8. SingleBlockManager.shape属性为property属性,返回内部数据的形状
    9. SingleBlockManager.blocks属性为普通属性,返回一个列表,该列表只有一个元素,该元素为一个IntBlock对象(或者其他的xxxBlock对象),代表了内部数据。
    10. IntBlock.values属性为普通属性,它返回内部数据:一个ndarray
    11. IntBlock.shape属性为property属性,它返回内部数据的形状

    举例:

    s = pd.Series({'a':1,'b':2,'c':3},name='sr')
    s
    # a    1
    b    2
    c    3
    Name: sr, dtype: int64
    
    s.name,s._name,s.name is s._name
    # ('sr', 'sr', True)
    
    s.dtype,s.dtypes,s.dtype is s.dtypes
    # (dtype('int64'), dtype('int64'), True)
    
    s.ftype,s.ftypes,s.ftype is s.ftypes
    # ('int64:dense', 'int64:dense', False)
    
    f1,f2 = s.ftype,s.ftypes
    f1 is f2
    # False
    
    s.values,s._values,s.values is s._values
    # (array([1, 2, 3], dtype=int64), array([1, 2, 3], dtype=int64), True)
    
    s.index,s.shape
    # (Index(['a', 'b', 'c'], dtype='object'), (3,))
    
    s._data
    # SingleBlockManager
    Items: Index(['a', 'b', 'c'], dtype='object')
    IntBlock: 3 dtype: int64
    

    4.DataFrame的结构

    DataFrame

    1. .index/columns属性都为普通属性,它们返回的都是一个Index对象,参考Series。 
    2. .dtypes属性为property属性,给出了每列的数值类型。它返回的是一个Series。并且没有.dtype属性,这一点与Series不同。 
    3. .ftypes属性为property属性,给出了每列是否为sparse/dense的。它返回的是一个Series。并且没有.ftype属性,这一点与Series不同。 
    4. .values/._values/.shape属性都为property属性,参考Series
    5. ._data属性为普通属性,它返回的是一个BlockManager对象,该对象负责管理内部数据。该对象的.block属性(普通属性)返回一个列表,该列表里面有多个元素。 DataFrame尽量用一个数组保存类型相同的列。
    6. 每个元素都为一个xxBlock对象。如IntBlock/FloatBlock...
      1. 一个xxBlock 可能存储多个列的数据(这些列的数据都是同一个类型)
    7. xxBlock对象的.values属性(普通属性)就是存储的某个列(或者某些类型相同的列)的内部数据,一个ndarray
    8. xxBlock对象的.shape属性(property属性)就是存储的某个列(或者某些类型相同的列)的内部数据的形状 
    9. .blocks属性为property属性。该属性返回一个字典,该字典的键为不同的数值类型,该字典的值为该数值类型的数值组成的DataFrame

    举例:

    import numpy as np
    import pandas as pd
    df = pd.DataFrame(np.arange(0,12).reshape(3,4),index=['a','b','c'],columns=['c1','c2','c3','c3'])
    df
    # 	c1	c2	c3	c3
    a	0	1	2	3
    b	4	5	6	7
    c	8	9	10	11
    
    df.index,df.columns
    # (Index(['a', 'b', 'c'], dtype='object'),
     Index(['c1', 'c2', 'c3', 'c3'], dtype='object'))
    
    df.dtypes,type(df.dtypes)
    # (c1    int32
     c2    int32
     c3    int32
     c3    int32
     dtype: object, pandas.core.series.Series)
    
    df.ftypes,type(df.ftypes)
    # (c1    int32:dense
     c2    int32:dense
     c3    int32:dense
     c3    int32:dense
     dtype: object, pandas.core.series.Series)
    
    print(df.values,df._values)
    v1 = df.values
    v2 = df._values
    v1.base is v2.base
    # [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]] [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    True
    
    manager = df._data
    manager
    #BlockManager
    Items: Index(['c1', 'c2', 'c3', 'c3'], dtype='object')
    Axis 1: Index(['a', 'b', 'c'], dtype='object')
    IntBlock: slice(0, 4, 1), 4 x 3, dtype: int32 
    
    manager.blocks
    # (IntBlock: slice(0, 4, 1), 4 x 3, dtype: int32,)
    
    manager.blocks[0].values,manager.blocks[0].shape
    # (array([[ 0,  4,  8],
            [ 1,  5,  9],
            [ 2,  6, 10],
            [ 3,  7, 11]]), (4, 3))
    
    df.blocks,type(df.blocks),type(df.blocks['int32'])
    # ({'int32':    c1  c2  c3  c3
      a   0   1   2   3
      b   4   5   6   7
      c   8   9  10  11}, dict, pandas.core.frame.DataFrame)
    

  • 相关阅读:
    linux设备驱动程序第3版学习笔记(例程3--scull)未完1
    linux设备驱动程序第3版学习笔记(例程2--hellop.c)
    linux设备驱动程序第3版学习笔记(例程1)
    Intellij中request等对象无法解析
    OneNote学习笔记----语言概述
    四、归并排序(mergesort)
    三、堆排序(Heapsort),优先队列可以用于O(N log N)
    二、希尔排序(Shellsort)-- 缩减增量排序(diminishing increment sort)
    一、插入排序(insertion sort)
    hashmap冲突的解决方法以及原理分析:
  • 原文地址:https://www.cnblogs.com/nxf-rabbit75/p/12108423.html
Copyright © 2011-2022 走看看