python之面向对象进阶

# 2 == 3   # 值是否相等
# 2 is 3   # 内存地址是否相等

isinstance和issubclass

isinstance(obj,cls)检查是否obj是否是类 cls 的对象 判断第一个参数是否是第二个参数的实例

class A:pass
class B(A):pass
class C(B):pass
c = C()
print(isinstance(c,A))   # 包含继承关系的判断 #true

issubclass(sub, super)检查sub类是否是 super 类的派生类 第一个参数是疑似子类,第二个参数是疑似父类.

class A:pass
class B(A):pass
print(issubclass(A,B))  #false
print(issubclass(B,A))  #true

反射

1 什么是反射

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

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

四个可以实现自省的函数

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

# hasattr  判断某一个 变量 是否能够.调用一个名字,返回True或者False
# getattr  直接获取一个变量中的名字的值

class A:
    name = 'alex'   # 静态 属性
    age = 83        # 静态 属性
print(getattr(A,'name')) #alex
print(hasattr(A,'name')) #true

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show(self):
        for key in self.__dict__:
            print(key,self.__dict__[key])

yuan = Student('苑昊',38)
if hasattr(yuan,'name'):
    print(getattr(yuan,'name')) #苑昊
if hasattr(yuan,'show'):
    func = getattr(yuan,'show')
    func()   #name 苑昊 age 38

# setattr  为一个变量增加或者修改一个属性
# delattr  删除一个变量中的属性或者方法

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def show(self):
        for key in self.__dict__:
            print(key,self.__dict__[key])

hei = Student('小黑',18)
hei.sex = '不详'
print(hei.sex) #不详
setattr(hei,'sex','不详')  # 增改操作
print(hei.sex) #不详
setattr(hei,'sex','male')
print(hei.sex) #不详
delattr(hei,'sex')    # 删除操作
print(hei.__dict__)
def wahaha(a,b):   # 专属于某一个对象的静态方法
    print(a,b) #{'name': '小黑', 'age': 18}

# 反射类中的名字
# getattr(类名,'静态属性')
# getattr(类名,'类方法')()
# getattr(类名,'静态方法')()

# 反射对象中的名字
# getattr(对象名,'对象属性')
# getattr(对象名,'方法名')()

# 反射模块中的名字
# import 模块名
# getattr(模块名,'模块中的变量')
# getattr(模块名,'模块中的函数')()
# getattr(模块名,'模块中的类名')

# 反射当前模块中的名字
# import sys
# getattr(sys.modules[__name__],'变量')
# getattr(sys.modules[__name__],'函数')()
# getattr(sys.modules[__name__],'类名')

# sys.modules[__name__]
# import sys
# print(sys.modules[__name__])  # 所有导入过的模块
# {'字符串数据类型的模块名':模块的内存地址}
# {'__main__':当前模块的内存地址}

class  person:pass
hei = person()
setattr(hei,'name','小黑')
setattr(hei,'age',18)
print(hei,hei.__dict__)

# 怎么反射类 ?
# class Student:
#     def __init__(self,name,age):
#         self.name = name
#         self.age = age
#     def show_student(self):
#         for key in self.__dict__:
#             print(key,self.__dict__[key])
#
# class Teacher:
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def show_teacher(self):
#         for key in self.__dict__:
#             print(key, self.__dict__[key])
#
# class Manager:
#     def __init__(self, name, age):
#         self.name = name
#         self.age = age
#
#     def show_manager(self):
#         for key in self.__dict__:
#             print(key, self.__dict__[key])
# hei = Student('小黑',18)
# import sys
# main = sys.modules[__name__]
# import my_moudle
# cls = getattr(my_moudle,'Student')
# hei = cls('小黑',18)
# print(hei,hei.__dict__)

# 'Manager' 'Teacher' 'Student'
# 获取字符串数据类型的类名
# cls_name = input('>>>')

# 根据输入反射找到具体的类
# if hasattr(main,cls_name):
#     cls = getattr(main,cls_name)

# 实例化对象
# alex = cls('alex',81)
# print(type(alex))
# 展示这个对象中的所有方法
# for i in alex.__dict__:
#     print(i,alex.__dict__[i])

__str__和__repr__

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

自定制格式化字符串__format__

#_*_coding:utf-8_*_

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 'School(%s,%s)' %(self.name,self.addr)
    def __str__(self):
        return '(%s,%s)' %(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('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)

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

class B:

     def __str__(self):
         return 'str : class B'

     def __repr__(self):
         return 'repr : class B'


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

__del__

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

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

import time
class A:
    def __init__(self):
        self.f = open('userinfo','a')
    def consume(self):
        pass
    def __del__(self):
        '''在删除一个对象之前做一些收尾工作'''
        self.f.close()
        print('删除一个对象的时候调用我')

a = A()
time.sleep(1)
del a
# 删除一个对象的时候,如果内部存在__del__方法,
# 那么在删除一个对象之前先执行__del__方法中的代码
print(a) #  报错 name 'a' is not defined

item系列

__getitem__\__setitem__\__delitem__

class A:
    def __init__(self,name):
        self.name = name
        self.age = 81
    def __getitem__(self, item):
        return self.__dict__[item]
    def __setitem__(self, key, value):
        self.__dict__[key] = value
    def __delitem__(self, key):
        del self.__dict__[key]
a = A('alex')
print(a['name'])  # 对应了类中一个方法的语法 #alex
a.name
print(a['age'])  # 对应了类中一个方法的语法 #81
a.age
# 增加 和 修改一个属性
a['sex'] = '不详'
a.sex = '不详'
print(a.__dict__)  #{'name': 'alex', 'age': 81, 'sex': '不详'}
print(a.sex)  #不详
print(a['sex']) #不详
a['sex'] = '女'
print(a.__dict__) #'{'name': 'alex', 'age': 81, 'sex': '女'}
del a['sex']
print(a.__dict__) #'name': 'alex', 'age': 81}

__new__

# 元类
# 有一个元类 在创建类
# type()  所有直接用class创建出来的类的元类都是type

# class 类名(B,classMeta = 元类名)
# class 类名(B,classMeta = type)  # 默认

# 元类 创造 类     所以所有的类的type都是它的元类,默认是type
# 类   创造 对象   具体创造对象的方法 __new__方法,所有的对象的type都是它对应的类

# python中 一切皆对象
# 变量 都有它属于的数据类型

class A:
    def __init__(self):
        print('执行init方法了')
    def __new__(cls):
        print('执行new方法了')
        return object.__new__(cls)   # 创造对象,将对象返回

a = A()
print(type(a))
# 执行new方法了
# 执行init方法了
# <class '__main__.A'>
print(type(A))
# 执行new方法了
# 执行init方法了
# <class 'type'>

# 先执行__new__方法 创造出一个对象
# 然后把创造出来的对象传递给__init__方法
# 会把self自动的返回,被a接收

# 一个类 可以被多次实例化 但是同一时间在python的内存中,只能有一个实例
class A:
    _instance = None
    def __init__(self,name):
        '''给娃穿衣服'''
        self.name = name
    def __new__(cls, *args, **kwargs):
        '''生娃的过程'''
        if not A._instance:
            A._instance = object.__new__(cls)
        return A._instance
a1 = A('alex')  # 第一次实例化的时候创造一个实例
print(a1.name)
a2 = A('egon')
print(a1.name,a2.name)  # 'alex' 'alex'

__call__

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

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

class A:
    def __call__(self,a):
        print('执行我了',a)
    def call(self,a):
        print('执行我了',a)
a = A()
a('abc')   # __call__   #执行我了 abc
a.call('aaa') #执行我了 aaa

__len__

def len(obj):
    return obj.__len__()
print(len(hei))  #4

__eq__

class A:
    def __init__(self,name,cls,age,sex):
        self.name = name
        self.cls = cls
        self.age = age
        self.sex = sex
    def __eq__(self, other):
        # if self.__dict__ == other.__dict__:return True
        return True
    def __len__(self):
        return len(self.__dict__)

hei = A('小黑','py10期',18,'无')
hei2 = A('小2黑','py11期',17,'无')
print(hei.__dict__) #{'name': '小黑', 'cls': 'py10期', 'age': 18, 'sex': '无'}
print(hei2.__dict__) #'name': '小2黑', 'cls': 'py11期', 'age': 17, 'sex': '无'}
print(hei == hei2)  #True
# 两个对象就算值是完全相等的,但是仍然内存地址不同
# == 实际上是比较内存地址的
# == 实际上是调用了__eq__方法

__hash__

# hash(obj)函数,obj对象对应的类必然内部实现了__hash__方法
# hash的结果就是__hash__方法的返回值
# 且在一次成的执行过程中是不会发生变化的
# 且要想作为字典的key或者作为集合的元素,这个对象对应的类必须实现__hash__方法

# 不可变的数据类型都可以被hash
class A:pass
    # def __hash__(self):
    #     return 1
a = A()
b = A()

print(hash(a))   # object.__hash__()
print(hash(b))   # object.__hash__()

__format__

#_*_coding:utf-8_*_

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 __format__(self, format_spec):
        return format_spec.format(obj=self)

s1=School('oldboy1','北京','私立')
print(format(s1,format_dict['tna'])) #私立:oldboy1:北京
print(format(s1,format_dict['nat'])) #oldboy1-北京-私立
print(format(s1,format_dict['tan'])) #私立/北京/oldboy1
print(format(s1,'tna')) #tna
print(format(s1,'tan')) #tan

面试题

# 有一个类,对应这个类产生了100个对象
# 每个对象有三个属性 : 姓名 年龄 性别
# 请对这一百个对象进行去重,如果姓名和性别相同,即便年龄不同也是相同的对象
# 问最简便的方法?
class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __hash__(self):
        return hash('%s%s'%(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(100):
    p_lst.append(Person('egon',i,'male'))
p_lst.append(Person('alex',i,'male'))
p_lst.append(Person('yuan',i,'male'))
print(p_lst)
print(set(p_lst)) # 报错不可hash 完成了__hash__
'''
# hash是否相等   __hash__
# 值是否相等     __eq__

# 收获1
# 对于一些python当中已经存在的内置函数 内置数据类型 内置模块中的方法
# 都有可能依赖于类中的内置方法
# 收获2
# set方法依赖集合中元素对象的__hash__ __eq__
'''

from collections import namedtuple
card = namedtuple('card',['num','col'])
class A:
    num = [str(n) for n in range(2,11) ]+ list('jqka')
    col = ['红心','方板','梅花','黑桃']
    def __init__(self):
        self._cards = [card(num,col) for num in A.num
                      for col in A.col]
    def __len__(self):
        return  len(self._cards)
    def __getitem__(self, item):
        return self._cards[item]
    def __setitem__(self, key, value):
        self._cards[key] = value
deck = A()
print('**', deck[:]) #打印所有的纸牌
from random import choice
print(choice(deck)) #打印随机的纸牌 
# deck对象对应的类中的getitem方法和len方法