python's twenty-third day for me 面对对象进阶

Posted 2020-10-31 Qingqiu_Gu

普通方法：对象和类绑定的过程。

class A:
    def func1(self):pass
    def func2(self):pass
    def func3(self):pass
    def func4(self):pass

a = A()
b = A()
print(A.func1)      # <function A.func1 at 0x00000217A0BE3400>
print(a.func1)      # <bound method A.func1 of <__main__.A object at 0x00000217A0CF9EB8>>
print(b.func1)      # <bound method A.func1 of <__main__.A object at 0x00000217A0CFF080>>

类方法：由于不适用对象内存空间的属性所以不会将对象和方法绑在一起。而是将类和方法绑在一起。

class A:
    def func1(self):pass
    @classmethod
    def func2(cls):pass
    def func3(self):pass
    def func4(self):pass

a = A()
b = A()
print(A.func2)      # <bound method A.func2 of <class \'__main__.A\'>>
print(a.func2)      # <bound method A.func2 of <class \'__main__.A\'>>
print(b.func2)      # <bound method A.func2 of <class \'__main__.A\'>>

#  对象能找到类，类里面绑着方法。

静态方法：不是绑定方法，没有和对象或者类发生任何绑定关系。

class A:
    def func1(self):pass
    @classmethod
    def func2(cls):pass
    def func3(self):pass
    @staticmethod
    def func4(self):pass

a = A()
b = A()
print(A.func4)      # <function A.func4 at 0x000002BE409837B8>
print(a.func4)      # <function A.func4 at 0x000002BE409837B8>
print(b.func4)      # <function A.func4 at 0x000002BE409837B8>

#  没有绑定  : 并没有 bound method  

isinstance：能够检测到继承关系。判断一个对象和一个类有没有血缘关系。isinstance(对象名，类名)。

#  能够检测到继承的关系。
class A:pass
class B(A):pass
class C(B):pass
c = C()
print(isinstance(c,C))      # True
print(isinstance(c,B))      # True
print(isinstance(c,A))      # True

# type 只是单纯的判断类
print(type(c) is C)     # True
print(type(c) is B)     # False
print(type(c) is A)     # False

issubclass：可以查看是否存在继承关系。

# issubclasss(子类名，父类名) 返回bool值。
class A:pass
class B(A):pass
class C(B):pass
print(issubclass(B,A))      # True
print(issubclass(C,B))      # True
print(issubclass(C,A))      # True

反射：

　　反射的4个内置函数：1，getattr　　2，hasattr　　3，setattr　　4，delattr

　　正常情况下，如果可以拿到这个变量，那么如有这个变量的字符串形式，就是用反射可以获取到这个值。

　　概念：使用字符串数据类型的变量名，访问一个命名空间中的名字。

　　找一个属性，直接就可以找到这个属性的值。

　　找一个方法，找到的是这个方法的的内存地址。

class A:
    role = \'Person\'
    def func(self):
        print(\'*\')
# ret = input(\'>>>\')
# a = A()
print(getattr(A,\'role\'))       # 从A的命名空间里找一个属性，直接就可以找到这个属性的值
f = getattr(A,\'func\');f(1)     # 从A的命名空间找一个方法，找到的是这个方法的内存地址

hasattr()　　判断一个命名空间中有没有这个名字。

getattr()　　从命名空间中获取这个名字对应的值，如果空间里没有这个属性则会报错。

class A:
    role = \'Person\'
    def func(self):
        print(\'guxiaobai\')
ret = input(\'>>>\')
if hasattr(A,ret):
    f = getattr(A,ret)
    print(f)
    if type(f) is not str:
        f(1)  #  若是函数名则以加括号执行。
# 其次因为是从类中寻找的所以需要传参数。若是对象中找，则不需要传参数。
class A:
    role = \'Person\'
    def func(self):
        print(\'guxiaobai\')
ret = input(\'>>>\')
a = A()
if hasattr(a,ret):
    f = getattr(a,ret)
    print(f)
    if type(f) is not str:
        f()

类中的反射：类可以获取类中的属性和方法。

class A:
    role = \'Person\'
    def func(self):
        print(\'guxiaobai\')

print(hasattr(A,\'role\'))    # True
print(hasattr(A,\'func\'))    # True
ret = input(\'>>>\')
if hasattr(A,ret):
    print(getattr(A,ret))

class A:                                 
    role = \'Person\'                      
    def __init__(self):                  
        self.money = 100                 
    def func(self):                      
        print(\'guxiaobai\')               
a = A()                                  
print(hasattr(a,\'money\'))   # True       
print(getattr(a,\'money\'))   # 100        
getattr(a,\'func\')()         # guxiaobai 

模块使用模块中的名字：

import time     # 一个py文件就是一个模块
time.time()
print(getattr(time,\'time\')())

在自己所在的模块中使用自己的名字：

　　1，import sys　　首先导入sys模块。

　　2，getattr(sys.modules[\'__main__\']，名字)

def login():
    print(\'执行login功能\')
def register():
    print(\'执行register功能\')

import sys
while True:
    ret = input(\'请输入你想执行的功能：退出输入Q/q:\')
    if ret.upper() == \'Q\':
        break
    if hasattr(sys.modules[\'__main__\'],ret):
        getattr(sys.modules[\'__main__\'],ret)()

getattr 一定要和 hasattr 配合使用。

setattr：修改和新建。

class A:
    def __init__(self,name):
        self.name = name

    def func(self):
        print(\'guqingqiu\')

a = A(\'顾清秋\')
print(a.name)       # 顾清秋
setattr(a,\'name\',\'顾小白\')         # 已经存在的属性是修改。
print(a.name)       # 顾小白
print(a.__dict__)       # {\'name\': \'顾小白\'}
setattr(a,\'age\',17)
print(a.__dict__)       # {\'age\': 17, \'name\': \'顾小白\'}
print(a.age)  # 17      # 不存在的属性就是新建。

setattr 如果新建方法（只能将不属于类的方法移入到类中）且格式：setattr(类名，‘方法名’，方法名)因为方法一般不存放在对象中，所以一般是类名，若是用对象调用，则 方法（形参）中必须有一个形参，否则就不需要。

def login():
    print(\'执行login功能\')
class A:
    def __init__(self,name):
        self.name = name

    def func(self):
        print(\'guqingqiu\')
a = A(\'顾清秋\')
print(A.__dict__)
setattr(A,\'login\',login)
print(A.__dict__)
getattr(A,\'login\')()       # 外部login()中不需要形参。
getattr(a,\'login\')()       # 外部login(self)中需要形参,否则会报错。

delattr：删除属性或方法，基本不用。

class A:
    def __init__(self,name):
        self.name = name
    def func(self):
        print(\'guqingqiu\')
a = A(\'顾清秋\')
print(a.__dict__)   # {\'name\': \'顾清秋\'}
delattr(a,\'name\')
print(a.__dict__)   # {}

内置方法：

　　　　内置的东西都和内置方法有着千丝万缕的联系。

class A:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __len__(self):
        return len(self.__dict__)
a = A(\'alex\',35,\'不详\')
print(a.__len__())  # 3
a.hobby = \'开车\'
print(a.__len__())  # 4

字典的存储：hash

# hash 和 __hash__关系
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __hash__(self):
        return 0       # return 是什么就是什么值。
a = A(\'alex\',35)
print(hash(a))
print(a.__hash__())