面向对象的零碎知识

一  面向对象的软件开发

      任何程序开发都是先设计 后编程，python中class机制只不过是一种编程的方式。一个软件中所产生的错误或隐藏的错误，未知的错误可能达到惊人的程度，这也不是在设计阶段能完全解决的。

      什么是软件工程：软件的开发其实是一整套规范，而我们只学了其中的一小部分。一个完整的开发过程，需要明确每个阶段的任务，在保证一个阶段正确的情况下在进行第二个阶段。

       1面向对象分析（object oriented analysis ，OOA）

    软件工程中，系统分析阶段要求程序员和用户结合到一起，对用户的需求做出精确分析和明确表述。大方面分析软件系统应该做什么，而不是 该怎么去做。

         2 面向对象设计（object oriented design，OOD）

　根据面向对象分析阶段形成的需求模型，对每一部分分别进行具体的设计。

    首先是类的设计，类的设计可能包含多个层次（利用继承与派生机制）。然后以这些类为基础提出程序设计的思路和方法，包括对算法的设计。

       3 面向对象编（object orientedprogramming，OOP）

    根据面向对象设计的结果，选择一种计算机语言把它写成程序，可以是python

　　4 面向对象测试（object oriented test，OOT）

　在写好程序后交给用户使用前，必须对程序进行严格的测试，测试的目的是发现程序中的错误并修正它。

    面向对的测试是用面向对象的方法进行测试，以类作为测试的基本单元。

   　5 面向对象维护（object oriendted soft maintenance，OOSM）

  正如对任何产品都需要进行售后服务和维护一样，软件在使用时也会出现一些问题，或者软件商想改进软件的性能，这就需要修改程序。

    由于使用了面向对象的方法开发程序，使用程序的维护比较容易。

二  isinstance(obj,cls)和issubclass(sub,super)

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

1 class Foo(object):
2     pass
3  
4 obj = Foo()
5  
6 isinstance(obj, Foo)

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

1 class Foo(object):
2     pass
3  
4 class Bar(Foo):
5     pass
6  
7 issubclass(Bar, Foo)

三  反射

1 什么是反射：主要是指程序可以访问，检测和修改他本身状态的一种功能（自省）。

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

3  四种可以实现自省的函数

 getattr  获取属性

# class Teacher:
#     school='oldbly'
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#     def teach(self):
#         print('%s is teaching'%self.name)

# print(getattr(Teacher,'school'))
# print(getattr(Teacher,'solasdf',None))

setattr    设置属性

# class Teacher:
#     school='oldbly'
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#     def teach(self):
#         print('%s is teaching'%self.name)

# setattr(Teacher,'x',123)
# print(Teacher.x)

delattr  删除属性

# class Teacher:
#     school='oldbly'
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#     def teach(self):
#         print('%s is teaching'%self.name)

# delattr(Teacher,'school')
# print(Teacher.school)

hasattr  检查是否含有某属性

# class Teacher:
#     school='oldbly'
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
#     def teach(self):
#         print('%s is teaching'%self.name)


# print(hasattr(Teacher,'school'))

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(hasattr(b1,'name'))
print(hasattr(b1,'sell_house'))

#获取属性
n=getattr(b1,'name')
print(n)
func=getattr(b1,'rent_house')
func()

# getattr(b1,'aaaaaaaa') #报错
print(getattr(b1,'aaaaaaaa','不存在啊'))

#设置属性
setattr(b1,'sb',True)
setattr(b1,'show_name',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.show_name(b1))

#删除属性
delattr(b1,'addr')
delattr(b1,'show_name')
delattr(b1,'show_name111')#不存在,则报错

print(b1.__dict__)

一切都是对象，泪也是一个对象

class Foo(object):
 
    staticField = "old boy"
 
    def __init__(self):
        self.name = 'wupeiqi'
 
    def func(self):
        return 'func'
 
    @staticmethod
    def bar():
        return 'bar'
 
print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')

__setattr__,__delattr__,__getattr__三者的用法演示

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__添加/修改属性会触发它的执行
f1=Foo(10)
print(f1.__dict__) # 因为你重写了__setattr__,凡是赋值操作都会触发它的运行,你啥都没写,就是根本没赋值,除非你直接操作属性字典,否则永远无法赋值
f1.z=3
print(f1.__dict__)

#__delattr__删除属性的时候会触发
f1.__dict__['a']=3#我们可以直接修改属性字典,来完成添加/修改属性的操作
del f1.a
print(f1.__dict__)

#__getattr__只有在使用点调用属性且属性不存在的时候才会触发
f1.xxxxxx

4 为什么是使用反射和反射的好处

       好处一，实现可插拔机制

             有两个程序员，一个程序员假如想使用另一个程序员所写的类的时候，但是另一个程序员现在不在了，并且还没有完成他写的类。而这个程序员可以使用反射机制继续完成自己的代码。而另一个程序员回来后再继续完成类的定义，并且去实现这个程序员想要的功能。总之反射的好处是可以事先定义好接口。接口只会在被完成后才会真正执行。这实现了即插即用。其实是一种后期绑定：可以事先把主要逻辑写好（只定义接口）后期在实现接口功能。

      另一个程序员还没有实现的全部功能

class FtpClient:
    'ftp客户端,但是还么有实现具体的功能'
    def __init__(self,addr):
        print('正在连接服务器[%s]' %addr)
        self.addr=addr

      不影响其他人的代码编写

#from module import FtpClient
f1=FtpClient('192.168.1.1')
if hasattr(f1,'get'):
    func_get=getattr(f1,'get')
    func_get()
else:
    print('---->不存在此方法')
    print('处理其他的逻辑')

          好处二：动态导入模块（基于反射当前模块成员）

四  二次加工标准类型（包装）

  1包装：python为我们提供了标准数据类型和丰富内置方法。大多数情况下我们都需要基于标准数据类型来定制我们自己的数据类型。新增改写的方法，这就会用到继承我派生。

class List(list): #继承list所有的属性，也可以派生出自己新的，比如append和mid
    def append(self, p_object):
        ' 派生自己的append：加上类型检查'
        if not isinstance(p_object,int):
            raise TypeError('must be int')
        super().append(p_object)

    @property
    def mid(self):
        '新增自己的属性'
        index=len(self)//2
        return self[index]

l=List([1,2,3,4])
print(l)
l.append(5)
print(l)
# l.append('1111111') #报错，必须为int类型

print(l.mid)

#其余的方法都继承list的
l.insert(0,-123)
print(l)
l.clear()
print(l)

class List(list):
    def __init__(self,item,tag=False):
        super().__init__(item)
        self.tag=tag
    def append(self, p_object):
        if not isinstance(p_object,str):
            raise TypeError
        super().append(p_object)
    def clear(self):
        if not self.tag:
            raise PermissionError
        super().clear()

l=List([1,2,3],False)
print(l)
print(l.tag)

l.append('saf')
print(l)

# l.clear() #异常

l.tag=True
l.clear()

   2授权：授权是包装的一个特性, 包装一个类型通常是对已存在的类型的一些定制,这种做法可以新建,修改或删除原有产品的功能。其它的则保持原样。授权的过程,即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。

实现授权的关键点就是覆盖__getattr__方法

import time
class FileHandle:
    def __init__(self,filename,mode='r',encoding='utf-8'):
        self.file=open(filename,mode,encoding=encoding)
    def write(self,line):
        t=time.strftime('%Y-%m-%d %T')
        self.file.write('%s %s' %(t,line))

    def __getattr__(self, item):
        return getattr(self.file,item)

f1=FileHandle('b.txt','w+')
f1.write('你好啊')
f1.seek(0)
print(f1.read())
f1.close()

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
#我们来加上b模式支持
import time
class FileHandle:
    def __init__(self,filename,mode='r',encoding='utf-8'):
        if 'b' in mode:
            self.file=open(filename,mode)
        else:
            self.file=open(filename,mode,encoding=encoding)
        self.filename=filename
        self.mode=mode
        self.encoding=encoding

    def write(self,line):
        if 'b' in self.mode:
            if not isinstance(line,bytes):
                raise TypeError('must be bytes')
        self.file.write(line)

    def __getattr__(self, item):
        return getattr(self.file,item)

    def __str__(self):
        if 'b' in self.mode:
            res="<_io.BufferedReader name='%s'>" %self.filename
        else:
            res="<_io.TextIOWrapper name='%s' mode='%s' encoding='%s'>" %(self.filename,self.mode,self.encoding)
        return res
f1=FileHandle('b.txt','wb')
# f1.write('你好啊啊啊啊啊') #自定制的write,不用在进行encode转成二进制去写了,简单,大气
f1.write('你好啊'.encode('utf-8'))
print(f1)
f1.close()

 五__del__的用法

当该对象被删除时执行函数内的操作

# import time
# class Foo:
#     def __init__(self,x):
#         self.x=x
#         print('connect mysql') #conn=abcdef('192.168.1.10',3306)
#
#     def __del__(self):
#         '''做一些与这个对象有关的清理操作'''
#         # conn.close()
#         # file.close()
#         print('====>')
# f=Foo(10)
# del f #f.__del__()
# time.sleep(3)
# print('主程序')

六__str__用法

改变对象的字符串显示

class Teacher:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.courses=[]

    def teach(self):
        print('%s teach' %self.name)

    def __str__(self):
        return '<name:%s age:%s>' %(self.name,self.age)

class Course:
    def __init__(self,name,price,period):
        self.name=name
        self.price=price
        self.period=period
    def __str__(self):
        return '《name:%s price:%s period:%s》' %(self.name,self.price,self.period)

# egon=Teacher('egon',18)
# print(egon) #egon.__str__()
# print(egon) #egon.__str__()



















egon=Teacher('egon',18)
# print(egon.courses)
python=Course('python',20000,'6mon')
openstack=Course('openstack',10,'3mon')
linux=Course('linux',1,'1mon')

egon.courses.append(python)
egon.courses.append(openstack)
egon.courses.append(linux)


# egon.courses.extend([python,openstack,linux])
print(egon.courses)
for obj in egon.courses:
    print(obj)

七 item系列

# l=['a','b','c']
# dic={'a':1}
#
# print(l[1])
# print(dic['a'])

class Foo:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def __getitem__(self, item):
        # print(self,item,type(item))
        # return getattr(self,item)
        return self.__dict__[item]
    def __setitem__(self, key, value):
        # setattr(self,key,value)
        self.__dict__[key]=value

    def __delitem__(self, key):
        # delattr(self,key)
        self.__dict__.pop(key)

    def __len__(self):
        return 10
f=Foo('egon',18,'male')
# print(f.name) #f['name']
# print(f.age) #f['age']
# print(f.sex) #f['sex']

# print(f['name'])

# f['name']='egon_nb'
# print(f.__dict__)
# del f['name']
# print(f.__dict__)

print(len(f))