Python装饰器AOP 不定长参数 鸭子类型 重载(三)

            
                def print_info(name, age =18，gender =True )
print_info("zhan", gender =False )

def demo(num, *nums ,**nums )
        

            
                >>>
                def print_everything(*args):
        for count, thing inenumerate(args):
...         print‘{0}. {1}‘.format(count, thing)
...
>>> print_everything(‘apple‘, ‘banana‘, ‘cabbage‘)
0. apple
1. banana
2. cabbage
        

            
                >>>
                def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print‘{0} = {1}‘.format(name, value)
...
>>> table_things(apple =‘fruit‘, cabbage =‘vegetable‘)
cabbage = vegetable
apple = fruit
        

            
                >>>
                def myPrint(a, b, c):
...     print‘a = {0}, b = {1}, c = {2}‘.format(a,b,c)
...
>>> mylist = [‘aardvark‘, ‘baboon‘, ‘cat‘]
>>> myPrint(*mylist)

a = aardvark, b = baboon, c = cat
        

            
                def makebold(fn):
    def wrapped():
        return"<b>"+ fn() +"</b>"return wrapped

def makeitalic(fn):
    def wrapped():
        return"<i>"+ fn() +"</i>"return wrapped

@makebold@makeitalicdef hello():
    return"hello world"print hello() ## returns <b><i>hello world</i></b>#通过两个装饰器实现对目标函数的包装
        

            
                def bread(func):
    def wrapper():
        print"</‘‘‘‘‘‘\>"
        func()
        print"<\______/>"return wrapper

def ingredients(func):
    def wrapper():
        print"#tomatoes#"
        func()
        print"~salad~"return wrapper

def sandwich(food="--ham--"):
    print food

sandwich()
#outputs: --ham--
sandwich = bread(ingredients(sandwich))  #装饰器实际就是函数调用
sandwich()

#输出:#</‘‘‘‘‘‘\># #tomatoes## --ham--# ~salad~#<\______/>
        

            
                @bread
                @ingredients
                def sandwich(food="--ham--"):
    print food

sandwich()
#输出:  是不是觉得简单很多啦!#</‘‘‘‘‘‘\># #tomatoes## --ham--# ~salad~#<\______/>#改变顺序会有影响的,执行顺序是先里面@ingredients,在执行@bread
        

            
                def a_decorator_passing_arguments(function_to_decorate):
    def a_wrapper_accepting_arguments(arg1, arg2):
        print"I got args! Look:", arg1, arg2
        function_to_decorate(arg1, arg2)
    return a_wrapper_accepting_arguments

# 当你调用装饰器返回的函数时,也就调用了包装器,把参数传入包装器里,# 它将把参数传递给被装饰的函数里.@a_decorator_passing_argumentsdef print_full_name(first_name, last_name):
    print"My name is", first_name, last_name

print_full_name("Peter", "Venkman")
# 输出:#I got args! Look: Peter Venkman#My name is Peter Venkman
        

            
                def method_friendly_decorator(method_to_decorate):
    def wrapper(self, lie):
        lie = lie -3# 女性福音 :-)return method_to_decorate(self, lie)
    return wrapper

class Lucy(object):
    def__init__(self):
        self.age =32@method_friendly_decorator#装饰类方法def sayYourAge(self, lie):
        print"I am %s, what did you think?"% (self.age + lie)

l = Lucy()
l.sayYourAge(-3)
#输出: I am 26, what did you think?
        

            
                def decorator_maker_with_arguments(decorator_arg1, decorator_arg2):
    print("I make decorators! And I accept arguments:", decorator_arg1, decorator_arg2)
    def my_decorator(func):
        print("I am the decorator", decorator_arg1, decorator_arg2)
        # 不要忘了装饰器参数和函数参数!def wrapped(function_arg1, function_arg2) :
            print ("\t- from the decorator: {0}{1}\n""\t- from the function call: {2} {3}\n""Then I can pass them to the decorated function"
                  .format(decorator_arg1, decorator_arg2,
                          function_arg1, function_arg2))
            return func(function_arg1, function_arg2)
        return wrapped
    return my_decorator

@decorator_maker_with_arguments("Leonard", "Sheldon")
def decorated_function_with_arguments(function_arg1, function_arg2):
    print ("I am the decorated function and only knows about my arguments: {0}"" {1}".format(function_arg1, function_arg2))

decorated_function_with_arguments("Rajesh", "Howard") #调用函数#输出:#I make decorators! And I accept arguments: Leonard Sheldon#I am the decorator. Leonard Sheldon#   - from the decorator: Leonard Sheldon#   - from the function call: Rajesh Howard#Then I can pass them to the decorated function#I am the decorated function and only knows about my arguments: Rajesh Howard
        

            
                class duck():
  def walk(self):
    print(‘I walk like a duck‘)
  def swim(self):
    print(‘i swim like a duck‘)
 
class person():
  def walk(self):
    print(‘this one walk like a duck‘) 
  def swim(self):
    print(‘this man swim like a duck‘)
    
def watch_duck(animal): #定义一个函数,接受animal参数,需要具有walk swim两项本领
  animal.walk()
  animal.swim()
 
small_duck = duck()  #实例化鸭子
watch_duck(small_duck) #能调用就认为是鸭子类型
输出 >> 
I walk like a duck
i swim like a duck
 
duck_like_man = person() #实例化人,但是人同样有walk swim方法
watch_duck(duck_like_man) #同样被认为是鸭子类型
输出 >> 
this one walk like a duck
this man swim like a duck
 
class Lame_Foot_Duck():
  def swim(self):
    print(‘i am lame but i can swim‘)
 
lame_duck = Lame_Foot_Duck() #实例化蹩脚的鸭子,类下只具有swim方法
watch_duck(lame_duck)  #虽然是鸭子,但是不被认为是鸭子类型
 
输出 >>AttributeError: Lame_Foot_Duck instance has no attribute ‘walk‘
        

            
                class Write:
    @staticmethoddef write(output,content):
        #output对象只要实现write方法,不管接受的类型
        output.write(content)
#stringIO类型
output = StringIO.StringIO()
Write.write(output,‘helloworld‘)

#file类型
output =open(‘out.txt‘,‘w‘)
Write.write(output,‘helloworld‘)