python9

"""
今日作业：
1.定义一个父类：
 要求：包含三个对象变量，且其中一个对象变量使用_命名
          定义一个方法：命名使用__命名
    定义一个子类继承上边的父类：且定义一个和父类方法名相同的方法(__)
    实例化子类的对象
    访问带_的对象变量
    访问父类中的__xxx方法
    访问子类中的__xxx方法
2.什么是闭包?
一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外被执行。
能够读取其他函数内部变量的函数
  闭包的特征?
  1.嵌套函数
2.内层函数引用了外层函数的变量
3.内层函数作为返回值返回给外层函数
特征2：
自由变量: 既不是局部变量，也不是模块全局变量
         在闭包的时候：内层引用外层函数的变量
保存我们要执行代码的环境
执行的代码块和为自由变量提供绑定的计算环境两者的结合
  定义闭包，完成的功能为:传入一个数求和并输出
   例如: 传入10 ->输出10
         传入15 ->输出25
   传入20 ->输出45
3.定义一个装饰器：打印函数运行花费的时间
  你在执行之前获取一个时间
  执行函数
  在执行函数之后获取一个时间
  去求时间差
  time模块
4.定义一个类：
     要求：包含一个对象属性，且用_(单下划线)命名的
        定义一个类方法(装饰器)
     定义一个静态方法(装饰器)
     定义委托属性(三个类装饰器): 可以访问_命名的属性的值
                   可以修改_命名的属性的值
       可以删除_命名的属性
     执行：
     实例一个对象
     调用类方法(类和对象两种方式)
     调用静态方法(类和对象两种方式)
     对象.委托属性
     对象.委托属性 = value
     del 对象.委托属性
"""
#1
class A:
    def say_something(self):
        print("A says something")

class B:
    def print_info(self):
        print("This is B")

class C:

    def say_something(self):
        print("C says something")
    def print_info(self):
        print("This is C")

class D(B):
    pass

class E:
    pass
class G(E, C):
    pass

# A, B, E, C
class F(A, B, G):
    def say_something(self):
        super(E, self).say_something()

f = F()
f.print_info()
f.say_something()
print(F.__mro__)
#2
def sum_outer():
    data_list = []
    def sum_inner(arg):
        data_list.append(arg)
        print(sum(data_list))
    return sum_inner

sum_func = sum_outer()
sum_func(10)
sum_func(20)
#3
import  time

def cost_time(func):
    def inner(*args, **kwargs):
        before_time = time.time()
        func(*args, **kwargs)
        after_time = time.time()
        print(after_time - before_time)
    return  inner
print(time.time())

@cost_time
def timein():
    time.sleep(2)
    print("timein")
timein()

#4
class tody:

    def __init__(self):
        self._data = None
    @staticmethod
    def static_method(*args, **kwargs):
        print("this is staticm")
    @classmethod
    def class_method(cls):
        print("this is classm")

    @property#访问data方法，转为属性：只提供访问：xxx.peoperty
    def data(self):
        return self._data
    @data.setter#委托属性：提供修改：xxx.setter
    def data(self, value):
        self._data = value
    @data.deleter#委托属性：删除：xxx.deleter（xxx根据property决定）
    def data(self):
        del self._data
m = tody()
tody.class_method()
tody.static_method()
m.class_method()
m.static_method()

print(m.data)
m.data = "data"
print(m.data)
#del m.data
#print(m.data)

结果：