| | |
- __builtin__.dict(__builtin__.object)
-
- SmartDict
- __builtin__.object
-
- PropertiesContainer
- Command
class Command |
| |
Emulator of lambda functions.
The idea is taken from H.P. Langtangen, Python Scripting for Computational
Science. Springer Verlag Berlin Heidelberg, 2004. p. 519.
|
| |
Methods defined here:
- __call__(self, *args, **kwargs)
- Emulate a call of the function supplied in the constructor.
Positional arguments are obtained by appending args to the ones
supplied in the constructor. The keywords arguments are the ones supplied
in the constructor updated by kwargs.
- __init__(self, func, *args, **kwargs)
- Constructor of the class.
Positional arguments :
func -- function to be called
must be callable, otherwise an exception is raised
args -- positional arguments to the function
Keyword arguments :
kwargs -- keyword arguments to the function
Static methods defined here:
- fget_attr(obj, name)
- Emulate a fget function used by definition of a property (via attribute).
This is a static method of the class.
Positional arguments :
obj -- supposed to be the first argument of the fget function
name -- name of the attribute
- fget_value(obj, value)
- Emulate a fget function used by definition of a property (via value).
This is a static method of the class.
Positional arguments :
obj -- supposed to be the first argument of the fget function
value -- value to return
- fset_attr(obj, value, name)
- Emulate a fset function used by definition of a property.
This is a static method of the class.
Positional arguments :
obj -- object
value -- value of the attribute to be set
name -- attribute of the object to be set
|
class PropertiesContainer(__builtin__.object) |
| |
Class for exposing properties via attributes.
The following protected methods are called in the constructor :
_check_consistency() -- check the consistency of the data passed
_declare_properties() -- declare properties
The following protected method should be used for adding properties :
_add_property() -- expose a given class attribute as a property
|
| |
Methods defined here:
- __init__(self, modulename=None)
- Constructor of the class.
Keyword arguments :
modulename -- name of the package where the class is located (default None)
if not None, import that package first
- __repr__(self)
- Can be used to recreate an object with the same value.
Data and other attributes defined here:
- __dict__ = <dictproxy object>
- dictionary for instance variables (if defined)
- __weakref__ = <attribute '__weakref__' of 'PropertiesContainer' objects>
- list of weak references to the object (if defined)
|
class SmartDict(__builtin__.dict) |
| |
A container for a convenient storage of overridable options.
The class is based on the Python builtin dictionary. It is made up of two
containers for the options : internal dictionary for their default values
and a second dictionary, where the options are searched first. The former is
refered as the default dictionary and the latter as the reference dictionary.
The following readable and writable property is exposed :
kw -- reference dictionary
The following public methods are exported :
update_() -- update the reference dictionary
merge() -- overwrite the default dictionary with the reference one
|
| |
- Method resolution order:
- SmartDict
- __builtin__.dict
- __builtin__.object
Methods defined here:
- __delitem__(self, key)
- Delete a key from the default dictionary.
Positional arguments :
key -- key to be deleted
Nothing is done if the key does not exist.
- __getitem__(self, key)
- Overridden subscripting operator.
- __init__(self, mapping_or_sequence=None, kw=None, default_value=None)
- Constructor of the class.
Keyword arguments :
mapping_or_sequence -- initial contents of the default dictionary
(default : None, i.e. empty sequence)
kw -- reference dictionary (default None)
default_value -- returned if a key is found in neither in the default
nor in the reference dictionary (default None)
- __repr__(self)
- Can be used to recreate an object with the same value.
- merge(self)
- Update the default dictionary with the reference one.
- update_(self, kw)
- Update the reference dictionary.
If it is not defined, update the default dictionary.
Positional arguments :
kw -- dictionary to update with
Data and other attributes defined here:
- __dict__ = <dictproxy object>
- dictionary for instance variables (if defined)
- __weakref__ = <attribute '__weakref__' of 'SmartDict' objects>
- list of weak references to the object (if defined)
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
- __eq__(...)
- x.__eq__(y) <==> x==y
- __ge__(...)
- x.__ge__(y) <==> x>=y
- __getattribute__(...)
- x.__getattribute__('name') <==> x.name
- __gt__(...)
- x.__gt__(y) <==> x>y
- __hash__(...)
- x.__hash__() <==> hash(x)
- __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
- __setitem__(...)
- x.__setitem__(i, y) <==> x[i]=y
- 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 E and F: for k in E: D[k] = E[k]
(if E has keys else: for (k, v) in E: D[k] = v) then: for k in F: D[k] = F[k]
- values(...)
- D.values() -> list of D's values
Data and other attributes inherited from __builtin__.dict:
- __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.
| |