text: # This contains most of the executable examples from Guido's descr
  # tutorial, once at
  #
  #     http://www.python.org/2.2/descrintro.html
  #
  # A few examples left implicit in the writeup were fleshed out, a few were
  # skipped due to lack of interest (e.g., faking super() by hand isn't
  # of much interest anymore), and a few were fiddled to make the output
  # deterministic.
  
  from test.test_support import sortdict
  import pprint
  
  class defaultdict(dict):
      def __init__(self, default=None):
          dict.__init__(self)
          self.default = default
  
      def __getitem__(self, key):
          try:
              return dict.__getitem__(self, key)
          except KeyError:
              return self.default
  
      def get(self, key, *args):
          if not args:
              args = (self.default,)
          return dict.get(self, key, *args)
  
      def merge(self, other):
          for key in other:
              if key not in self:
                  self[key] = other[key]
  
  test_1 = """
  
  Here's the new type at work:
  
      >>> print defaultdict               # show our type
      <class 'test.test_descrtut.defaultdict'>
      >>> print type(defaultdict)         # its metatype
      <type 'type'>
      >>> a = defaultdict(default=0.0)    # create an instance
      >>> print a                         # show the instance
      {}
      >>> print type(a)                   # show its type
      <class 'test.test_descrtut.defaultdict'>
      >>> print a.__class__               # show its class
      <class 'test.test_descrtut.defaultdict'>
      >>> print type(a) is a.__class__    # its type is its class
      True
      >>> a[1] = 3.25                     # modify the instance
      >>> print a                         # show the new value
      {1: 3.25}
      >>> print a[1]                      # show the new item
      3.25
      >>> print a[0]                      # a non-existent item
      0.0
      >>> a.merge({1:100, 2:200})         # use a dict method
      >>> print sortdict(a)               # show the result
      {1: 3.25, 2: 200}
      >>>
  
  We can also use the new type in contexts where classic only allows "real"
  dictionaries, such as the locals/globals dictionaries for the exec
  statement or the built-in function eval():
  
      >>> def sorted(seq):
      ...     seq.sort(key=str)
      ...     return seq
      >>> print sorted(a.keys())
      [1, 2]
      >>> exec "x = 3; print x" in a
      3
      >>> print sorted(a.keys())
      [1, 2, '__builtins__', 'x']
      >>> print a['x']
      3
      >>>
  
  Now I'll show that defaultdict instances have dynamic instance variables,
  just like classic classes:
  
      >>> a.default = -1
      >>> print a["noway"]
      -1
      >>> a.default = -1000
      >>> print a["noway"]
      -1000
      >>> 'default' in dir(a)
      True
      >>> a.x1 = 100
      >>> a.x2 = 200
      >>> print a.x1
      100
      >>> d = dir(a)
      >>> 'default' in d and 'x1' in d and 'x2' in d
      True
      >>> print sortdict(a.__dict__)
      {'default': -1000, 'x1': 100, 'x2': 200}
      >>>
  """
  
  class defaultdict2(dict):
      __slots__ = ['default']
  
      def __init__(self, default=None):
          dict.__init__(self)
          self.default = default
  
      def __getitem__(self, key):
          try:
              return dict.__getitem__(self, key)
          except KeyError:
              return self.default
  
      def get(self, key, *args):
          if not args:
              args = (self.default,)
          return dict.get(self, key, *args)
  
      def merge(self, other):
          for key in other:
              if key not in self:
                  self[key] = other[key]
  
  test_2 = """
  
  The __slots__ declaration takes a list of instance variables, and reserves
  space for exactly these in the instance. When __slots__ is used, other
  instance variables cannot be assigned to:
  
      >>> a = defaultdict2(default=0.0)
      >>> a[1]
      0.0
      >>> a.default = -1
      >>> a[1]
      -1
      >>> a.x1 = 1
      Traceback (most recent call last):
        File "<stdin>", line 1, in ?
      AttributeError: 'defaultdict2' object has no attribute 'x1'
      >>>
  
  """
  
  test_3 = """
  
  Introspecting instances of built-in types
  
  For instance of built-in types, x.__class__ is now the same as type(x):
  
      >>> type([])
      <type 'list'>
      >>> [].__class__
      <type 'list'>
      >>> list
      <type 'list'>
      >>> isinstance([], list)
      True
      >>> isinstance([], dict)
      False
      >>> isinstance([], object)
      True
      >>>
  
  Under the new proposal, the __methods__ attribute no longer exists:
  
      >>> [].__methods__
      Traceback (most recent call last):
        File "<stdin>", line 1, in ?
      AttributeError: 'list' object has no attribute '__methods__'
      >>>
  
  Instead, you can get the same information from the list type
  (the following example filters out the numerous method names
  starting with '_'):
  
      >>> pprint.pprint([name for name in dir(list) if not name.startswith('_')])
      ['append',
       'count',
       'extend',
       'index',
       'insert',
       'pop',
       'remove',
       'reverse',
       'sort']
  
  The new introspection API gives more information than the old one:  in
  addition to the regular methods, it also shows the methods that are
  normally invoked through special notations, e.g. __iadd__ (+=), __len__
  (len), __ne__ (!=). You can invoke any method from this list directly:
  
      >>> a = ['tic', 'tac']
      >>> list.__len__(a)          # same as len(a)
      2
      >>> a.__len__()              # ditto
      2
      >>> list.append(a, 'toe')    # same as a.append('toe')
      >>> a
      ['tic', 'tac', 'toe']
      >>>
  
  This is just like it is for user-defined classes.
  """
  
  test_4 = """
  
  Static methods and class methods
  
  The new introspection API makes it possible to add static methods and class
  methods. Static methods are easy to describe: they behave pretty much like
  static methods in C++ or Java. Here's an example:
  
      >>> class C:
      ...
      ...     @staticmethod
      ...     def foo(x, y):
      ...         print "staticmethod", x, y
  
      >>> C.foo(1, 2)
      staticmethod 1 2
      >>> c = C()
      >>> c.foo(1, 2)
      staticmethod 1 2
  
  Class methods use a similar pattern to declare methods that receive an
  implicit first argument that is the *class* for which they are invoked.
  
      >>> class C:
      ...     @classmethod
      ...     def foo(cls, y):
      ...         print "classmethod", cls, y
  
      >>> C.foo(1)
      classmethod test.test_descrtut.C 1
      >>> c = C()
      >>> c.foo(1)
      classmethod test.test_descrtut.C 1
  
      >>> class D(C):
      ...     pass
  
      >>> D.foo(1)
      classmethod test.test_descrtut.D 1
      >>> d = D()
      >>> d.foo(1)
      classmethod test.test_descrtut.D 1
  
  This prints "classmethod __main__.D 1" both times; in other words, the
  class passed as the first argument of foo() is the class involved in the
  call, not the class involved in the definition of foo().
  
  But notice this:
  
      >>> class E(C):
      ...     @classmethod
      ...     def foo(cls, y): # override C.foo
      ...         print "E.foo() called"
      ...         C.foo(y)
  
      >>> E.foo(1)
      E.foo() called
      classmethod test.test_descrtut.C 1
      >>> e = E()
      >>> e.foo(1)
      E.foo() called
      classmethod test.test_descrtut.C 1
  
  In this example, the call to C.foo() from E.foo() will see class C as its
  first argument, not class E. This is to be expected, since the call
  specifies the class C. But it stresses the difference between these class
  methods and methods defined in metaclasses (where an upcall to a metamethod
  would pass the target class as an explicit first argument).
  """
  
  test_5 = """
  
  Attributes defined by get/set methods
  
  
      >>> class property(object):
      ...
      ...     def __init__(self, get, set=None):
      ...         self.__get = get
      ...         self.__set = set
      ...
      ...     def __get__(self, inst, type=None):
      ...         return self.__get(inst)
      ...
      ...     def __set__(self, inst, value):
      ...         if self.__set is None:
      ...             raise AttributeError, "this attribute is read-only"
      ...         return self.__set(inst, value)
  
  Now let's define a class with an attribute x defined by a pair of methods,
  getx() and setx():
  
      >>> class C(object):
      ...
      ...     def __init__(self):
      ...         self.__x = 0
      ...
      ...     def getx(self):
      ...         return self.__x
      ...
      ...     def setx(self, x):
      ...         if x < 0: x = 0
      ...         self.__x = x
      ...
      ...     x = property(getx, setx)
  
  Here's a small demonstration:
  
      >>> a = C()
      >>> a.x = 10
      >>> print a.x
      10
      >>> a.x = -10
      >>> print a.x
      0
      >>>
  
  Hmm -- property is builtin now, so let's try it that way too.
  
      >>> del property  # unmask the builtin
      >>> property
      <type 'property'>
  
      >>> class C(object):
      ...     def __init__(self):
      ...         self.__x = 0
      ...     def getx(self):
      ...         return self.__x
      ...     def setx(self, x):
      ...         if x < 0: x = 0
      ...         self.__x = x
      ...     x = property(getx, setx)
  
  
      >>> a = C()
      >>> a.x = 10
      >>> print a.x
      10
      >>> a.x = -10
      >>> print a.x
      0
      >>>
  """
  
  test_6 = """
  
  Method resolution order
  
  This example is implicit in the writeup.
  
  >>> class A:    # classic class
  ...     def save(self):
  ...         print "called A.save()"
  >>> class B(A):
  ...     pass
  >>> class C(A):
  ...     def save(self):
  ...         print "called C.save()"
  >>> class D(B, C):
  ...     pass
  
  >>> D().save()
  called A.save()
  
  >>> class A(object):  # new class
  ...     def save(self):
  ...         print "called A.save()"
  >>> class B(A):
  ...     pass
  >>> class C(A):
  ...     def save(self):
  ...         print "called C.save()"
  >>> class D(B, C):
  ...     pass
  
  >>> D().save()
  called C.save()
  """
  
  class A(object):
      def m(self):
          return "A"
  
  class B(A):
      def m(self):
          return "B" + super(B, self).m()
  
  class C(A):
      def m(self):
          return "C" + super(C, self).m()
  
  class D(C, B):
      def m(self):
          return "D" + super(D, self).m()
  
  
  test_7 = """
  
  Cooperative methods and "super"
  
  >>> print D().m() # "DCBA"
  DCBA
  """
  
  test_8 = """
  
  Backwards incompatibilities
  
  >>> class A:
  ...     def foo(self):
  ...         print "called A.foo()"
  
  >>> class B(A):
  ...     pass
  
  >>> class C(A):
  ...     def foo(self):
  ...         B.foo(self)
  
  >>> C().foo()
  Traceback (most recent call last):
   ...
  TypeError: unbound method foo() must be called with B instance as first argument (got C instance instead)
  
  >>> class C(A):
  ...     def foo(self):
  ...         A.foo(self)
  >>> C().foo()
  called A.foo()
  """
  
  __test__ = {"tut1": test_1,
              "tut2": test_2,
              "tut3": test_3,
              "tut4": test_4,
              "tut5": test_5,
              "tut6": test_6,
              "tut7": test_7,
              "tut8": test_8}
  
  # Magic test name that regrtest.py invokes *after* importing this module.
  # This worms around a bootstrap problem.
  # Note that doctest and regrtest both look in sys.argv for a "-v" argument,
  # so this works as expected in both ways of running regrtest.
  def test_main(verbose=None):
      # Obscure:  import this module as test.test_descrtut instead of as
      # plain test_descrtut because the name of this module works its way
      # into the doctest examples, and unless the full test.test_descrtut
      # business is used the name can change depending on how the test is
      # invoked.
      from test import test_support, test_descrtut
      test_support.run_doctest(test_descrtut, verbose)
  
  # This part isn't needed for regrtest, but for running the test directly.
  if __name__ == "__main__":
      test_main(1)
  