python programming

python Singleton  

1.  Python __call__ special method practical example

instantiate a class: x = Foo() is really x = type(Foo).__call__(Foo), where __call__ is defined by the metaclass of Foo

2.  use call to implement Singleton

class _Singleton(type):
    """ A metaclass that creates a Singleton base class when called. """
    _instances = {}
    print("_instances")
    def __call__(cls, *args, **kwargs):
        ins = cls._instances.get(cls)
        print("class is:", cls, "instance is:", ins, args, kwargs)
        if not ins or (hasattr(ins, "_reset") and isinstance(ins, cls)
                and ins._reset()):
            cls._instances[cls] = super(
                    _Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Singleton(_Singleton('SingletonMeta', (object,), {})):
    print"Singleton"
    def __init__(self, *args, **kwargs):
        print("Singleton __init__", args, kwargs)

class Logger(Singleton):
    print"Logger"
    def __init__(self, *args, **kwargs):
        print("Logger __init__")
        print(args, kwargs)
    def _reset(self, *args, **kwargs):
        print("Logger _reset")
        print(args, kwargs)
        return True

print("Type is:", type(Logger))
print(dir(type(Logger)))
l = Logger("hello")
l = Logger("world")

Python classmethod()

__new__, __init__, __call__  

简述 __init__、__new__、__call__ 方法  

3.  Creating a singleton in Python

Method 2: A base class

class Singleton(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):
    pass

　　

 decorators

1. decorators with parameters

from functools import wraps

def decorator(argument):
    def real_decorator(function):
        @wraps(function)
        def wrapper(*args, **kwargs):
            funny_stuff()
            something_with_argument(argument)
            retval = function(*args, **kwargs)
            more_funny_stuff()
            return retval
        return wrapper
    return real_decorator

　　

2. Python class method decorator with self arguments

#/usr/bin/env python3
from functools import wraps

def wrapper(method):
    @wraps(method)
    def _impl(self, *method_args, **method_kwargs):
        method_output = method(self, *method_args, **method_kwargs)
        return method_output + "!"
    return _impl

class Foo:
    @wrapper
    def bar(self, word):
        return word

f = Foo()
result = f.bar("kitty")
print(result)

traceback

1. python3 org

2. Extract traceback info from an exception object

web development

我的爱家租房项目

 

exercise

二叉树遍历：

class T(object):
    def __init__(self, data=None, left=None, right=None):
       self.data = data
       self.left = left
       self.right = right

#         1
#       /   
#      /     
#     2      3
#   /      /  
#  4    5  6    7

n4 = T(4)
n5 = T(5)
n6 = T(6)
n7 = T(7)
n2 = T(2, n4, n5)
n3 = T(3, n6, n7)
n1 = T(1, n2, n3)


def preOrder(n):
    if not n:
        return
    print(n.data, end=" ")
    preOrder(n.left)
    preOrder(n.right)

print("PreOrder:")
preOrder(n1)

def inOrder(n):
    if not n:
        return
    inOrder(n.left)
    print(n.data, end=" ")
    inOrder(n.right)

print("
inOrder:")
inOrder(n1)

def PostOrder(n):
    if not n:
        return
    PostOrder(n.left)
    PostOrder(n.right)
    print(n.data, end=" ")

print("
postOrder:")
PostOrder(n1)
print()

print("*" * 20)

def preOrderStack(n):
    if not n:
        return
    a = [n]
    cur = n
    while (a):
        cur = a.pop()
        print(cur.data, end=" ")
        if cur.right:
            a.append(cur.right)
        if cur.left:
            a.append(cur.left)

print("PreOrderStack:")
preOrderStack(n1)
print()

def inOrderStack(n):
    if not n:
        return
    a = []
    cur = n
    while (a or cur):
        while(cur):
            a.append(cur)
            cur = cur.left
        node = a.pop()
        print(node.data, end=" ")
        cur = node.right

print("InOrderStack:")
inOrderStack(n1)
print()

def postOrderStack(n):
    if not n:
        return
    a = [n]
    h = n
    cur = None
    while (a):
        c = a[-1]
        if (c.left and h !=c.left and h !=c.right):
            a.append(c.left)
        elif (c.right and h != c.right):
            a.append(c.right)
        else:
            node = a.pop()
            print(node.data, end=" ")
            h = c

print("PostOrderStack:")
postOrderStack(n1)
print()



def levelOrder(n):
    if not n:
        return
    a = [n]
    while (a):
        c = a.pop(0)
        print(c.data, end=" ")
        if (c.left):
            a.append(c.left)
        if (c.right):
            a.append(c.right)

print("levelOrder:")
levelOrder(n1)
print()