Python---day9作业

1.定义一个父类：
要求：包含三个对象变量，且其中一个对象变量使用_命名
定义一个方法：命名使用__命名
定义一个子类继承上边的父类：且定义一个和父类方法名相同的方法(__)
实例化子类的对象
访问带_的对象变量
访问父类中的__xxx方法
访问子类中的__xxx方法

class Parent:

    def __init__(self, name, age):
        self.name = name
        self.age = age
        self._gender = "男" # 约定他是私有变量
    def __print_info(self):
        print(self.name, self.age)
    def _print_gender(self):
        print(self._gender)
    def __method1(self):
        print("123")


class Son(Parent):

    def __print_info(self):
        print(self.name, self.age)
    def _print_gender(self):
        print(self._gender)
    def __method1(self):
        print("456")

parent = Parent("zhangsan", 18)
print(parent.name)
print(parent.age)
print(parent._gender)
parent._Parent__method1()

son = Son("son", 6)
son._Parent__print_info()
son._Son__print_info()
son._Son__method1()

zhangsan
18
男
123
son 6
son 6
456

2.什么是闭包?
闭包的特征?
定义闭包，完成的功能为:传入一个数求和并输出
例如: 传入10 ->输出10
传入15 ->输出25
传入20 ->输出45

什么叫闭包？
一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外被执行。
能够读取其他函数内部变量的函数
闭包包含自由(未绑定到特定对象)变量;
这些变量不是在这个代码块内或者任何全局上下文中定义的，而是在定义代码块的环境中定义(局部变量)
闭包一词来源于要执行的代码块和为自由变量提供绑定的计算环境两者的结合
闭包就是可以创建一个独立的环境，每个闭包里面的环境都是独立的，互不干扰。

闭包特征: 
1.嵌套函数
2.内层函数引用了外层函数的变量
3.内层函数作为返回值返回给外层函数
特征2：
自由变量: 既不是局部变量，也不是模块全局变量
         在闭包的时候：内层引用外层函数的变量
保存我们要执行代码的环境
执行的代码块和为自由变量提供绑定的计算环境两者的结合

def outer():
    data = 0
    def inner():
        print(data)
        print(__name__)
    return inner

inner = outer()
inner()

def sum_data():
    result = []
    def inner(value):
        result.append(value)
        print(sum(result))
    return inner

inner = sum_data()
inner(10)
inner(15)
inner(20)

0
__main__
10
25
45

3.定义一个装饰器：打印函数运行花费的时间
你在执行之前获取一个时间
执行函数
在执行函数之后获取一个时间
去求时间差
time模块

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 login():
    time.sleep(1)
    print("login")

login()

1637152883.7294261
login
1.009498119354248

4.定义一个类：
要求：包含一个对象属性，且用_(单下划线)命名的
定义一个类方法(装饰器)
定义一个静态方法(装饰器)
定义委托属性(三个类装饰器): 可以访问_命名的属性的值
可以修改_命名的属性的值
可以删除_命名的属性
执行：
实例一个对象
调用类方法(类和对象两种方式)
调用静态方法(类和对象两种方式)
对象.委托属性
对象.委托属性 = value
del 对象.委托属性

class Today:

    def __init__(self):
        self._data = None

    @staticmethod
    def static_method(*args, **kwargs):
        print("This is static method")

    @classmethod
    def class_method(cls):
        print("This is class method")

    @property   #委托属性data.   property:只能提供访问
    def data(self):
        return self._data

    @data.setter   #委托属性的修改:xxx.setter
    def data(self, value):
        self._data = value

    @data.deleter   #委托属性的删除:xxx.deleter
    def data(self):
        del self._data

today = Today()
#调用静态方法:类.方法/对象.方法
Today.class_method()
Today.static_method()
today.class_method()
today.static_method()

print(today.data)

today.data = "data"
print(today.data)

This is class method
This is static method
This is class method
This is static method
None
data