python学习——面对对象进阶

一、isinstance和issubclass

　　isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo:
    pass

a = Foo()
print(isinstance(Foo,object))

# 输出：True

class Parent(object):
    pass

b = Parent()
print(isinstance(Parent,object))

# 输出：True

　　由此可以看出，python3中若没有说明继承的是哪个类的时候，默认继承object。

　　issubclass(sub, super)检查sub类是否是 super 类的派生类 

class Parent():
    pass

class Son(Parent):
    pass

print(issubclass(Parent,object))
print(issubclass(Son,Parent))

# 输出：
True
True

二、反射

　　1、什么是反射（非常强大，也很重要）

　　　　反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

　　2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

　　　　四个可以实现自省的函数

　　　　下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

def hasattr(*args, **kwargs): # real signature unknown
    """
    Return whether the object has an attribute with the given name.
    
    This is done by calling getattr(obj, name) and catching AttributeError.
    """
    pass

def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value
    
    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't
    exist; without it, an exception is raised in that case.
    """
    pass

def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.
    
    setattr(x, 'y', v) is equivalent to ``x.y = v''
    """
    pass

def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.
    
    delattr(x, 'y') is equivalent to ``del x.y''
    """
    pass

class Parent():
    p = '类的静态变量'
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def say_hello(self):
        return '{}say {}'.format(self.name,'hello')

obj = Parent('周曾吕',88,'不详')

# 检测是否含有某个属性
print(hasattr(obj,'name'))
print(hasattr(obj,'age'))
print(hasattr(obj,'sex'))
print(hasattr(obj,'say_hello'))

# 输出：
True
True
True
True

# 获取属性
n1 = getattr(obj,'name')
n2 = getattr(obj,'age')
n3 = getattr(obj,'sex')

print(n1,n2,n3)

# 输出：周曾吕 88 不详

func = getattr(obj,'say_hello')
print(func)

# 输出：
<bound method Parent.say_hello of <__main__.Parent object at 0x00000222F34B2CF8>>

# print(getattr(obj,'aaaa','不存在'))  # 不存在 报错

# 设置属性（赋值）
setattr(obj,'sb',True)
setattr(obj,'show_name',lambda self:self.name + 'sb')
print(obj.__dict__)
print(obj.show_name(obj))

# 输出：
{'name': '周曾吕', 'age': 88, 'sex': '不详', 'sb': True, 'show_name': <function <lambda> at 0x00000222F34CD730>}
周曾吕sb

# 删除属性
delattr(obj,'sex')
delattr(obj,'show_name')
delattr(obj,'sb')
# delattr(obj,'show_name_aaa')   # 不存在就报错

print(obj.__dict__)

# 输出：
{'name': '周曾吕', 'age': 88}

 

class Foo:

    staticName = 'University Guiyang'

    def __init__(self):
        self.name = 'liulonghai'

    def func(self):
        return 'in func now '

    @staticmethod
    def qqxing():
        return 'qqxing'

print(getattr(Foo,'staticName'))
print(getattr(Foo,'func'))
print(getattr(Foo,'qqxing'))

ret1 = getattr(Foo,'func')
ret2 = getattr(Foo,'qqxing')

print(ret1(Foo))
print(ret2())

# 输出：
University Guiyang
<function Foo.func at 0x0000020D5570E8C8>
<function Foo.qqxing at 0x0000020D5570E950>
in func now 
qqxing

　　注意：当调用类里面的普通方法时，要传一个类名作为参数，否则会报错。如上面的 ret2(Foo)

import sys

n1 = 'qqxing'
def func1():
    return 'in func1 now'

n2 = 'wahaha'
def func2():
    return 'in func2 now'

the_module = sys.modules[__name__]

if hasattr(the_module,'func1'):
    ret1 = getattr(the_module,'func1')
    print(ret1())
if hasattr(the_module,'func2'):
    ret2 = getattr(the_module,'func2')
    print(ret2())

print(getattr(the_module,'n1'))
print(getattr(the_module,'n2'))

# 输出：
in func1 now
in func2 now
qqxing
wahaha

　　注意：不管是函数还是变量，反射的时候只能有一个变量，且变量必须是全局变量。

　　导入其他模块，可以利用反射来运行该模块中存在的方法

import 面向对象的三大特性

if hasattr(面向对象的三大特性,'A'):
    ret1 = getattr(面向对象的三大特性,'A')
    print(ret1)
    print(ret1())

# 输出：
<class '面向对象的三大特性.A'>
China

　　注意，若导入的模块是一个类而不是函数，运行的时候可能会报错，他会说这个类的类名不可调用，是因为这个类中没有__call__这个方法，如果你加上之后就不会报错了，但是他返回的是一个内存地址，没有显示这个函数的结果（不管你怎么调用都不显示，而且不会报错，是不是懵逼了），其实是因为类中没有实现__repr__或者__str__这两个双下方法中的其中一个，你加上就可以了。。。

三、__repr__和__str__
　　改变对象的字符串显示__str__,__repr__

　　自定制如下的格式化字符串__format__ 👇

format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
    def __init__(self,name,addr,type):
        self.name = name
        self.addr = addr
        self.type = type

    def __repr__(self):
        return '学校名：{} 地址：{}'.format(self.name,self.addr)
    def __str__(self):
        return '学校名：{} 地址：{}'.format(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec = 'nat'
        fmt = format_dict[format_spec]
        return fmt.format(obj=self)

s1=School('贵阳学院','贵阳','公立')
print('from repr: ', repr(s1))
print('from str: ', str(s1))
print(s1)

'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出 就是说__repr__是__str__的备胎
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1, 'nat'))
print(format(s1, 'tna'))
print(format(s1, 'tan'))
print(format(s1, 'asfdasdffd'))

# 输出：
from repr:  学校名：贵阳学院 地址：贵阳
from str:  学校名：贵阳学院 地址：贵阳
学校名：贵阳学院 地址：贵阳
贵阳学院-贵阳-公立
公立:贵阳学院:贵阳
公立/贵阳/贵阳学院
贵阳学院-贵阳-公立

class A:
    def __str__(self):
        return 'from str: class A'

    def __repr__(self):
        return 'from repr: class A'

b = A()
print('%s'%b)
print('%r'%b)

# 输出：
from str: class A
from repr: class A

 四、__del__

　　析构方法，当对象在内存中被释放时，自动触发执行。

　　注意：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class A:
    def __del__(self):
        print('执行我呗！')

a = A()
del a
print('*******')

# 输出：
执行我呗！
*******

五、item系列

　　5.1、__getitem__ __setitem__ __delitem__

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

    def __getitem__(self, item):
        return self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __delitem__(self, key):
        print('*******del obj[key]时，执行我啦********')
        self.__dict__.pop(key)

    def __delattr__(self, item):
        print('del obj[key]时，执行我啦')
        self.__dict__.pop(item)

a = A('小周哥')
a['age1'] = 18
a['age2'] = 88
print(a.__dict__)
del a.age2
del a['age1']
a['name'] = '小伟哥'
print(a.__dict__)

# 输出：
{'name': '小周哥', 'age1': 18, 'age2': 88}
del obj[key]时，执行我啦
*******del obj[key]时，执行我啦********
{'name': '小伟哥'}

六、__new__

class A:
    def __init__(self):
        self.x = 1000000
        print('in init function now ')

    def __new__(cls, *args, **kwargs):
        print('in new function now ')
        return object.__new__(A,*args,**kwargs)

a = A()
print(a.x)

# 输出：
in new function now
in init function now
1000000

class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            cls._instance = object.__new__(cls,*args,**kwargs)

        return cls._instance

one = Singleton()
one.name = '刘龙海'
two = Singleton()
two.name = '刘永贵'
print(one.name)
# 刘永贵
print(id(one))
# 3237255572616
print(id(two))
# 3237255572616
print(one.name)
# 刘永贵
print(one == two)
# True
print(one is two)
# True

 　　单例模式：在类中始终都只有一个实例。

class A:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            cls._instance = object.__new__(A,*args,**kwargs)
        return cls._instance

a = A()
aa = A()
aa.name = '刘永贵'
a.name = '刘龙海'
print(a.name)
# 刘龙海
print(aa.name)
# 刘龙海
print(id(a))
# 2266637659216
print(id(aa))
# 2266637659216
print(a == aa)
# True
print(a is aa )
# True

七、__call__
　　对象后面加括号，触发执行。

　　注意：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class A:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        return 'in __call__'

a = A()
print(a())
print(A()())

# 输出：
in __call__
in __call__

八、__len__

class A:
    def __init__(self):
        self.a = 1
        self.aa = 2

    def __len__(self):
        return len(self.__dict__)

aaa = A()
print(len(aaa))

# 输出：2

九、__hash__

class A:
    def __init__(self):
        self.a = 1
        self.aa = 2

    def __hash__(self):
        return hash(str(self.a)+str(hash(self.aa)))

aaa = A()
print(hash(aaa))

# 输出：5078281282522828503

十、__eq__

class A:
    def __init__(self):
        self.a = 1
        self.aa = 2

    def __eq__(self, other):
        if self.a == other.a and self.aa == other.aa:
            return True

c1 = A()
c2 = A()
print(c1 == c2)

# 输出：True

class A:
    def __init__(self):
        self.a = 1
        self.aa = 2

    def __eq__(self, other):
        if self.a == other.a and self.aa == other.aa:
            return True

a = A()
aa = A()
print(a == aa)

# 输出：True

十一、面向对象进阶实例
　　1.扑克牌游戏

from collections import namedtuple
from random import choice,shuffle
import json

Card = namedtuple('牌',['num_types','numbers'])
class Pukepai():
    numbers = [str(n) for n in range(2,11)] + list('JQKA')
    num_types = ['黑桃','红桃','梅花','方块']

    def __init__(self):
        self._cards = [Card(num_type,number) for num_type in Pukepai.num_types
                                             for number in Pukepai.numbers]

    def __call__(self, *args, **kwargs):
        return Pukepai

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

    def __setitem__(self, key, value):
        self._cards[key] = value

    def __str__(self):
        return json.dumps(self._cards,ensure_ascii=False)

puke = Pukepai()
print(puke[10])
print(choice(puke))
print(choice(puke))
print(choice(puke))
print(choice(puke))
print(choice(puke))
shuffle(puke)
print(puke[:52])

# 输出：
牌(num_types='黑桃', numbers='Q')
牌(num_types='方块', numbers='Q')
牌(num_types='方块', numbers='4')
牌(num_types='红桃', numbers='8')
牌(num_types='红桃', numbers='3')
牌(num_types='梅花', numbers='6')
[牌(num_types='红桃', numbers='J'), 牌(num_types='红桃', numbers='8'), 牌(num_types='方块', numbers='2'), 牌(num_types='黑桃', numbers='7'), 牌(num_types='红桃', numbers='2'), 牌(num_types='方块', numbers='A'), 牌(num_types='梅花', numbers='3'), 牌(num_types='方块', numbers='7'), 牌(num_types='梅花', numbers='8'), 牌(num_types='方块', numbers='K'), 牌(num_types='黑桃', numbers='Q'), 牌(num_types='方块', numbers='3'), 牌(num_types='红桃', numbers='7'), 牌(num_types='梅花', numbers='5'), 牌(num_types='方块', numbers='8'), 牌(num_types='红桃', numbers='A'), 牌(num_types='黑桃', numbers='J'), 牌(num_types='梅花', numbers='10'), 牌(num_types='黑桃', numbers='K'), 牌(num_types='红桃', numbers='10'), 牌(num_types='方块', numbers='4'), 牌(num_types='梅花', numbers='Q'), 牌(num_types='梅花', numbers='7'), 牌(num_types='黑桃', numbers='3'), 牌(num_types='方块', numbers='5'), 牌(num_types='红桃', numbers='4'), 牌(num_types='方块', numbers='10'), 牌(num_types='黑桃', numbers='4'), 牌(num_types='红桃', numbers='9'), 牌(num_types='梅花', numbers='4'), 牌(num_types='红桃', numbers='3'), 牌(num_types='黑桃', numbers='A'), 牌(num_types='梅花', numbers='K'), 牌(num_types='黑桃', numbers='8'), 牌(num_types='黑桃', numbers='5'), 牌(num_types='方块', numbers='J'), 牌(num_types='方块', numbers='Q'), 牌(num_types='红桃', numbers='6'), 牌(num_types='梅花', numbers='J'), 牌(num_types='黑桃', numbers='6'), 牌(num_types='梅花', numbers='2'), 牌(num_types='梅花', numbers='A'), 牌(num_types='黑桃', numbers='2'), 牌(num_types='梅花', numbers='9'), 牌(num_types='红桃', numbers='Q'), 牌(num_types='黑桃', numbers='9'), 牌(num_types='方块', numbers='9'), 牌(num_types='梅花', numbers='6'), 牌(num_types='黑桃', numbers='10'), 牌(num_types='红桃', numbers='K'), 牌(num_types='方块', numbers='6'), 牌(num_types='红桃', numbers='5')]

　　2.一道面试题

class Person:
    def __init__(self,name,sex,age):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):
        return hash(self.name + self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:
            return True

p_lst = []
for i in range(10):
    p_lst.append(Person('刘龙海','男',i))

print(p_lst[:2])
print(set(p_lst))

# 输出：
[<__main__.Person object at 0x0000023940FF5B38>, <__main__.Person object at 0x0000023940FF5C88>]
{<__main__.Person object at 0x0000023940FF5B38>}