| | |
- __builtin__.dict(__builtin__.object)
-
- DatatNamedRows(_DatatBase, __builtin__.dict)
- __builtin__.list(__builtin__.object)
-
- Datat(_DatatBase, __builtin__.list)
- _DatatBase(__builtin__.object)
-
- Datat(_DatatBase, __builtin__.list)
- DatatNamedRows(_DatatBase, __builtin__.dict)
class Datat(_DatatBase, __builtin__.list) |
| |
A data table. Instantiate with a list of column names.
Looping over the Datat gives dictionaries mapping field names to values. If
you prefer to unpack into variables, loop over .tuples
|
| |
- Method resolution order:
- Datat
- _DatatBase
- __builtin__.list
- __builtin__.object
Methods defined here:
- __repr__(self)
- Gives a table preview of the first 10 rows.
- append(self, datum)
- Add a datum (as a dict) to the Datat. Any missing fields will be set
to None.
- filter(self, *conditions, **kwconditions)
- Returns a new dataset containing only rows with specific values.
Use keyword arguments to specify values for each column, or conditions
as strings for more complex queries.
augbdays = birthdays.filter(Month="August")
cars.filter("MPG > 30", Model="Ford")
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
Methods inherited from _DatatBase:
- __init__(self, colnames)
- blankdatum(self)
- Get a dictionary with values set to None, which can be modified and
appended to the Datat.
- save_csv(self, csvfile)
- Saves the Datat to a CSV file, placing the headers in the first row.
csvfile can be a file opened for writing, or the path to a file.
- translate_to_R(self)
- Turns the Datat into an R data.frame, using the rpy2 package.
This method will only exist if rpy2 can be imported.
Methods inherited from __builtin__.list:
- __add__(...)
- x.__add__(y) <==> x+y
- __contains__(...)
- x.__contains__(y) <==> y in x
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __delslice__(...)
- x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __getslice__(...)
- x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
- __gt__(...)
- x.__gt__(y) <==> x>y
- __iadd__(...)
- x.__iadd__(y) <==> x+=y
- __imul__(...)
- x.__imul__(y) <==> x*=y
- __iter__(...)
- x.__iter__() <==> iter(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __mul__(...)
- x.__mul__(n) <==> x*n
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __reversed__(...)
- L.__reversed__() -- return a reverse iterator over the list
- __rmul__(...)
- x.__rmul__(n) <==> n*x
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- __setslice__(...)
- x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.
- __sizeof__(...)
- L.__sizeof__() -- size of L in memory, in bytes
- count(...)
- L.count(value) -> integer -- return number of occurrences of value
- extend(...)
- L.extend(iterable) -- extend list by appending elements from the iterable
- index(...)
- L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
- insert(...)
- L.insert(index, object) -- insert object before index
- pop(...)
- L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
- remove(...)
- L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
- reverse(...)
- L.reverse() -- reverse *IN PLACE*
- sort(...)
- L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
Data and other attributes inherited from __builtin__.list:
- __hash__ = None
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
|
class DatatNamedRows(_DatatBase, __builtin__.dict) |
| |
A data table with rows by name instead of in a sequence. Instantiate by
passing the column names, and optionally a name for the column containing
row names (this can be set later as .namescol).
Looping over a DatatNamedRows will give row names. You can use standard
.items() and .values() methods for row names and content, or just the rows,
respectively. To unpack row names and fields, use .tuples.
If OrderedDict is available (built in to Python 2.7/3.1 and later, or the
ordereddict module from PyPI), rows will be kept in the order they were
added. Otherwise, the order of rows will be ignored.
|
| |
- Method resolution order:
- DatatNamedRows
- _DatatBase
- __builtin__.dict
- __builtin__.object
Methods defined here:
- __init__(self, colnames, namescol=None)
- __repr__(self)
- Gives a table preview of the first 10 rows.
- __setitem__(self, name, row)
- filter(self, *conditions, **kwconditions)
- Returns a new dataset containing only rows with specific values.
Use keyword arguments to specify values for each column, or conditions
as strings for more complex queries.
metalsdatat.filter("Melting_pt > 400")
apples.filter(Category="Cooker")
- save_csv(self, csvfile, namescol=None)
- Saves the Datat to a CSV file, with the headers in the first row.
csvfile can be a file opened for writing, or the path to a file.
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
Methods inherited from _DatatBase:
- blankdatum(self)
- Get a dictionary with values set to None, which can be modified and
appended to the Datat.
- translate_to_R(self)
- Turns the Datat into an R data.frame, using the rpy2 package.
This method will only exist if rpy2 can be imported.
Methods inherited from __builtin__.dict:
- __cmp__(...)
- x.__cmp__(y) <==> cmp(x,y)
- __contains__(...)
- D.__contains__(k) -> True if D has a key k, else False
- __delitem__(...)
- x.__delitem__(y) <==> del x[y]
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __getitem__(...)
- x.__getitem__(y) <==> x[y]
- __gt__(...)
- x.__gt__(y) <==> x>y
- __iter__(...)
- x.__iter__() <==> iter(x)
- __le__(...)
- x.__le__(y) <==> x<=y
- __len__(...)
- x.__len__() <==> len(x)
- __lt__(...)
- x.__lt__(y) <==> x<y
- __ne__(...)
- x.__ne__(y) <==> x!=y
- __sizeof__(...)
- D.__sizeof__() -> size of D in memory, in bytes
- clear(...)
- D.clear() -> None. Remove all items from D.
- copy(...)
- D.copy() -> a shallow copy of D
- get(...)
- D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
- has_key(...)
- D.has_key(k) -> True if D has a key k, else False
- items(...)
- D.items() -> list of D's (key, value) pairs, as 2-tuples
- iteritems(...)
- D.iteritems() -> an iterator over the (key, value) items of D
- iterkeys(...)
- D.iterkeys() -> an iterator over the keys of D
- itervalues(...)
- D.itervalues() -> an iterator over the values of D
- keys(...)
- D.keys() -> list of D's keys
- pop(...)
- D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
- popitem(...)
- D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
- setdefault(...)
- D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
- update(...)
- D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
- values(...)
- D.values() -> list of D's values
Data and other attributes inherited from __builtin__.dict:
- __hash__ = None
- __new__ = <built-in method __new__ of type object>
- T.__new__(S, ...) -> a new object with type S, a subtype of T
- fromkeys = <built-in method fromkeys of type object>
- dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
| |