Detail: IndexHierarchyGO: Constructor
Overview: IndexHierarchyGO: Constructor
- IndexHierarchyGO.__init__(indices, *, indexers=array([], dtype=int64), name=<object object>, blocks=None, own_blocks=False)
Initializer.
- Parameters:
indices – list of
Indexobjectsindexers – a 2D indexer array
name – name of the IndexHierarchy
blocks –
own_blocks –
>>> a = np.array([[0, 0, 1, 1], [0, 1, 0, 1]]) >>> a.flags.writeable = False >>> sf.IndexHierarchyGO((sf.Index(('a', 'b')), sf.Index((1024, 2048))), indexers=a) <IndexHierarchyGO> a 1024 a 2048 b 1024 b 2048 <<U1> <int64>
- classmethod IndexHierarchyGO.from_index_items(items, *, index_constructor=None, name=None)
Given an iterable of pairs of label,
IndexBase, produce anIndexHierarchywhere the labels are depth 0, the indices are depth 1. While the providedIndexBasecan be Index or IndexHierarchy, across all pairs all depths must be the same.- Parameters:
items – iterable of pairs of label,
IndexBase.index_constructor – Optionally provide index constructor for outermost index.
>>> ix1 = sf.Index(('a', 'b', 'c'), name='x') >>> ix2 = sf.Index((1024, 2048, 4096), name='y') >>> ih1 = sf.IndexHierarchyGO.from_index_items(((ix1.name, ix1), (ix2.name, ix2)), name='ih1') >>> ih1 <IndexHierarchyGO: ih1> x a x b x c y 1024 y 2048 y 4096 <<U1> <object> >>> ih2 = sf.IndexHierarchyGO.from_index_items(((ix2.name, ix2), (ix1.name, ix1)), name='ih2') >>> sf.IndexHierarchyGO.from_index_items(((ih1.name, ih1), (ih2.name, ih2))) <IndexHierarchyGO> ih1 x a ih1 x b ih1 x c ih1 y 1024 ih1 y 2048 ih1 y 4096 ih2 y 1024 ih2 y 2048 ih2 y 4096 ih2 x a ih2 x b ih2 x c <<U3> <<U1> <object>
- classmethod IndexHierarchyGO.from_labels(labels, *, name=None, reorder_for_hierarchy=False, index_constructors=None, depth_reference=None, continuation_token=<object object>)
Construct an
IndexHierarchyfrom an iterable of labels, where each label is tuple defining the component labels for all hierarchies.- Parameters:
labels – an iterator or generator of tuples.
* –
name –
reorder_for_hierarchy – an optional argument that will ensure the resulting index is arranged in a tree-like structure.
index_constructors –
depth_reference –
continuation_token – a Hashable that will be used as a token to identify when a value in a label should use the previously encountered value at the same depth.
- Returns:
>>> sf.IndexHierarchyGO.from_labels((('a', 1024, True), ('a', 2048, True), ('a', 2048, False), ('b', 1024, True)), name='x') <IndexHierarchyGO: x> a 1024 True a 2048 True a 2048 False b 1024 True <<U1> <int64> <bool>
- classmethod IndexHierarchyGO.from_labels_delimited(labels, *, delimiter=' ', name=None, index_constructors=None)
Construct an
IndexHierarchyfrom an iterable of labels, where each label is string defining the component labels for all hierarchies using a string delimiter. All components after splitting the string by the delimited will be literal evaled to produce proper types; thus, strings must be quoted.- Parameters:
labels – an iterator or generator of tuples.
- Returns:
>>> sf.IndexHierarchyGO.from_labels_delimited(("'a'|1024|False", "'b'|1024|True", "'b'|2048|False"), delimiter='|') <IndexHierarchyGO> a 1024 False b 1024 True b 2048 False <<U1> <int64> <bool>
- classmethod IndexHierarchyGO.from_names(names)
Construct a zero-length
IndexHierarchyfrom an iterable ofnames, where the length ofnamesdefines the zero-length depth.- Parameters:
names – Iterable of hashable names per depth.
>>> sf.IndexHierarchyGO.from_names(('x', 'y', 'z')) <IndexHierarchyGO: ('x', 'y', 'z')> <float64> <float64> <float64>
- classmethod IndexHierarchyGO.from_pandas(value)
Given a Pandas index, return the appropriate IndexBase derived class.
>>> mi = pd.MultiIndex.from_product((('a', 'b'), (1024, 2048))) >>> sf.IndexHierarchyGO.from_pandas(mi) <IndexHierarchyGO> a 1024 a 2048 b 1024 b 2048 <object> <int64>
- classmethod IndexHierarchyGO.from_product(*levels, name=None, index_constructors=None)
Given groups of iterables, return an
IndexHierarchymade of the product of a values in those groups, where the first group is the top-most hierarchy.- Parameters:
*levels – index initializers (or Index instances) for each level
name –
index_consructors –
- Returns:
>>> sf.IndexHierarchyGO.from_product(('a', 'b'), ('1517-04-01', '1620-11-21'), name='x', index_constructors=(sf.Index, sf.IndexDate)) <IndexHierarchyGO: x> a 1517-04-01 a 1620-11-21 b 1517-04-01 b 1620-11-21 <<U1> <datetime64[D]>
- classmethod IndexHierarchyGO.from_tree(tree, *, name=None, index_constructors=None)
Convert into a
IndexHierarchya dictionary defining keys to either iterables or nested dictionaries of the same.- Returns:
>>> sf.IndexHierarchyGO.from_tree({'a': {1024: (False, True), 2048: (True,)}}) <IndexHierarchyGO> a 1024 False a 1024 True a 2048 True <<U1> <int64> <bool>
- classmethod IndexHierarchyGO.from_values_per_depth(values, *, name=None, depth_reference=None, index_constructors=None)
Construct an
IndexHierarchyfrom a 2D NumPy array, or a collection of 1D arrays per depth.Very similar implementation to
_from_type_blocks(), but avoids creating TypeBlocks instance.- Returns:
>>> sf.IndexHierarchyGO.from_values_per_depth((('a', 'a', 'b', 'b'), (0, 1, 0, 1))) <IndexHierarchyGO> a 0 a 1 b 0 b 1 <<U1> <int64> >>> sf.IndexHierarchyGO.from_values_per_depth((range(0, 12, 2), range(6))) <IndexHierarchyGO> 0 0 2 1 4 2 6 3 8 4 10 5 <int64> <int64>
IndexHierarchyGO: Constructor | Exporter | Attribute | Method | Dictionary-Like | Display | Selector | Iterator | Operator Binary | Operator Unary | Accessor Values | Accessor Datetime | Accessor String | Accessor Transpose | Accessor Regular Expression | Accessor Hashlib | Accessor Type Clinic