【0903 | Day 29】反射和内置方法

目录

绑定方法和非绑定方法

总结：

  • @classmethod 是个装饰器，放在类中函数的上面，该函数就变成了类的绑定方法

  • 类的绑定方法由类来调用，自动把类传过去(对象也可以调,一般不用)

  • 类的绑定方法一般用在不需要通过对象，只需要通过类就能完成某些事的时候，该方法定义为类的绑定方法

一、绑定方法

绑定方法：绑定给谁就由谁调用，并且将自身传入

  • 类的绑定方法：类中使用 @classmethod 修饰的方法就是绑定到类的方法。这类方法专门为类定制

    class Operate_database():
    host = '192.168.0.5'
    port = '3306'
    user = 'abc'
    password = '123456'

    @classmethod
    def connect(cls):  # 约定俗成第一个参数名为cls，也可以定义为其他参数名
        print(cls)
        print(cls.host + ':' + cls.port + ' ' + cls.user + '/' + cls.password)


==>>> Operate_database.connect()

#<class '__main__.Operate_database'>
#192.168.0.5:3306 abc/123456

    Operate_database().connect()

  • 对象的绑定方法：在类中没有被任何装饰器修饰的方法就是 绑定到对象的方法，这类方法专门为对象定制。

    class Person:
    country = "China"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self):
        print(self.name + ', ' + str(self.age))


==>>> p = Person('Kitty', 18)
      print(p.__dict__)

#{'name': 'Kitty', 'age': 18}

==>>> print(Person.__dict__['speak'])

#<function Person.speak at 0x10f0dd268>

    注意：speak即为绑定到对象的方法，这个方法不在对象的名称空间中，而是在类的名称空间中。

二、非绑定方法

非绑定方法：在类内部使用 @staticmethod 修饰的方法即为非绑定方法，这类方法和普通定义的函数没有区别，不与类或对象绑定，谁都可以调用，且没有自动传值的效果。

import hashlib


class Operate_database():
    def __init__(self, host, port, user, password):
        self.host = host
        self.port = port
        self.user = user
        self.password = password

    @staticmethod
    def get_passwrod(salt, password):
        m = hashlib.md5(salt.encode('utf-8'))  # 加盐处理
        m.update(password.encode('utf-8'))
        return m.hexdigest()


==>>> hash_password = Operate_database.get_passwrod('lala', '123456')  # 通过类来调用
	  print(hash_password)

#f7a1cc409ed6f51058c2b4a94a7e1956


==>>> p = Operate_database('192.168.0.5', '3306', 'abc', '123456')
	  hash_password = p.get_passwrod(p.user, p.password)  # 也可以通过对象调用
	  print(hash_password)

#0659c7992e268962384eb17fafe88364

注意：简而言之，非绑定方法就是将普通方法放到了类的内部。

断点调试

总结：

  • 一等公民：能够将一个东西赋值给一个变量，这个东西就叫一等公民

  • 红色圆圈表示断点标记，程序运行时会在该处暂停

  • 断点应该加在报错的地方之前

  • 绿色箭头表示快速跳到下一个断点执行

issubclass和isinstance

总结：

  • issubclass：判断第一个类是不是第二个类的子类,返回true或者false
  • isinstance：判断第一个参数是不是第二个参数的对象,返回true或者false

issubclass 举个栗子：

class Foo:
    pass
class Bar(Foo):
    pass
class Tt(Bar):
    pass

print(Bar.__bases__) ==>Foo
print(issubclass(Bar,Foo))  ==>判断Bar是不是Foo的子类, True
print(issubclass(Tt,object))    ==>新式类默认继承object，所以为True

isinstance 举个栗子：

class Foo:
    pass
class Tt():
    pass

f=Foo()  ==>实例化对象
print(isinstance(f,Foo)) ==>True
print(isinstance(f,Tt))	 ==>False

反射

总结：

  • 反射:通过字符串来获取,设置,删除对象中的属性或方法
  • hasattr():判断一个属性是否在对象中,返回True或者False
  • getattr():通过字符串获取属性或方法,如果获取到了,就会返回相应的属性或方法
  • setattr():通过字符串来设置属性或方法
  • delattr():通过字符串来删除属性或方法
  • 拓展：sorted( )和 .sorted前者为内置函数，后者为绑定方法

举个栗子：

class Foo:
    def run(self):
        print('run')
    def speak(self):
        print('speak')

p=Foo()
print(Foo.__dict__)
cmd=input('请输入命令:')

#方案一:
print(Foo.__dict__[cmd])
Foo.__dict__[cmd](Foo)

#判断一下对象中有没有没有我输入的属性,如果有,打印
if hasattr(p,cmd):
    run=getattr(p,cmd)
    run()
else:
    print('该命令不存在')

1. 通过用户输入key和value往对象中赋值

key=input('请输入key:')
value=input('输入value:')

setattr(p,key,value)
print(p.age)

2. 动态的往对象中放方法

def test(a):
    print(a)

print(p.__dict__)
setattr(p,'test',test)

print(p.__dict__)
p.test(0)

3. 动态的删除属性

#原始的删除方法
p.name='lqz'
del p.name


#动态删除p中属性为变量a的属性
p.name='lqz'
p.age=18
p.sex='male'

a=input('请输入要删除的属性:')
delattr(p,a)


#直接p.a是不对的
del p.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(b1.__dict__)
print(hasattr(b1,'sell_house'))

a='sell_house'
getattr(b1,'sell_house')
getattr(b1,a)()
sell_house=getattr(b1,a)
name=getattr(b1,'name')
print(name)
print(sell_house)

内置方法

总结：

  • 点拦截方法对象.即触发
  • __setattr__：赋值或修改都将触发
  • __getattr__：一旦在对象中取不到，则会触发
  • __delattr__：对象.删除值会触发
  • __str__：print打印时自动触发该函数执行，打印出内存地址，如果重写则会打印出自定义内容
  • __repr__ :跟__str__类似,在交互式命令下直接写变量名,会执行__repr__
  • item：__setitem__和__getitem__，对象通过[ ] 中括号取值,赋值,删除值的时候,会调用
  • __call__：对象加括号会调用它
  • __enter__和__exit__：with上下文管理器（本质）
class Foo:
    x = 1

    def __init__(self, y):
        self.y = y

    def __getattr__(self, item):
        print('----> from getattr:你找的属性不存在')

    def __setattr__(self, key, value):
        print('----> from setattr')
        # self.key = value  # 这就无限递归了,你好好想想
        # self.__dict__[key] = value  # 应该使用它

    def __delattr__(self, item):
        print('----> from delattr')
        # del self.item  # 无限递归了
        self.__dict__.pop(item)

一、__setattr__

  • 添加/修改属性会触发它的执行

  • 注意：利用该内置方法可以自定义值，而不是不能通过__init__放值

f1 = Foo(10) #触发self.y,进入__setattr__
print(f1.__dict__) 

# 因为你重写了__setattr__，凡是赋值操作都会触发它的运行，你啥都没写，就是根本没赋值，除非你直接操作属性字典，否则永远无法赋值

f1.z = 3  #赋值, 进入__setattr__
print(f1.__dict__)

----> from setattr
{}
----> from setattr
{}

二、__delattr__

  • 删除属性的时候会触发
f1 = Foo(10)  #----> from setattr

f1.__dict__['a'] = 3  # 我们可以直接修改属性字典，来完成添加/修改属性的操作del f1.aprint(f1.__dict__)python
print(f1.__dict__)
del f1.a  #----> from delattr
print(f1.__dict__)

----> from setattr
{'a': 3}
----> from delattr
{}

三、__getattr__

  • 只有在使用点调用属性，且属性不存在的时候，才会触发
  • 取不到值而调用该方法时，也可以自定义值返回
f1 = Foo(10)
f1.bb

----> from setattr
----> from getattr:你找的属性不存在

写一个类继承字典,让它可以 . 取值,可以中括号取值：

class Mydict(dict):
    def __init__(self, **kwargs):
        #self.xxx = xxx 原先使用self.某属性，对象加点会调用__setattr__，所以尽量不用
        super().__init__(**kwargs)

    def __getattr__(self, item):
        return self[item]

    def __setattr__(self, key, value):
        #第一种写法
        self[key] = value 
        
         #第二种写法
        self.__dict__[key] = value
        
        #第三种写法，默认父类为object，此时为重写__setattr__直接赋值
        super().__setattr__(key, value) 
        

di = Mydic(name = 'lqz', age = 18)
di.name = 'lqz' #不进入__init__，会调用__setattr__，里面有__dict__，name放入key，lqz放入value


print(di['name'])
print(di.name)

---> lqz
---> lqz

di.sex = 'male'
di['sex'] = 'male'
print(di.sex)
di.sex = 19
print(di.sex)

---> male
---> 19

四、__item__系列

  • 对象通过[ ] 中括号取值,赋值,删除值的时候,会调用
class Foo:
    def __init__(self, name):
        self.name = name

    def __getitem__(self, item):
        print('getitem执行', self.__dict__[item])

    def __setitem__(self, key, value):
        print('setitem执行')
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('del obj[key]时，delitem执行')
        self.__dict__.pop(key)
  1. __setitem__
  • 中括号赋值时触发
f=Foo('lqz')
f['age'] = 18

---> setitem执行

  1. __getitem__
  • 中括号取值时触发
f=Foo('lqz')
f['age'] = 18
f['age']

---> setitem执行
---> getitem执行 18

f['name'] = 'nick'

---> setitem执行

五、__call__

  • 对象加括号会调用它
class Foo:
    def __call__(self):
        print('xxxx')

f=Foo()()

---> xxxx

六、__enter__和__exit__

  • with上下文管理器（本质）
class Mydict():
    def __getattr__(self, item):
        print('xxx')
        return '该属性不存在'

m=Mydict()
print(m.name)

---> xxx

---> 该属性不存在

posted @ 2019-09-03 16:38  fxyadela  阅读(120)  评论(0)  编辑  收藏  举报