面向对象进阶

class A:
    pass
class B(A):
    pass
a = A()
b = B()

• isinstance
• 检测对象与类之间的关系
  print(isinstance(a,A))
  print(isinstance(b,A))
  print(isinstance(a,B))

• issubclass
• 检测类与类之间的关系
  print(issubclass(A,B))
  print(issubclass(B,A))

反射

好处一：实现可插拔机制,先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能
好处二：动态导入模块（基于反射当前模块成员）

• 反射:
  使用字符串数据类型的变量名来获取这个变量的值
  就是字符串转化成变量名的一个实现
  三个场景

class BlackMedium:
    feature='Ugly'
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr

    def sell_house(self):
        print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)
    def rent_house(self):
        print('%s 黑中介租房子啦,傻逼才租呢' %self.name)

b1=BlackMedium('万成置地','回龙观天露园')

#检测是否含有某属性
print(hasattr(b1,'name'))
print(hasattr(b1,'sell_house'))

#获取属性
n=getattr(b1,'name')
print(n)
func=getattr(b1,'rent_house')
func()

# getattr(b1,'aaaaaaaa') #报错
print(getattr(b1,'aaaaaaaa','不存在啊'))

#设置属性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.show_name(b1))

#删除属性
delattr(b1,'addr')
delattr(b1,'show_name')
delattr(b1,'show_name111')#不存在,则报错

print(b1.__dict__)

* input
    * 用户输入的如果是a，那么就打印1，如果输入的是b就打印2，如果输入的是name，就打印alex
* 文件
    * 从文件中读出的字符串，想转换成变量的名字
* 网络
    * 将网络传输的字符串转换成变量的名字

• 反射类中的变量 : 静态属性,类方法，静态方法
  getattr(变量名：命名空间，字符串(必须字符串,不是就会报错)：属于一个命名空间内的变量名或者函数名)

• 判断实现
  hasattr(变量名：命名空间，字符串：属于一个命名空间内的变量名)

• 反射对象中的变量

• 反射模块中的变量
  import os # os就是一个模块

• 反射本文件中的变量

import sys
print(sys.modules['__main__'])  # 本文件的命名空间
print(sys.modules[__name__])     # 反射本文件中的变量 固定的使用这个命名空间
print(sys.modules['__main__'].a)
print(getattr(sys.modules[__name__],'a'))   #a是一个变量
obj = getattr(sys.modules[__name__],'Foo')()  #反射一个类实例化一个obj

• setattr(Foo,'School','OLDOBY') # 接受三个参数 命名空间 ‘变量名’ 变量值

• delattr(Foo,'Country') # 接受三个参数 命名空间 ‘变量名’

不是需要程序员定义，本身就存在在类中的方法就是内置方法
内置的方法通常都长这样 ： __名字__
名字 ： 双下方法、 魔术方法、 内置方法
所有的双下方法，都不需要我们直接去调用,都有另外一种自动触发它的语法

• __str__, __repr__

  • __str__
    当你打印一个对象的时候 触发str
    当你使用%s格式化的时候 触发str
    str强转数据类型的时候 触发str

  • __repr__
    repr是str的备胎
    有__str___的时候执行__str__,没有实现__str__的时候，执行 __repr__
    repr(obj)内置函数对应的结果是 __repr__的返回值
    当你使用(%r)格式化的时候 触发repr

class Foo:
    def __str__(self):      #2
        return 'Foo.str'
    def __repr__(self):     #4
        return 'Foo.repr'


class Son(Foo):
    # pass
    def __str__(self):       #1
        return 'Son.str'

    def __repr__(self):
        return 'Son.repr'    #3

s1 = Son()
print(s1)

---

反射总结:

反射 用字符串类型的变量名来获取变量的值

hasattr(命名空间,'变量名')
getattr(命名空间,'变量名')
    类名.静态属性  getattr(类名,'静态属性')
    类名.类方法()  getattr(类名,'类方法')()
    类名.静态方法()  getattr(类名,'静态方法')()

    对象.对象属性  getattr(对象,'对象属性')
    对象.方法()    getattr(对象,'方法')()

    模块名.方法名
    模块名.类名
    模块名.变量
    模块名.函数

    本文件反射
    import sys
    getattr(sys.modules[__name__],'所有定义在这个文件中的名字')
setattr 给命名空间的某一个名字设置一个值
delattr 删除某一个命名空间中变量对应的值

内置方法

不用调用调用这个方法就可以出发这个方法的执行
class Foo:
    def __str__(self):
        return 'abcd'
    def __repr__(self):
        return 'dcba'
obj = Foo()
__str__ ：
    print(obj)
    '%s'%obj
    str(obj)
__repr__  : # 当使用会触发str方法的方式，但是Foo类内部又没有实现__str__方法的时候，都会调用__repr__
    '%r'%obj
    repr(obj)

• __new__
  在init之前，实例化对象的第一步是new创建了一个空间

class Foo:
   def __init__(self):                 # 初始化方法
       print('执行了init')
   def __new__(cls, *args, **kwargs):  # 构造方法
       # object.__new__(cls)
       print('执行了new')
       return object.__new__(cls)
obj = Foo()

new 是小人捏出来了
init 给小人穿衣服

设计模式 常用的23种
java里来的
python
推崇设计模式 java开发
贬低设计模式 纯python开发

单例模式
一个类 只有一个实例的时候 单例模式

class Foo:
    __instance = None
    def __init__(self,name,age):                 # 初始化方法
        self.name = name
        self.age = age
        self.lst = [name]
    def __new__(cls, *args, **kwargs):  # 构造方法
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

obj1 = Foo('alex',20)
obj2 = Foo('egon',22)
print(obj1.lst,obj2.lst)

• __del__:析构方法 ： 在删除这个类创建的对象的时候会先触发这个方法，再删除对象

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.file = open('file',mode = 'w')
    def write(self):
        self.file.write('sjahgkldhgl')
    def __del__(self):    # 析构方法 ： 在删除这个类创建的对象的时候会先触发这个方法，再删除对象
        # 做一些清理工作,比如说关闭文件，关闭网络的链接，数据库的链接
        self.file.close()
        print('执行del了')

f = Foo('alex',20)
print(f)

• __len__

class Foo:
    def __len__(self):
        return 1
obj = Foo()
print(len(obj))

• __eq__
  print(alex == alex2) # alex.eq(alex2)

• __hash__
  1.每次执行hash值都会变化
  2.在一次执行的过程中对同一个值得hash结果总是不变的
  字典为什么寻址快
  dic = {'name':'alex','age':83,'sex':'不详'}
  字典在内存中是如何存储的？
  为什么字典的key必须可hash

hash算法
1.对于相同的值在一次程序的运行中是不会变化的
2.对于不同的值在一次程序的运行中总是不同的