面向对象相关

特殊成员补充：

1.__str__

2.__doc__:查看"""   """所注释的内容

3.__dict__:把所传的值以字典的形式打印出来

class Foo(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        pass


obj1 = Foo('刘博文', 99)
obj2 = Foo('史雷', 89)

print(obj1.__dict__)  # {'name': '刘博文', 'age': 99}
print(obj2.__dict__)  # {'name': '史雷', 'age': 89}

4.__iter__  把不可迭代对象 -> 可迭代对象

class Foo(object):
   
    def __iter__(self):
        return iter([123,456])
obj=Foo()
for el in obj:
    print(el )

 练习题：

一.
class Starkconfig(object):
    list_display=[]
    def get_list_display(self):
        self.list_display.insert(0,999)
        return self.list_display
class Roleconfig(Starkconfig):
    list_display = [11,22]
s1=Starkconfig()
ret=s1.get_list_display()
print(ret)
ret2=s1.get_list_display()
print(ret2)

[999]
[999, 999]
二.

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0,33)
        return self.list_display

class RoleConfig(StarkConfig):
    list_display = [11,22]
s1 = StarkConfig()
s2 = StarkConfig()
result1 = s1.get_list_display()
print(result1)
result2 = s2.get_list_display()
print(result2)

[33]
[33,33]
三.

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0,33)
        return self.list_display
class RoleConfig(StarkConfig):
    list_display = [11,22]
s1 = StarkConfig()
s2 = RoleConfig()
result1 = s1.get_list_display()
print(result1)
result2 = s2.get_list_display()
print(result2)

 [33]
[33, 11, 22]
四.

class StarkConfig(object):
    list_display = []

    def get_list_display(self):
        self.list_display.insert(0,33)
        return self.list_display
class RoleConfig(StarkConfig):
    list_display = [11,22]
s1 = RoleConfig()
s2 = RoleConfig()
result1 = s1.get_list_display()
print(result1)
result2 = s2.get_list_display()
print(result2)

[33, 11, 22]
[33, 33, 11, 22] 

 #########################################################################

1.issubclass  type   isinstance：

<1.issubclass  :检查第一个参数（子类）是否是第二个参数（父类）的 子子孙孙类

class a:
    pass
class b(a):
    pass
class c(b):
    pass
print(issubclass(b,a))
print(issubclass(c,b))
print(issubclass(c,a))****

True
True
True

<2.type :获取当前的对象是由那个类创建的

class Foo(object):
    pass
class Bar(object):
    pass
def func(*args):
    foo_conter=0
    bar_conter=0
    for el in args:
        if type(el)==Foo:
            foo_conter+=1
        elif type(el )==Bar:
            bar_conter+=1
    return foo_conter,bar_conter
ret1,ret2=func(Foo(),Foo(),Bar())
print(ret1,ret2)
2   1

 <3.isinstance :检查第一个参数（对象）是否是第二个参数（以及父类）的实例、

class Foo(Base):
    pass

obj1 = Foo()
print(isinstance(obj1,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。


obj2 = Base()
print(isinstance(obj2,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
print(isinstance(obj2,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。

True
True
False
True

练习：给你一个参数，判断对象是不是由某一个指定类？ type --> type(obj) == Foo
给你一个参数，判断对象是不是由某一个指定类或其父类？ isinstance

 方法和函数：

对象.xxx  --> xxx就是方法
类.xxx    --> xxx就是函数
xxx       --> xxx就是函数

 打印查看：
function    功能
method    方法

 代码检查：
from types import MethodType,FunctionType
def check(arg):
"""
检查arg是方法还是函数？
:param arg:
:return:
"""
if isinstance(arg,MethodType):
print('arg是一个方法')
elif isinstance(arg,FunctionType):
print('arg是一个函数')
else:
print('不知道是什么')

 反射*****

可以在模块中使用，也可以在面向对象中使用

模块：
from types import FunctionType
import handler
while True:
    print("""
    系统支持的函数有：
        1. f1
        2. f2
        3. f3
        4. f4
        5. f5
    """)
    val = input("请输入要执行的函数：") # val = "f1"
    if hasattr(handler, val):#检查handler中是否有val的值   hasattr
        func_or_val = getattr(handler, val)  # 根据字符串为参数，去模块中寻找与之同名的成员。*****
        if isinstance(func_or_val, FunctionType):#判断func_or_val是不是以一个方法
            func_or_val()
        else:
            print(func_or_val)
    else:
        print('handler中不存在输入的属性名')

面向对象：

class Account(object):
    func_list = ['login', 'logout', 'register']

    def login(self):
        """
        登录
        :return:
        """
        print('登录111')

    def logout(self):
        """
        注销
        :return:
        """
        print('注销111')

    def register(self):
        """
        注册
        :return:
        """
        print('注册111')

    def run(self):
        """
        主代码
        :return:
        """
        print("""
            请输入要执行的功能：
                1. 登录
                2. 注销
                3. 注册
        """)

        choice = int(input('请输入要执行的序号:'))
        func_name = Account.func_list[choice-1]

        # func = getattr(Account,func_name) # Account.login
        # func(self)

        func = getattr(self, func_name)  # self.login
        func()

obj1 = Account()
obj1.run()

 总结：

getattr # 根据字符串的形式，去对象中找成员。
hasattr # 根据字符串的形式，去判断对象中是否有成员。
setattr # 根据字符串的形式，去判断对象动态的设置一个成员（内存）
delattr # 根据字符串的形式，去判断对象动态的设置一个成员（内存）

是否可以被调用：

类（）

对象（）

函数（）

方法（）

def func():
    pass
class Foo(object):
    def __call__(self, *args, **kwargs):
        pass
    def func(self):
        pass
obj = Foo()
print(callable(func))函数
print(callable(Foo))类
print(callable(obj))对象
print(callable(obj.func))方法