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__方法

巴特西

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

最新文章

热门文章