DataAnalysis (version 0.0.1)		index
DataAnalysis.html

This package implements tools to build python package and tools.
 
>>> from DataAnalysis import DataAnalysis
>>> from pprint import pprint
>>> data = [
...     {
...             "age": 45,
...             "pay": 80000,
...             "level": 12,
...     },
...     {
...             "age": 18,
...             "pay": 25000,
...             "level": 3,
...     },
...     {
...             "age": 45,
...             "pay": 40000,
...             "level": 3,
...     }
... ]
>>> analyse = DataAnalysis(data)
>>> pprint([x for x in analyse.get_medians()])
[statistictype(key='age', value=45),
 statistictype(key='pay', value=40000),
 statistictype(key='level', value=3)]
>>> pprint([x for x in analyse.get_deviations()])
[statistictype(key='age', value=12.727922061357855),
 statistictype(key='pay', value=23213.98046197353),
 statistictype(key='level', value=4.242640687119285)]
>>> pprint([x for x in analyse.get_variances()])
[statistictype(key='age', value=243),
 statistictype(key='pay', value=808333333.3333334),
 statistictype(key='level', value=27)]
>>> pprint([x for x in analyse.get_averages()])
[statistictype(key='age', value=36.0),
 statistictype(key='pay', value=48333.333333333336),
 statistictype(key='level', value=6.0)]
>>> pprint([x for x in analyse.get_maximums()])
[statistictype(key='age', value=valuetype(key='age', value=45, counter=2)),
 statistictype(key='pay', value=valuetype(key='pay', value=80000, counter=1)),
 statistictype(key='level', value=valuetype(key='level', value=12, counter=1))]
>>> pprint([x for x in analyse.get_minimums()])
[statistictype(key='age', value=valuetype(key='age', value=18, counter=1)),
 statistictype(key='pay', value=valuetype(key='pay', value=25000, counter=1)),
 statistictype(key='level', value=valuetype(key='level', value=3, counter=2))]
>>> pprint([x for x in analyse.count_values_by_keys()])
[statistictype(key='age', value=2),
 statistictype(key='pay', value=3),
 statistictype(key='level', value=2)]
>>> analyse.count_values_by_key('level')
statistictype(key='level', value=2)
>>> pprint([x for x in analyse.sort_by_value()])
[valuetype(key='level', value=3, counter=2),
 valuetype(key='level', value=12, counter=1),
 valuetype(key='age', value=18, counter=1),
 valuetype(key='age', value=45, counter=2),
 valuetype(key='pay', value=25000, counter=1),
 valuetype(key='pay', value=40000, counter=1),
 valuetype(key='pay', value=80000, counter=1)]
>>> pprint([x for x in analyse.sort_values_by_sum()])
[valuetype(key='level', value=3, counter=2),
 valuetype(key='level', value=12, counter=1),
 valuetype(key='age', value=18, counter=1),
 valuetype(key='age', value=45, counter=2),
 valuetype(key='pay', value=25000, counter=1),
 valuetype(key='pay', value=40000, counter=1),
 valuetype(key='pay', value=80000, counter=1)]
>>> pprint([x for x in analyse.sort_keys_by_sum()])
[('pay', 145000), ('age', 108), ('level', 18)]
>>> pprint([x for x in analyse.sort_by_counter()])
[valuetype(key='age', value=18, counter=1),
 valuetype(key='pay', value=80000, counter=1),
 valuetype(key='pay', value=25000, counter=1),
 valuetype(key='pay', value=40000, counter=1),
 valuetype(key='level', value=12, counter=1),
 valuetype(key='age', value=45, counter=2),
 valuetype(key='level', value=3, counter=2)]
>>> pprint([x for x in analyse.sort_by_key()])
[valuetype(key='age', value=45, counter=2),
 valuetype(key='age', value=18, counter=1),
 valuetype(key='level', value=12, counter=1),
 valuetype(key='level', value=3, counter=2),
 valuetype(key='pay', value=80000, counter=1),
 valuetype(key='pay', value=25000, counter=1),
 valuetype(key='pay', value=40000, counter=1)]
>>> pprint([x for x in analyse.keys_frequences()])
[statistictype(key='age', value=0.07441809186500006),
 statistictype(key='pay', value=99.91317889282416),
 statistictype(key='level', value=0.012403015310833345)]
>>> pprint([x for x in analyse.keys_values_frequences()])
[statistictype(key=valuetype(key='age', value=45, counter=2), value=0.06201507655416673),
 statistictype(key=valuetype(key='age', value=18, counter=1), value=0.012403015310833345),
 statistictype(key=valuetype(key='pay', value=80000, counter=1), value=55.12451249259265),
 statistictype(key=valuetype(key='pay', value=25000, counter=1), value=17.226410153935202),
 statistictype(key=valuetype(key='pay', value=40000, counter=1), value=27.562256246296325),
 statistictype(key=valuetype(key='level', value=12, counter=1), value=0.008268676873888896),
 statistictype(key=valuetype(key='level', value=3, counter=2), value=0.004134338436944448)]
>>> pprint([x for x in analyse.keys_values_count_frequences()])
[statistictype(key=valuetype(key='age', value=45, counter=2), value=22.22222222222222),
 statistictype(key=valuetype(key='age', value=18, counter=1), value=11.11111111111111),
 statistictype(key=valuetype(key='pay', value=80000, counter=1), value=11.11111111111111),
 statistictype(key=valuetype(key='pay', value=25000, counter=1), value=11.11111111111111),
 statistictype(key=valuetype(key='pay', value=40000, counter=1), value=11.11111111111111),
 statistictype(key=valuetype(key='level', value=12, counter=1), value=11.11111111111111),
 statistictype(key=valuetype(key='level', value=3, counter=2), value=22.22222222222222)]
>>> pprint([x for x in analyse.values_frequences()])
[statistictype(key=45, value=22.22222222222222),
 statistictype(key=18, value=11.11111111111111),
 statistictype(key=80000, value=11.11111111111111),
 statistictype(key=25000, value=11.11111111111111),
 statistictype(key=40000, value=11.11111111111111),
 statistictype(key=12, value=11.11111111111111),
 statistictype(key=3, value=22.22222222222222)]
>>> pprint([x for x in analyse.value_frequence(45)])
[45, 22.22222222222222]
>>> pprint([x for x in analyse.key_value_count_frequence(analyse.valuetype(key='pay', value=80000, counter=1))])
[valuetype(key='pay', value=80000, counter=1), 11.11111111111111]
>>> pprint([x for x in analyse.key_value_frequence(analyse.valuetype(key='pay', value=80000, counter=1))])
[valuetype(key='pay', value=80000, counter=1), 55.12451249259265]
>>> pprint([x for x in analyse.key_frequence('pay')])
['pay', 99.91317889282416]
>>> statistictypes = [DataAnalysis.statistictype(key=45, value=22.22222222222222),
...  DataAnalysis.statistictype(key=18, value=11.11111111111111),
...  DataAnalysis.statistictype(key=80000, value=11.11111111111111),
...  DataAnalysis.statistictype(key=25000, value=11.11111111111111),
...  DataAnalysis.statistictype(key=40000, value=11.11111111111111),
...  DataAnalysis.statistictype(key=12, value=11.11111111111111),
...  DataAnalysis.statistictype(key=3, value=22.22222222222222)]
>>> pprint([x for x in DataAnalysis.sort_statistictype_by_key(statistictypes)])
[statistictype(key=3, value=22.22222222222222),
 statistictype(key=12, value=11.11111111111111),
 statistictype(key=18, value=11.11111111111111),
 statistictype(key=45, value=22.22222222222222),
 statistictype(key=25000, value=11.11111111111111),
 statistictype(key=40000, value=11.11111111111111),
 statistictype(key=80000, value=11.11111111111111)]
>>> pprint([x for x in DataAnalysis.sort_statistictype_by_value(statistictypes)])
[statistictype(key=18, value=11.11111111111111),
 statistictype(key=80000, value=11.11111111111111),
 statistictype(key=25000, value=11.11111111111111),
 statistictype(key=40000, value=11.11111111111111),
 statistictype(key=12, value=11.11111111111111),
 statistictype(key=45, value=22.22222222222222),
 statistictype(key=3, value=22.22222222222222)]
>>> pprint([x for x in DataAnalysis.sort_dict_by_value({"a": 2, "b": 1, "c": 3})])
['b', 'a', 'c']
>>> pprint([x for x in analyse.get_values_by_key('pay')])
[valuetype(key='pay', value=80000, counter=1),
 valuetype(key='pay', value=25000, counter=1),
 valuetype(key='pay', value=40000, counter=1)]
>>> pprint([x for x in analyse.get_gt(DataAnalysis.valuetype(key='level', value=3, counter=2))])
[valuetype(key='age', value=45, counter=2),
 valuetype(key='age', value=18, counter=1),
 valuetype(key='pay', value=80000, counter=1),
 valuetype(key='pay', value=25000, counter=1),
 valuetype(key='pay', value=40000, counter=1),
 valuetype(key='level', value=12, counter=1),
 None]
>>> pprint([x for x in analyse.get_lt(DataAnalysis.valuetype(key='level', value=3, counter=2))])
[None, None, None, None, None, None, None]
>>> pprint([x for x in analyse.get_lt(DataAnalysis.valuetype(key='pay', value=25000, counter=1))])
[valuetype(key='age', value=45, counter=2),
 valuetype(key='age', value=18, counter=1),
 None,
 None,
 None,
 valuetype(key='level', value=12, counter=1),
 valuetype(key='level', value=3, counter=2)]
>>> analyse.count_lt(DataAnalysis.valuetype(key='pay', value=25000, counter=1))
6
>>> analyse.count_gt(DataAnalysis.valuetype(key='pay', value=25000, counter=1))
2
>>> analyse.count_value('level', 3)
valuetype(key='level', value=3, counter=2)
>>> analyse.get_minimum('level')
statistictype(key='level', value=valuetype(key='level', value=3, counter=2))
>>> analyse.get_maximum('level')
statistictype(key='level', value=valuetype(key='level', value=12, counter=1))
>>> analyse.get_sum('level')
statistictype(key='level', value=18)
>>> analyse.get_average('level')
statistictype(key='level', value=6.0)
>>> analyse.get_variance('level')
statistictype(key='level', value=27)
>>> analyse.get_deviation('level')
statistictype(key='level', value=4.242640687119285)
>>> analyse.get_median('level')
statistictype(key='level', value=3)
>>> data = [
...     {
...             "filename": "__init__.py",
...             "size": 255,
...             "lines": 5,
...             "modification": datetime.now(),
...     },
...     {
...             "filename": "WebScripts.py",
...             "size": 256520,
...             "lines": 3214,
...             "modification": datetime(2016, 6, 22, 12, 25, 48),
...     },
...     {
...             "filename": "future_python_file.py",
...     },
... ]
>>> analyse = DataAnalysis(data)
>>> pprint([x for x in analyse.get_sums()])
[statistictype(key='filename', value=None),
 statistictype(key='size', value=256775),
 statistictype(key='lines', value=3219),
 statistictype(key='modification', value=None)]
>>> analyse = DataAnalysis(data, fields=['size', 'lines', 'modification'])
>>> pprint([x for x in analyse.get_sums()])
[statistictype(key='size', value=256775),
 statistictype(key='lines', value=3219),
 statistictype(key='modification', value=None)]
>>> analyse = DataAnalysis(data, filter_=lambda x: x.get("size"))
>>> len(analyse.keys['filename'])
2
>>> analyse = DataAnalysis(data)
>>> len(analyse.keys['filename'])
3
>>> data = (
...     (1,2,3),
...     (500, 412, 561),
...     (721, 216, 683),
...     (10,25,56),
... )
>>> analyse = DataAnalysis(data)
>>> len(analyse.keys[0])
4
>>> analyse = DataAnalysis(data, filters={0: lambda x: x < 100})
>>> len(analyse.keys[0])
2
>>> analyse = DataAnalysis(data, fields=[1,3])
>>> len(analyse.keys[0])
0
>>> pprint([x for x in analyse.get_all_values()])
[valuetype(key=1, value=2, counter=1),
 valuetype(key=1, value=412, counter=1),
 valuetype(key=1, value=216, counter=1),
 valuetype(key=1, value=25, counter=1)]
>>> data = [{"key1": 1, "key2": 2}] * 3 + [{"key1": 2, "key2": 1}] * 2
>>> DataAnalysis.print_data(data, {"key1": "Column name", "key2": 5}, True)
|Column name|key2 |
|-----------|-----|
|1          |2    |
|1          |2    |
|1          |2    |
|1          |2    |
|2          |1    |
|2          |1    |
>>> DataAnalysis.print_data(data, {"key1": "Column name", "key2": 2}, True)
|Column name|ke|
|-----------|--|
|1          |2 |
|1          |2 |
|1          |2 |
|1          |2 |
|2          |1 |
|2          |1 |
>>> DataAnalysis.print_data(data)
|key1|key2|
|----|----|
|1   |2   |
|1   |2   |
|1   |2   |
|1   |2   |
|2   |1   |
|2   |1   |
>>> analysis = DataAnalysis(data)
>>> analysis.statistictypes_printer(analysis.get_deviations())
|key                    |value              |
|-----------------------|-------------------|
|key1                   |0.4898979485566356 |
|key2                   |0.4898979485566356 |
>>> analysis.statistictypes_printer(analysis.get_averages())
|key                    |value              |
|-----------------------|-------------------|
|key1                   |1.4                |
|key2                   |1.6                |
>>> analysis.valuetypes_printer(analysis.get_gt(analysis.valuetype(key="key1", value=0.5, counter=0)))
|key                    |value              |counter     |
|-----------------------|-------------------|------------|
|key1                   |1                  |3           |
|key1                   |2                  |2           |
|key2                   |2                  |3           |
|key2                   |1                  |2           |
>>> from DataAnalysis import PYPLOT
>>> if PYPLOT: analysis.statistictypes_chart(analysis.get_averages())
...
>>> for x in DataAnalysis.get_grouped_DataAnalysis(data, ("key1", "key2")): DataAnalysis.valuetypes_printer(x.get_values()); print()
...
|key                    |value              |counter     |
|-----------------------|-------------------|------------|
|key1                   |1                  |3           |
|key2                   |2                  |3           |
<BLANKLINE>
|key                    |value              |counter     |
|-----------------------|-------------------|------------|
|key1                   |2                  |2           |
|key2                   |1                  |2           |
<BLANKLINE>
>>> if PYPLOT: analysis.valuetypes_values_chart(analysis.get_all_values())
...
>>> if PYPLOT: analysis.valuetypes_counters_chart(analysis.get_values())
...
>>> import sys
>>> sys.modules["matplotlib"] = sys
>>> sys.modules["matplotlib.pyplot"] = sys
>>> from importlib import reload
>>> DataAnalysis = reload(sys.modules["DataAnalysis"]).DataAnalysis
>>> DataAnalysis.show_chart
Traceback (most recent call last):
  ...
AttributeError: type object 'DataAnalysis' has no attribute 'show_chart'
>>>
 
Run tests:
 ~# python -m doctest DataAnalysis.py
 ~# python DataAnalysis.py            # Verbose mode
 
1 items passed all tests:
  79 tests in __main__
79 tests in 65 items.
79 passed and 0 failed.
Test passed.
 
~# coverage run DataAnalysis.py
~# coverage report
Name              Stmts   Miss  Cover
-------------------------------------
DataAnalysis.py     290      0   100%
-------------------------------------
TOTAL               290      0   100%
~#

 
Classes
       
builtins.object
DataAnalysis

 
class DataAnalysis(builtins.object)
    DataAnalysis(data: collections.abc.Iterable[typing.Dict[collections.abc.Hashable, ~Value], collections.abc.Iterable[~Value]], fields: List[collections.abc.Hashable] = None, filter_: collections.abc.Callable = None, filters: Dict[collections.abc.Hashable, collections.abc.Callable] = {})
 

 
  Methods defined here:
__init__(self, data: collections.abc.Iterable[typing.Dict[collections.abc.Hashable, ~Value], collections.abc.Iterable[~Value]], fields: List[collections.abc.Hashable] = None, filter_: collections.abc.Callable = None, filters: Dict[collections.abc.Hashable, collections.abc.Callable] = {})
Initialize self.  See help(type(self)) for accurate signature.
build_keys(self) -> None
This function build data keys (reqired for all functions).
compare_event_action(self, ref_value: DataAnalysis.valuetype, event: collections.abc.Callable, match_action: collections.abc.Callable, not_match_action: collections.abc.Callable = <function DataAnalysis.<lambda> at 0x0000013E035B5630>) -> Any
This function calls match_action if event
return is True else calls not_match_action.
 
event signature: event(tested_value: valuetype, ref_value: valuetype) -> bool
match_action signature: match_action(value: valuetype) -> Any
not_match_action signature: not_match_action(value: valuetype) -> Any
compare_values(self, function: collections.abc.Callable, value1: DataAnalysis.valuetype, value2: DataAnalysis.valuetype) -> bool
This function compares valuetypes.
count_gt(self, value: DataAnalysis.valuetype) -> int
This function counts values greater than value.
count_lt(self, value: DataAnalysis.valuetype) -> int
This function counts values lesser than value.
count_value(self, key: collections.abc.Hashable, value: ~Value) -> DataAnalysis.valuetype
This function returns valuetype representing
a key value and counter of this value.
count_values_by_key(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This functions returns a statistictype with
key and counter of differents values for this key.
count_values_by_keys(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This functions returns statistictypes with
key and counter of differents values for this key.
get_all_values(self) -> collections.abc.Iterable[DataAnalysis.valuetype]
This function returns a list of
all keys, values and counters.
get_average(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This function returns average for a specific key.
get_averages(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns averages.
get_deviation(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This function returns deviation for a specific key.
get_deviations(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns deviations.
get_gt(self, value: DataAnalysis.valuetype) -> collections.abc.Iterable[DataAnalysis.valuetype]
This function yields valuetype greater than value.
get_keys_counter(self) -> collections.Counter
This function returns a Counter object
representing key and sum of the values.
get_keys_values_count_counter(self) -> collections.Counter
This function returns a Counter object
representing valuetypes and values count.
get_keys_values_counter(self) -> collections.Counter
This function returns a Counter object
representing valuetypes and sum of the values.
get_lt(self, value: DataAnalysis.valuetype) -> collections.abc.Iterable[DataAnalysis.valuetype]
This function yields valuetype lesser than value.
get_maximum(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This function returns maximum for a specific key.
get_maximums(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns maximums.
get_median(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This function returns median for a specific key.
get_medians(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns medians.
get_minimum(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This function returns minimum for a specific key.
get_minimums(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns minimums.
get_numbers_by_key(self, key: collections.abc.Hashable) -> Optional[List[Union[int, float]]]
This function returns a list of numbers by key value.
get_statistic(self, key: collections.abc.Hashable, function: collections.abc.Callable, valuegetter: collections.abc.Callable = None) -> DataAnalysis.statistictype
This function returns specific statistic for a specific key.
get_statistics(self, function: collections.abc.Callable, valuegetter: collections.abc.Callable = None) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns specific statistics.
get_sum(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This function returns sum for a specific key.
get_sums(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns sums.
get_values(self) -> collections.abc.Iterable[DataAnalysis.valuetype]
This function returns a list of
each keys, values and counters.
get_values_by_key(self, key: collections.abc.Hashable) -> collections.abc.Iterable[DataAnalysis.valuetype]
This function returns the list of
keys, values and counters for a key.
get_values_counter(self) -> collections.Counter
This function returns a Counter object
representing values and values count.
get_variance(self, key: collections.abc.Hashable) -> DataAnalysis.statistictype
This function returns variance for a specific key.
get_variances(self) -> collections.abc.Iterable[DataAnalysis.statistictype]
This function returns variances.
key_frequence(self, key: collections.abc.Hashable, pourcent: bool = True, counter: collections.Counter = None, all_sum: Union[int, float] = None) -> DataAnalysis.statistictype
This functions returns a statistictype of key frequence.
key_value_count_frequence(self, value: DataAnalysis.valuetype, pourcent: bool = True, counter: collections.Counter = None, all_sum: Union[int, float] = None) -> DataAnalysis.statistictype
This function returns a statistictype of
the frequency of the sum of the values in
the key.
key_value_frequence(self, value: DataAnalysis.valuetype, pourcent: bool = True, counter: collections.Counter = None, all_sum: Union[int, float] = None) -> DataAnalysis.statistictype
This function returns a statistictype of
the frequency of the sum of the values in
the key.
keys_frequences(self, pourcent: bool = True, counter: collections.Counter = None) -> collections.abc.Iterable[DataAnalysis.statistictype]
This generator yields statistictypes of keys frequences.
keys_values_count_frequences(self, pourcent: bool = True, counter: collections.Counter = None) -> collections.abc.Iterable[DataAnalysis.statistictype]
This generator yields statistictypes of
the frequency of the sum of the values in
the key.
keys_values_frequences(self, pourcent: bool = True, counter: collections.Counter = None) -> collections.abc.Iterable[DataAnalysis.statistictype]
This generator yields statistictypes of
the frequency of the sum of the values in
the key.
sort_by_counter(self, *args, **kwargs) -> collections.abc.Iterable[DataAnalysis.valuetype]
This functions returns keys, values
and counters sorted by counters.
sort_by_key(self, *args, **kwargs) -> collections.abc.Iterable[DataAnalysis.valuetype]
This functions returns keys, values and counters sorted by counters.
sort_by_value(self, *args, **kwargs) -> DataAnalysis.valuetype
This functions returns keys, values
and counters sorted by values.
sort_keys_by_sum(self, counter: collections.Counter = None) -> List[Tuple[collections.abc.Hashable, ~Value]]
This functions returns keys and
values sorted by sum of values.
sort_values_by_sum(self, *args, **kwargs) -> collections.abc.Iterable[DataAnalysis.valuetype]
This functions returns keys, values
and counters sorted by sum of values.
value_frequence(self, value: ~Value, pourcent: bool = True, counter: collections.Counter = None, all_sum: Union[int, float] = None) -> DataAnalysis.statistictype
This functions returns a statistictype of value frequence.
values_frequences(self, pourcent: bool = True, counter: collections.Counter = None) -> collections.abc.Iterable[DataAnalysis.statistictype]
This generator yields statistictypes of values frequences.
Class methods defined here:
get_grouped_DataAnalysis(data: collections.abc.Iterable[typing.Dict[collections.abc.Hashable, ~Value], collections.abc.Iterable[~Value]], columns: Tuple[collections.abc.Hashable], *args, **kwargs) -> collections.abc.Iterable[~DataAnalysis] from builtins.type
This function returns a DataAnalysis instance
for each group formatted by columns values.
Static methods defined here:
frequence(all_sum: Union[int, float], sample_sum: Union[int, float], pourcent: bool = True) -> Union[int, float]
This function returns the frequence of sample in all.
get_iterator_tuples(data: collections.abc.Iterable[typing.Dict[collections.abc.Hashable, ~Value], collections.abc.Iterable[~Value]]) -> collections.abc.Iterable[typing.Tuple[collections.abc.Hashable, ~Value]]
This function returns an iterator of tuples from dict or Iterable.
print_data(data: collections.abc.Iterable[typing.Dict[collections.abc.Hashable, ~Value], collections.abc.Iterable[~Value]], headers: Dict[collections.abc.Hashable, Union[str, int]] = {}, onetime: bool = False) -> None
This function prints data.
 
The headers are printed on the first
row and set the width of the columns.
sort_dict_by_value(data: Dict[collections.abc.Hashable, ~Value], *args, **kwargs) -> Dict[collections.abc.Hashable, ~Value]
This functions returns the dict sorted by values.
sort_statistictype_by_key(data: collections.abc.Iterable[DataAnalysis.statistictype], *args, **kwargs) -> collections.abc.Iterable[DataAnalysis.statistictype]
This functions returns statistictypes sorted by keys.
sort_statistictype_by_value(data: collections.abc.Iterable[DataAnalysis.statistictype], *args, **kwargs) -> collections.abc.Iterable[DataAnalysis.statistictype]
This functions returns statistictypes sorted by values.
statistictypes_printer(data: collections.abc.Iterable[DataAnalysis.statistictype]) -> None
This function prints statistictypes.
valuetypes_printer(data: collections.abc.Iterable[DataAnalysis.valuetype]) -> None
This function prints valuetypes.
Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
Data and other attributes defined here:
statistictype = <class 'DataAnalysis.statistictype'>
statistictype(key, value)
valuetype = <class 'DataAnalysis.valuetype'>
valuetype(key, value, counter)

 
Data
        __all__ = ['DataAnalysis']
__author_email__ = 'mauricelambert434@gmail.com'
__copyright__ = '\nPythonToolsKit Copyright (C) 2022 Maurice Lam...ome to redistribute it\nunder certain conditions.\n'
__description__ = '\nThis package implements tools to build python package and tools.\n'
__license__ = 'GPL-3.0 License'
__maintainer__ = 'Maurice Lambert'
__maintainer_email__ = 'mauricelambert434@gmail.com'
__url__ = 'https://github.com/mauricelambert/PythonToolsKit'

 
Author
        Maurice Lambert