Python9-反射-day27（大年初三）

复习

class 类名(父类,父类2):
    静态属性 = ''   #静态属性  类属性
    def __init__(self):   #初始化方法
        self.name = 'alex'
    def func(self):
       print(self,age)    #动态属性 方法
对象  = 类名()
对象.方法名（）
对象.属性名
对象.name
对象.age = 18
对象.func()
组合：表达的是什么有什么  *****
    一个类的属性是另外一个类的对象
命名空间：类和对象分别存在不同的命名空间中
面向对象的三大特性：继承、多态、封装
继承：单继承 ：****
              父类（超类、基类）
              子类（派生类）：派生方法和派生属性，
              子类的对象在调用方法和属性：先用自己的，自己没有才用父类的
      多继承：***（面试）
            不会超过三个父类，不要超过三层  ***
            如果子类自己有用自己的，如果没有就用离子类最近的那个父类的方法
        抽象类和接口类**
    经典类和新式类：继承规则不同，深度优先和广度优先 *****（面试）
    super 只能在python3中使用  ****
        super是根据mro广度优先顺序找上一个类
多态 ***：（面试）
        多态和鸭子类
封装：（面试）
    私有的  __名字
    只能在类的内部调用，子类都无法继承
三个装饰器
        @property       ****
        @staticmethod  ***
        @classmethod   *****当一个方法只使用了类的静态变量时，就给这个方法加上@classmethod装饰器，默认传cls参数

'''

class Teacher:
    pass
class Course:
 def __init__(self,name,price,period):
    self.name = name
    self.price = price
    self.period = period
python = Course('python',19800,'6 months')
class Classes:
    def __init__(self,name,course,teacher,school):
        self.name = name
        self.course = course
        self.teacher = teacher
        self.school = school
pys9 = Classes('pytho_s9',python,'tim','oldboy')
print(pys9.course.name)
python.name = 'python全栈'
print(pys9.course.name)

# isinstance和issubclass
# isinstance(obj,cls)检查是否obj是否是类 cls 的对象
# class A:
#     pass
# a = A()
# print(isinstance(a,A))
# issubclass(sub, super)检查sub类是否是 super 类的派生类
# class A:
#     pass
# class B(A):pass
# a = A()
# print(issubclass(B,A))

# 反射：是用字符串类型的名字去操作变量
# 反射就没有安全问题
# 反射对象中的属性和方法  hasattr  getattr  setattr delatter
# class A:
#     def func(self):
#         print('in func')
# a = A()
# a.name = 'alex'
# a.age = 64
# 反射对象的属性
# ret = getattr(a,'name')  #通过变量名的字符串形式取到的值
# get = input('>>>>>>')
# print(getattr(a,get))
# print(a.__dict__[get])
# 反射对象里的方法
# ret = getattr(a,'func')
# ret()

class A:
    price = 20
    def func(self):
        print('in func')

# 反射类的属性
print(getattr(A,'price'))

# 反射类的方法：classmethod  staticmethod
# 类名.方法名
class A:
    price = 20
    @classmethod
    def func(cls):
        print('in func')
print(getattr(A,'func'))
ret = getattr(A,'func')
ret()

# 模块
# 反射模块的属性
import my
# print(my.day)
print(getattr(my,'day'))

# 反射模块的方法
ret = getattr(my,'wahaha')
ret()

# 反射自己的模块中的变量
# year = 2019
# import  sys
# print(sys.modules['__main__'])
# def qqxing():
#     print('qqxing')
# print(getattr(sys.modules['__main__'],'year'))

# 反射自己模块中的方法或函数
# print(getattr(sys.modules['__main__'],'qqxing'))
# ret = getattr(sys.modules['__main__'],'qqxing')
# ret()
#
# get = input('>>>>>>> ')
# print(getattr(sys.modules['__main__'],get))
# print(getattr(sys.modules[__name__],get))
# 一个模块中的类能不能反射的到
# import my
# print(getattr(my,'C')())
# if hasattr(my,'name'):
#     getattr(my,'name')

# setattr() 设置修改变量
class A:
    pass
a = A()
setattr(A,'name','tim')
setattr(a,'name','gim')
print(A.name)
print(a.name)

# delattr()删除一个变量
delattr(a,'name')
print(a.name)

# obj.__str__

# 内置的类方法和内置的函数之间有着千丝万缕的联系
class Teacher:
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
    def __str__(self):
        return "Teacher's object : %s"%self.name
# a = A()
nezha = Teacher('哪吒',250)
print(nezha)
# print(a)    #打印一个对象的时候，就是调用a.__str__
# object 有个双下str，一旦被调用，就返回调用这个方法的内存地址
# print('%s:%s'%('A',a))   #%s  str()  直接打印  实际上都是走__str__
Teacher's object : 哪吒

# %s str()  直接打印  实际都是走__str__
# %r repr()  直接打印  实际都是走__repr__   repr是str的备胎，反过来不行

# obj.__repr__
class Teacher:
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
    def __str__(self):
        return "Teacher's object : %s"%self.name
    def __repr__(self):
        return str(self.__dict__)
# a = A()
nezha = Teacher('哪吒',250)
print(nezha)
print(repr(nezha))
print('>>>>>%r'%nezha)

# %s str()  直接打印  实际都是走__str__
# %r repr()  直接打印  实际都是走__repr__   repr是str的备胎，反过来不行（str不能做repr的备胎）

#str（obj）的时候，实际上是内部调用了obj.__str__方法，如果str方法有返回值，那么他返回的必定是一个字符串
#如果没有__str__方法，会先找本类中的__repr__方法，在没有再找父类中的__str__

# __del__
class A:
    def __del__(self):
        print('执行我拉')
a = A()
del a   #del 既执行了这个方法，又删除了变量，
print(a)

# __call__
class A:
    def __init__(self,name):
        pass
    def __call__(self):
        print('执行我了')
a  =  A('tim')
a()     #相当于执行了__call__方法