python9

“”"
1.定义一个父类：
要求：包含三个对象变量，且其中一个对象变量使用_命名
定义一个方法：命名使用__命名
定义一个子类继承上边的父类：且定义一个和父类方法名相同的方法(__)
实例化子类的对象
访问带_的对象变量
访问父类中的__xxx方法
访问子类中的__xxx方法
“”"
class Parent:
def __method1(self): # __method1 => _Parent__method1
print(“123”)

class Son(Parent):
def __method1(self): # __method1 => _Son__method1
print(“456”)

子类son从父类继承: _Parent__method1,

子类中有两个方法: _Parent__method1, _Son__method1

son = Son()
son._Son__method1()
son._Parent__method1()

“”"
2.什么是闭包?
一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外被执行。能够读取其他函数内部变量的函数
闭包的特征?
1.嵌套函数
2.内层函数引用了外层函数的变量
3.内层函数作为返回值返回给外层函数

“”"
“”"
定义闭包，完成的功能为:传入一个数求和并输出
例如: 传入10 ->输出10
传入15 ->输出25
传入20 ->输出45
“”"
def sum_outer():
data_list = []
def sum_inner(arg):
data_list.append(arg)
print(sum(data_list)) # sum(iterable) => 计算可迭代对象中所有元素的和
return sum_inner

sum_func = sum_outer()
sum_func(10)
sum_func(15)
sum_func(20)
“”"
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())

“”"
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 set_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.set_data = “data”
print(today.data)