* use very less memory then a disalignd pd.Dataframe
*`dios[var]` where `var` can be a list (or any iterable object) or a string
*`dios[slice]` where `slice` can be a row slicer
*`dios.loc[rowindexer]` act like `pandas.Series().loc[rowindexer]` for each series in the dios
*`dios.loc[rowindexer, columns]` like `dios.loc[rowindexer]` but for a subset of columns, which can be specified by a iterable, slice(on columns) or string
*`+,-,*,/,//,%` and `==,!=,>,>=,<=,<` and `~,&,|,^` and `is, in, len, all, any, empty, columns` are implemented
* also `pipe()` (and as alias `foreach()`) is implemented, which pass any `pandas.Series`-method to every series in the dios and return the resulting dios
* act quite like pd.DataFrame
* additional align locator (`.aloc[]`)
Indexing
--------
-`di[]` and `di.loc[]`, `di.iloc[]` and `di.at[]`, `di.iat[]` - should behave exactly like
their counter-parts from pd.Dataframe.
Most indexers are directly passed to the underling columns-series or row-series.
- on selecting operations, Dios simply throw out rows, that wasn't selected,
instead of using `nan`'s, like pd.Dataframe do.
- on writing operations, analogous to selecting, only selected rows are changed, un-selected rows preserve
their value.
-`dios[BoolDiosLike]` - like pd.DataFrame, dios accept boolean multiindexer (boolean pd.Dataframe
or boolean Dios) columns and rows from the multiindexer align with the dios.
This means that only matching columns are selected/written, the same apply for rows.
Nevertheless columns, that are empty after applying the indexer, are preserved, with the effect
that the resulting Dios always have the same (column)-dimension that the initial Dios.
(This is the exact same behaivior as pd.DataFrame handle multiindexer,
despite that miss-matching columns are filled with nan's)
- additional there is a `di.aloc[..]` indexing method. Unlike `iloc` and `loc` indexers and values
fully align if possible. Also this method handle missing values gratefully. In contrast
to `di[BoolDiosLike]`, empty columns are **not** preserved on selecting. Briefly:
Grateful handling of non-alignable indexer:
-**lists** (including non-boolean Series, only `ser.values` are used)
- as column indexer: only matching columns are used
- as row indexer: only matching rows are used in every series of the column
-**single labels** on columns or rows: use if match
Alignable indexer are:
-**boolean-series** (a missing index is treated like an existing `False` value)
- as **column indexer**: The index should contain column names. If the corresponding value is `True` and
the column exist, the column will be selected/written.
- as **row indexer**: The indexer will be applied on all (selected) columns.
On every column the index of the boolean-series is aligned with the index of underling series.
If the corresponding value is `True`, the row will be selected/written.
-**boolean-Dios**: work like `dios[BoolDiosLike]` (see above), but do not preserve empty columns on selecting.
-**pd.DataFrame**: like boolean-Dios
Alignable values are:
-**series**: align with every column
-**Dios**: full align on columns and rows
-**pd.DataFrame**: like Dios
Properties
----------
- columns
- dtype
- itype (see section Itype)
- empty
Methods and implied features
-------
Work mostly like analogous methods from pd.DataFrame.
- copy()
- copy_empty()
- all()
- any()
- squeeze()
- to_df()
- apply()
- astype()
- memory_usage()
-`in`
-`is`
-`len(Dios)`
Operators and Comparators
---------
- arithmetical: `+ - * ** // / %` and `abs()`
- boolean: `&^|~`
- comparators: `== != > >= < <=`
Itype
-----
DictOfSeries holds multiple series, where possibly every series can have a different index length
and index type. Different index length, is solved with some aligning magic, or simply fail, if
aligning makes no sense (eg. assigning the very same list to series of different length).
The bigger problem is the type of the index. If one series has a alphabetical index, an other
an numeric index, selecting along columns, can just fail in every scenario. To keep track of the
types of index or to prohibit the inserting of a *not fitting* index type,
we introduce a `itype`. This can be set on creation of a Dios and also changed during usage.
On change of the itype, all index of all series in the dios are casted to a new fitting type,
if possible. Different cast-mechanisms are available.
If a itype prohibit some certain types of index, but a series with this index-type is inserted,
a implicit cast is done, with or without a warning, or an error is raised. The warning/error policy
