Python(作业，class)

"""
1.定义一个类(不限定定义哪个类)：
    要求:a.需要有一个类变量
        b.需要有>=2个的对象变量
	    c.定义一个方法：打印类变量和对象变量
	    d.使用print打印对象->输出为This is a object
	    e.实例化两个对象：且两个对象相加等于2
	    f.为对象添加一个临时变量temp_var
2.定义一个父类：
	要求：包含三个对象变量，且其中一个对象变量使用_命名
          定义一个方法：命名使用__命名
		  定义一个子类继承上边的父类：且定义一个和父类方法名相同的方法(__)
		  实例化子类的对象
		  访问带_的对象变量
		  访问父类中的__xxx方法
		  访问子类中的__xxx方法
3.super的使用:
	定义一个类A, 里面又一个方法print_info
	定义一个类B, 里边有一个方法print_info和一个方法say_something
	定义一个类C, 里边有一个方法say_something
	定义一个类D, 里边有一个方法print_info和一个方法say_something
	定义一个类E,继承类A, 类B, 类C，类D
	实例化类E的对象
	执行print_info和say_something方法
	利用super，让执行print_info时调用B中print_info
	利用super, 让执行say_something时调用C中say_something
	利用super, 让执行print_info和say_something时调用
	    D中print_info和say_something
4.什么是闭包?
  闭包的特征?
  定义闭包，完成的功能为:传入一个数求和并输出
	  例如: 传入10 ->输出10
	        传入15 ->输出25
			传入20 ->输出45
"""

class Person:
    #类变量: 类中，方法外
    count = 0
    # 对象变量： 在__init__中定义
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def print_var(self):
        print(f"class_variable:{self.count}, object_var:{self.name},{self.age}")


    def __str__(self):
        return "This is a object"

    def __repr__(self):
        return "This is a object"

    def __add__(self, other):
        return 2


zhangsan = Person("张三", 18)
print(zhangsan)  #=> str(object) => object.__str__()
lisi = Person("李四", 20)
result = zhangsan + lisi
print(result)
zhangsan.print_var()
zhangsan.temp_var = 10
print(zhangsan.temp_var)


class Parent: # 默认继承了object

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        # 约定他是私有变量
        self._gender = gender

    # 名称转换:
    # 在python解释器规定好的，类中的方法如果是__开始的
    # 那么python解释器会做名称转换: 在方法名前_class
    def __print_info(self):
        print(f"{self.name}-{self.age}-{self._gender}")
    def test(self):
        print(111)

class Son(Parent):

    def __print_info(self):
        print(f"{self.name}-{self.age}-{self._gender}")

    def test(self):
        print(222)

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

son = Son("son", 6, "女")
son._Parent__print_info()
son._Son__print_info()
son.test()

# super的功能：改变继承的顺序
# 产生一个代理对象，然后将原先的调用委托给父类或兄弟类

class A:
    def print_info(self):
        print("This is A object")
    pass
class B:
    def print_info(self):
        print("This is B object")
    def say_something(self):
        print("B is saying")
    pass
class C:
    def say_something(self):
        print("C is saying")
    pass
class D:
    def print_info(self):
        print("This is D object")
    def say_something(self):
        print("D is saying")
    pass

class E(A, B, C, D):
    # def print_info(self):
    #     #self或者E(), 不用传self
    #     super(A, E()).print_info()
    # pass
    # def say_something(self):
    #     super(B, E).say_something(self)
    def print_info(self):
        # self或者E(), 不用传self
        super(C, E()).print_info()

    pass

    def say_something(self):
        super(C, E).say_something(self)
#继承顺序 mro: method resolution order
"""
super([type[, object-or-type]])
# type: 代表了一个类名
# object-or-type: 类或者对象
super(type, object-or-type):
功能
object-or-type: 决定了mro(继承的序列)
     #object对象的类的.__mro__
     #type.__mro__
type: 决定了我们搜索的起始位置从type之后的类开始

type和object-or-type是互相限制的
1. type1, type2 => type2必须是type1的子类
2. type, object => isinstance(type, object)为真

                   object-> e -> E
                   E 必须是type的子类
"""
print(E.__mro__)

e = E()
e.print_info()
e.say_something()

# 利用super，让执行print_info时调用B中print_info

# 利用super, 让执行say_something时调用C中say_something
# 利用super, 让执行print_info和say_something时调用
#	    D中print_info和say_something

"""
什么是闭包: 
嵌套函数
内层函数引用外层函数的变量(自由变量)
在外层函数返回内层函数
作用域

绑定操作: 
函数的形参： 函数的形参
import声明: 
类和函数的定义: 
赋值操作:
for循环首标:
异常捕获中相关的赋值变量:

强调一个东西：绑定操作，一个引用
            绑定操作即是可见的，引用操作即可用的
            引用之前，一定要有绑定操作
         
作用域搜索顺序
 搜索顺序:
    1.最先搜索的最内部作用域包含局部名称(代码块内部的)
    2.从最近的封闭作用域开始搜索的任何封闭函数的作用域包含非局部名称，也包括非全局名称
         离得最近的封闭区域: 上一层代码块
    3.倒数第二个作用域包含当前模块的全局名称
         模块中定义的变量
    4.最外面的作用域（最后搜索）是包含内置名称的命名空间
         python内置的命名空间
   


"""
# data = 0
def outer():
    data = 0
    def inner():
        print(data)
        print(__name__)
        # data = 4
    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)