Python 3 初探，第 2 部分: 高级主题

def myMethod(self):
    # do something

myMethod = transformMethod(myMethod)

@transformMethod
def myMethod(self):
    # do something

def mod(method):
    method.__name__ = "John"
    return method

@mod
def modMe():
    pass

print(modMe.__name__)

class myClass:
    pass

myClass = doSomethingOrNotWithClass(myClass)

@doSomethingOrNotWithClass
class myClass:
    pass

>>>aClass = type(‘className‘, 
   (object,), 
   {‘magicMethod‘: lambda cls : print("blah blah")})

class meta(type):
    def __new__(cls, className, baseClasses, dictOfMethods):
        return type.__new__(cls, className, baseClasses, dictOfMethods)

>>>class aClass(baseClass1, baseClass2, metaclass = aMetaClass): pass

class Test(object):
    __metaclass__ = type

def meth():
    print("Calling method")

class MyMeta(type):
    @classmethod
    def __prepare__(cls, name, baseClasses):
        return {‘meth‘:meth}

    def __new__(cls, name, baseClasses, classdict):
        return type.__new__(cls, name, baseClasses, classdict)

class Test(metaclass = MyMeta):
    def __init__(self):
        pass

    attr = ‘an attribute‘

t = Test()
print(t.attr)

# The custom dictionary
class member_table(dict):
    def __init__(self):
        self.member_names = []

    def __setitem__(self, key, value):
        # if the key is not already defined, add to the
        # list of keys.
        if key not in self:
            self.member_names.append(key)

        # Call superclass
        dict.__setitem__(self, key, value)

# The metaclass
class OrderedClass(type):
    # The prepare function
    @classmethod
    def __prepare__(metacls, name, bases): # No keywords in this case
        return member_table()

    # The metaclass invocation
    def __new__(cls, name, bases, classdict):
        # Note that we replace the classdict with a regular
        # dict before passing it to the superclass, so that we
        # don‘t continue to record member names after the class
        # has been created.
        result = type.__new__(cls, name, bases, dict(classdict))
        result.member_names = classdict.member_names
        return result

>>>from abc import *
>>>class C(metaclass = ABCMeta): pass
>>>c = C()

>>>from abc import *
>>>class C(metaclass = ABCMeta): 
...    @abstractmethod
...    def absMethod(self):
...        pass
>>>c = C() 
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can‘t instantiate abstract class C with abstract methods absMethod

>>>class B(C):
...    def absMethod(self):
...        print("Now a concrete method")
>>>b = B()
>>>b.absMethod()
Now a concrete method

>>>class TestABC(metaclass=ABCMeta): pass
>>>TestABC.register(list)
>>>TestABC.__instancecheck__([])
True

>>>from collections import Iterable
>>>issubclass(list, Iterable)
True

>>>try:
...    x = float(‘not a number‘)
... except (ValueError, NameError):
...    print "can‘t convert type"

>>> try:
...    x = float(‘not a number‘)
... except ValueError, NameError:
...    print "can‘t convert type"

>>> try:
...    x = float(‘blah‘)
... except ValueError, NameError:
...    print "NameError is ", NameError
...
NameError is invalid literal for float(): not a number

# bind ValueError object to local name ex
try:
    x = float(‘blah‘)
except ValueError as ex:
    print("value exception occurred ", ex)
 
# catch two different exceptions simultaneously
try:
    x = float(‘blah‘)
except (ValueError, NameError):
    print("caught both types of exceptions")

def divide(a, b):
    try:
        print(a/b)
    except Exception as exc:
        def log(exc):
        fid = open(‘logfile.txt‘) # missing ‘w‘
        print(exc, file=fid)
        fid.close()

        log(exc)

divide(1,0)

Traceback (most recent call last):
  File "chainExceptionExample1.py", line 3, in divide
  print(a/b)
ZeroDivisionError: int division or modulo by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "chainExceptionExample1.py", line 12, in <module>
    divide(1,0)
  File "chainExceptionExample1.py", line 10, in divide
    log(exc)
  File "chainExceptionExample1.py", line 7, in log
    print(exc, file=fid)
  File "/opt/python3.0/lib/python3.0/io.py", line 1492, in write
    self.buffer.write(b)
  File "/opt/python3.0/lib/python3.0/io.py", line 696, in write
    self._unsupported("write")
  File "/opt/python3.0/lib/python3.0/io.py", line 322, in _unsupported
    (self.__class__.__name__, name))
io.UnsupportedOperation: BufferedReader.write() not supported

>>> raise EXCEPTION from CAUSE

>>>exception = EXCEPTION
>>>exception.__cause__ = CAUSE
>>>raise exception

class CustomError(Exception): 
    pass

try:
    fid = open("aFile.txt") # missing ‘w‘ again
    print("blah blah blah", file=fid)
except IOError as exc:
    raise CustomError(‘something went wrong‘) from exc

Traceback (most recent call last):
  File "chainExceptionExample2.py", line 5, in <module>
    fid = open("aFile.txt")
  File "/opt/python3.0/lib/python3.0/io.py", line 278, in __new__
    return open(*args, **kwargs)
  File "/opt/python3.0/lib/python3.0/io.py", line 222, in open
    closefd)
 File "/opt/python3.0/lib/python3.0/io.py", line 615, in __init__
    _fileio._FileIO.__init__(self, name, mode, closefd)
IOError: [Errno 2] No such file or directory: ‘aFile.txt‘

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
File "chainExceptionExample2.py", line 8, in <modulei>
  raise CustomError(‘something went wrong‘) from exc
__main__.CustomError: something went wrong

from traceback import format_tb

try:
    1/0
except Exception as exc:
    print(format_tb(exc.__traceback__)[0])

>>>0o13
11

>>>0b010101
21

def methodName(param1: expression1, ..., paramN: expressionN)->ExpressionForReturnType:
    ...

def execute(program:"name of program to be executed", error:"if something goes wrong"):
    ...

def getName() -> "isString":
     ...