Package mmLib :: Module PDB :: Class HET
[show private | hide private]
[frames | no frames]

Type HET

object --+        
         |        
      dict --+    
             |    
     PDBRecord --+
                 |
                HET


The HET records are used to describe non-standard residues, such as
prosthetic groups, inhibitors, solvent molecules, and ions for
which coordinates are supplied. Groups are considered HET if they are: 
- not one of the standard amino acids, and 
- not one of the nucleic acids (C, G, A, T, U, and I), and 
- not one of the modified versions of nucleic acids (+C, +G, +A,
+T, +U, and +I), and 
- not an unknown amino acid or nucleic acid where UNK is used to
indicate the unknown residue name. 
Het records also describe heterogens for which the chemical identity
is unknown, in which case the group is assigned the hetID UNK.

Method Summary
    Inherited from PDBRecord
  __str__(self)
  read(self, line)
Read the PDB record line and convert the fields to the appropriate dictionary values for this class.
  reccat(self, rec_list, field)
Return the concatenation of field in all the records in rec_list.
  reccat_dictlist(self, rec_list, field, master_key)
  reccat_list(self, rec_list, field, sep)
Call reccat, then split the result by the seperator.
  reccat_multi(self, rec_list, primary_key, translations)
Create a list of dictionaries from a list of records.
  reccat_tuplelist(self, rec_list, field, sep1, sep2)
Call reccat_list with sep1 as the list seperator, then split the items into tuples by sep2.
  write(self)
Return a properly formed PDB record string from the instance dictionary values.
    Inherited from dict
  __init__(...)
x.__init__(...) initializes x; see x.__class__.__doc__ for signature
  __cmp__(x, y)
x.__cmp__(y) <==> cmp(x,y)
  __contains__(D, k)
D.__contains__(k) -> True if D has a key k, else False
  __delitem__(x, y)
x.__delitem__(y) <==> del x[y]
  __eq__(x, y)
x.__eq__(y) <==> x==y
  __ge__(x, y)
x.__ge__(y) <==> x>=y
  __getattribute__(...)
x.__getattribute__('name') <==> x.name
  __getitem__(x, y)
x.__getitem__(y) <==> x[y]
  __gt__(x, y)
x.__gt__(y) <==> x>y
  __hash__(x)
x.__hash__() <==> hash(x)
  __iter__(x)
x.__iter__() <==> iter(x)
  __le__(x, y)
x.__le__(y) <==> x<=y
  __len__(x)
x.__len__() <==> len(x)
  __lt__(x, y)
x.__lt__(y) <==> x<y
  __ne__(x, y)
x.__ne__(y) <==> x!=y
  __new__(T, S, ...)
T.__new__(S, ...) -> a new object with type S, a subtype of T
  __repr__(x)
x.__repr__() <==> repr(x)
  __setitem__(x, i, y)
x.__setitem__(i, y) <==> x[i]=y
  clear(D)
D.clear() -> None.
  copy(D)
D.copy() -> a shallow copy of D
  get(D, k, d)
D.get(k[,d]) -> D[k] if k in D, else d.
  has_key(D, k)
D.has_key(k) -> True if D has a key k, else False
  items(D)
D.items() -> list of D's (key, value) pairs, as 2-tuples
  iteritems(D)
D.iteritems() -> an iterator over the (key, value) items of D
  iterkeys(D)
D.iterkeys() -> an iterator over the keys of D
  itervalues(D)
D.itervalues() -> an iterator over the values of D
  keys(D)
D.keys() -> list of D's keys
  pop(D, k, d)
If key is not found, d is returned if given, otherwise KeyError is raised
  popitem(D)
2-tuple; but raise KeyError if D is empty
  setdefault(D, k, d)
D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
  update(...)
D.update(E, **F) -> None.
  values(D)
D.values() -> list of D's values
    Inherited from object
  __delattr__(...)
x.__delattr__('name') <==> del x.name
  __reduce__(...)
helper for pickle
  __reduce_ex__(...)
helper for pickle
  __setattr__(...)
x.__setattr__('name', value) <==> x.name = value
    Inherited from type
  fromkeys(dict, S, v)
v defaults to None.

Class Variable Summary
list __slots__ = []

Class Variable Details

__slots__

Type:
list
Value:
[]                                                                     

Generated by Epydoc 2.1 on Sun Apr 23 22:08:39 2006 http://epydoc.sf.net