2017-10-29-09多继承，类的特殊方法，装饰器笔记

##02多继承，类的特殊方法，装饰器

1.多继承

class Base:
    def play(self):
        print('这是Base')

class A(Base):
    def play(self):
        print('这是A')
        
class B(Base):
    def play(self):
        print('这是B')
        

class C(B,A):
    #子类调用父类的方法
    def play(self):
        #A.play(self)#第一种方法
        #super().play()#第二种方法，默认调用第一个父类的方法
        #super(C,self).play()#括号不写，默认(C,self)

        super(A,self).play()
        super(B,self).play()
        super(C,self).play()
        print('这是C')
        
c=C()

##输出
>>> c.play()
这是Base
这是A
这是B
这是C
>>> 

super, 上一层

1.super（）， （自己类名，自己实例） 例：（ C，c ）

2.谁调用我，我就以你为基准。 建立一张调用顺序表

‘(B,A) C -> B -> A -> Base ->object ’

2.类的特殊方法 (魔法方法)

不仅仅是属性，更多是方法

class Rectangle:
  '''
    这是计算长方形的面积的
    '''
  eye=2
    def __init__(self,length,width):
        if isinstance(length,(int,float)) and isinstance(
            width,(int,float)):
            self.length=length
            self.width=width
        else:
            print('请输入int or float类型')
    def area(self):
        return self.length*self.width
    def __str__(self):
        return '这个长方形的面积%s'%(self.area())
    def __repr__(self):
        return '长:%s 宽:%s'
      (self.length,self.width)
    def __call__(self):
        return  '我是一个Rectangle类，你要干嘛'

r = Rectangle(2,3)

#__dict__
>>> r.__dict__	#打印实例里面的属性
{'length': 2, 'width': 3}
>>>

注意  ,共有属性。当不修改时，默认引用（源类 Rectangle ）

# 修改之后，就会定义在 实例里面
>>> r.__dict__
{'length': 2, 'width': 3}
>>> r.eye
2
>>> r.eye=3
>>> r.__dict__
{'length': 2, 'width': 3, 'eye': 3}
>>> 
#__doc__就是函数：冒号后面跟的通三引号括起来的说明
#r.__doc__
>>> r.__doc__
'\n    这是计算长方形的面积的\n    '
>>> 

>>> print(r)	#对应def __str__
这个长方形的面积6
>>> 
============== RESTART: E:/开发工具/作业/xxxx.py ==============
>>> r		#对应def __repr__
长:2 宽:3

#print 默认调用__str__,没有时调用__repr__

>>> r()
'我是一个Rectangle类，你要干嘛'
>>> 
#添加def __add__(self,other):
        return self.area()+other.area()
        之前
>>> r1=Rectangle(2,3)
>>> r2=Rectangle(3,2)
>>> r1+r2
Traceback (most recent call last):
  File "<pyshell#53>", line 1, in <module>
    r1+r2
TypeError: unsupported operand type(s) for +: 'Rectangle' and 'Rectangle'
>>> 
#添加def __add__(self,other):
        return self.area()+other.area()
        之后
>>> r1=Rectangle(2,3)
>>> r2=Rectangle(3,2)
>>> r1+r2
12
__add__(self,other)
__sub__(self,other)     #x-y

delattr() # 删除对象属性

getattr() # 得到某个属性值

setattr() # 给对象添加某个属性值

hasattr() # 判断对象object是否包含名为name的特性

isinstance() # 检查对象是否是类的对象，返回True或False

issubclass() # 检查一个类是否是另一个类的子类。返回True或Fals

###3.装饰器 ,添加附加功能

装饰器接收一个功能，提那家一些功能并返回。

Python有一个简化的语法。

可以用 @ 符号和装饰函数的名称，并将其放在要装饰的函数的定义之上。l

例如:

@make_pretty
def ordinary():
	print('i am oridinary')

上面代码相当于

def oridinary():
	print('i am oridinary')
oridinary=make_pretty(oridinaty)

函数可以作为参数传递给另一个函数。

将其他函数作为参数的函数也称为高阶函数。

举例

def inc(x):
	return x+1
	
def dec(x):
	return x-1
	
def operate(func,x):
	result=func(x)
	return result

def fx(x):
    x+=1
    def fy(y):
        return x*y

    return fy

def f1(func):
    print('f1 running')
    def f2(y):
        print('f2 running')
        return func(y)+1
    return f2
@f1
def gun(m):
    print('gun running')
    return m*m

1. @f1 -> f1( gun2 ) -> f2
2. f2 ,等待调用
3. gun2 (5) -> 当参数 5传入 --> f2(5)
4. f2(5), 开始运行 -> print(‘f2 running’) -> func(y)： func = gun2 y = 5 ->{{func(y) 等于 gun2（5）}}
5. gun2(5) 开始运行 -> print(‘gun running’) -> 25
6. 25 +1 -> 26

##测试时间

import time 

def run_time(func):
	def new_fun(*args,**kwargs):
		t0 = time.time()
		print('star time: %s'%(time.strftime('%x',time.localtime())) )
		back = func(*args,**kwargs)
		print('end time: %s'%(time.strftime('%x',time.localtime())) )
		print('run time: %s'%(time.time() - t0))
		return back
	return new_fun

>>> @run_time
def test():
	for i in range(1,10):
		for j in range(1,i+1):
			print('%dx%d=%d'%(j,i,i*j),end=' ')
		print()

		
>>> test()
star time: 11/02/17
1x1=1 
1x2=2 2x2=4 
1x3=3 2x3=6 3x3=9 
1x4=4 2x4=8 3x4=12 4x4=16 
1x5=5 2x5=10 3x5=15 4x5=20 5x5=25 
1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 
1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 
1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 
1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81 
end time: 11/02/17
run time: 0.23501372337341309

留个映像，用的不是很多

类装饰器

class Test_Class():
	def __init__(self,func):
    	self.func = func

	def __call__(self):
    	print('类')
    	return self.func
@Test_Class
def  fun_test():
	print('这是一个测试')
fun_test()

fun_test()()

###python自带3个，类的内置装饰器

class Rectangle:
	'''这是一个长方形类，它可以计算面积'''
	aaa = 1
	def __init__(self,length,width):
    #构造方法
    	if isinstance(length,(int,float)) and 		isinstance(width,(int,float)):
        self.length = length
        self.width = width
    	else:
    		print('请输入int or float')


def area(self):
    return self.length * self.width
def func():
    print('可以调用吗？')
def show(cls):
    print(cls)
    print('show fun')
 
 r = Rectangle(2,3)
@property  # 可以把方法，当成属性一样调用r.area
@staticmethod   #静态方法, 不用self了，实例可以直接调用r.func()
@classmethod   #将实例，还原成了类class  self实例