Your IP : 216.73.216.213

Current Path : /opt/alt/python33/lib64/python3.3/test/__pycache__/
Upload File :
Current File : //opt/alt/python33/lib64/python3.3/test/__pycache__/test_descrtut.cpython-33.pyc

�
��f.c@s=ddlmZddlZGdd�de�ZdZGdd�de�ZdZd	Zd
Z	dZ
dZGd
d�de�Z
Gdd�de
�ZGdd�de
�ZGdd�dee�ZdZdZied6ed6ed6e	d6e
d6ed6ed6ed6Zddd �Zed!kr9ed"�ndS(#i(usortdictNcBsG|EeZdZd	dd�Zdd�Zdd�Zdd�Zd	S(
udefaultdictcCstj|�||_dS(N(udictu__init__udefault(uselfudefault((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyu__init__s
udefaultdict.__init__cCs4ytj||�SWntk
r/|jSYnXdS(N(udictu__getitem__uKeyErrorudefault(uselfukey((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyu__getitem__s
udefaultdict.__getitem__cGs(|s|jf}ntj|||�S(N(udefaultudictuget(uselfukeyuargs((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyugetsudefaultdict.getcCs2x+|D]#}||kr||||<qqWdS(N((uselfuotherukey((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyumerges
udefaultdict.mergeN(u__name__u
__module__u__qualname__uNoneu__init__u__getitem__ugetumerge(u
__locals__((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyudefaultdictsudefaultdictu�

Here's the new type at work:

    >>> print(defaultdict)              # show our type
    <class 'test.test_descrtut.defaultdict'>
    >>> print(type(defaultdict))        # its metatype
    <class '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():

    >>> print(sorted(a.keys()))
    [1, 2]
    >>> a['print'] = print              # need the print function here
    >>> exec("x = 3; print(x)", a)
    3
    >>> print(sorted(a.keys(), key=lambda x: (str(type(x)), x)))
    [1, 2, '__builtins__', 'print', '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}
    >>>
cBsP|EeZdZdgZd
dd�Zdd�Zdd�Zdd	�Zd
S(udefaultdict2udefaultcCstj|�||_dS(N(udictu__init__udefault(uselfudefault((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyu__init__is
udefaultdict2.__init__cCs4ytj||�SWntk
r/|jSYnXdS(N(udictu__getitem__uKeyErrorudefault(uselfukey((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyu__getitem__ms
udefaultdict2.__getitem__cGs(|s|jf}ntj|||�S(N(udefaultudictuget(uselfukeyuargs((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyugetssudefaultdict2.getcCs2x+|D]#}||kr||||<qqWdS(N((uselfuotherukey((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyumergexs
udefaultdict2.mergeN(	u__name__u
__module__u__qualname__u	__slots__uNoneu__init__u__getitem__ugetumerge(u
__locals__((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyudefaultdict2fs
	udefaultdict2u�

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'
    >>>

u

Introspecting instances of built-in types

For instance of built-in types, x.__class__ is now the same as type(x):

    >>> type([])
    <class 'list'>
    >>> [].__class__
    <class 'list'>
    >>> list
    <class 'list'>
    >>> isinstance([], list)
    True
    >>> isinstance([], dict)
    False
    >>> isinstance([], object)
    True
    >>>

You can get the information from the list type:

    >>> pprint.pprint(dir(list))    # like list.__dict__.keys(), but sorted
    ['__add__',
     '__class__',
     '__contains__',
     '__delattr__',
     '__delitem__',
     '__dir__',
     '__doc__',
     '__eq__',
     '__format__',
     '__ge__',
     '__getattribute__',
     '__getitem__',
     '__gt__',
     '__hash__',
     '__iadd__',
     '__imul__',
     '__init__',
     '__iter__',
     '__le__',
     '__len__',
     '__lt__',
     '__mul__',
     '__ne__',
     '__new__',
     '__reduce__',
     '__reduce_ex__',
     '__repr__',
     '__reversed__',
     '__rmul__',
     '__setattr__',
     '__setitem__',
     '__sizeof__',
     '__str__',
     '__subclasshook__',
     'append',
     'clear',
     'copy',
     '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.
u�

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 <class 'test.test_descrtut.C'> 1
    >>> c = C()
    >>> c.foo(1)
    classmethod <class 'test.test_descrtut.C'> 1

    >>> class D(C):
    ...     pass

    >>> D.foo(1)
    classmethod <class 'test.test_descrtut.D'> 1
    >>> d = D()
    >>> d.foo(1)
    classmethod <class '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 <class 'test.test_descrtut.C'> 1
    >>> e = E()
    >>> e.foo(1)
    E.foo() called
    classmethod <class '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).
u-

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
    <class '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
    >>>
up

Method resolution order

This example is implicit in the writeup.

>>> class A:    # implicit new-style 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):  # explicit new-style 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()
cBs |EeZdZdd�ZdS(uAcCsdS(NuA((uself((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyum�suA.mN(u__name__u
__module__u__qualname__um(u
__locals__((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyuA�suAcs&|EeZdZ�fdd�Z�S(uBcsdtt|�j�S(NuB(usuperuBum(uself(u	__class__(u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyum�suB.m(u__name__u
__module__u__qualname__um(u
__locals__((u	__class__u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyuB�suBcs&|EeZdZ�fdd�Z�S(uCcsdtt|�j�S(NuC(usuperuCum(uself(u	__class__(u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyum�suC.m(u__name__u
__module__u__qualname__um(u
__locals__((u	__class__u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyuC�suCcs&|EeZdZ�fdd�Z�S(uDcsdtt|�j�S(NuD(usuperuDum(uself(u	__class__(u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyum�suD.m(u__name__u
__module__u__qualname__um(u
__locals__((u	__class__u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyuD�suDuD

Cooperative methods and "super"

>>> print(D().m()) # "DCBA"
DCBA
u@

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()
called A.foo()

>>> class C(A):
...     def foo(self):
...         A.foo(self)
>>> C().foo()
called A.foo()
utut1utut2utut3utut4utut5utut6utut7utut8cCs*ddlm}m}|j||�dS(Ni(usupportu
test_descrtut(utestusupportu
test_descrtuturun_doctest(uverboseusupportu
test_descrtut((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyu	test_main�su	test_mainu__main__i(utest.supportusortdictupprintudictudefaultdictutest_1udefaultdict2utest_2utest_3utest_4utest_5utest_6uobjectuAuBuCuDutest_7utest_8u__test__uNoneu	test_mainu__name__(((u7/opt/alt/python33/lib64/python3.3/test/test_descrtut.pyu<module>s4V)WFJ#