python面向对象编程进阶

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python面向对象编程进阶相关的知识,希望对你有一定的参考价值。

python面向对象编程进阶

 

一.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 什么是反射

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

 

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

四个可以实现自省的函数

下列方法适用于类和对象(一切皆对象,类本身也是一个对象)

class Person:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self):
        print("eat")
    def sleep(self):
        print("sleep")

p=Person("liyi",21)

# hasattr(object,name)
# #判断object中有没有一个字符串对应的方法或属性,主要是能不能调用。有:返回True,没有:返回False
print(hasattr(p,name))
print(hasattr(p,aa))

#getattr(object, name,default)
# #返回object中对应字符串的方法或者属性的值,方法返回的是对象地址,加上()可以执行
print(getattr(p,name,"没有这个属性"))
print(getattr(p,aa,"没有这个属性"))
print(getattr(p,eat,"没有这个方法")())

# setattr(x, y, v)
# 给object设置属性或者修改属性
setattr(p,gender,1)
print(p.__dict__)

#delattr(x, y)
# 删除object的属性
delattr(p,name)
print(p.__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)
View Code

反射当前模块成员

技术图片
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sys


def s1():
    print s1


def s2():
    print s2


this_module = sys.modules[__name__]

hasattr(this_module, s1)
getattr(this_module, s2)
View Code

导入其他模块,利用反射查找该模块是否存在某个方法

技术图片
#!/usr/bin/env python
# -*- coding:utf-8 -*-

def test():
    print(from the test)
module_test.py
 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3  
 4 """
 5 程序目录:
 6     module_test.py
 7     index.py
 8  
 9 当前文件:
10     index.py
11 """
12 
13 import module_test as obj
14 
15 #obj.test()
16 
17 print(hasattr(obj,test))
18 
19 getattr(obj,test)()

 


3 为什么用反射之反射的好处

好处一:实现可插拔机制

有俩程序员,一个lili,一个是egon,lili在写程序的时候需要用到egon所写的类,但是egon去跟女朋友度蜜月去了,还没有完成他写的类,lili想到了反射,使用了反射机制lili可以继续完成自己的代码,等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是,可以事先定义好接口,接口只有在被完成后才会真正执行,这实现了即插即用,这其实是一种‘后期绑定’,什么意思?即你可以事先把主要的逻辑写好(只定义接口),然后后期再去实现接口的功能

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(处理其他的逻辑)

 

 

好处二:动态导入模块(基于反射当前模块成员)

技术图片

 

 好处三:我们现在有服务端和客户端,客户端给服务端发送命令,服务端要根据客户端的命令来执行不同的操作,反射就很好用了。

根据不同的需求,做不同的选择。

class Server:
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port

    def Down(self):
        print("正在下载")
    def Put(self):
        print("正在上传")

class Client:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port
    def InputCmd(self):
        self.Cmd=input("你现在的操作:")
        return self.Cmd
S1=Server("127.0.0.1",8888)
C1=Client("127.0.0.1",8888)
Cmd=str(C1.InputCmd())
getattr(S1,Cmd)()

 

 

三 __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

 

四 二次加工标准类型(包装)

包装:python为大家提供了标准数据类型,以及丰富的内置方法,其实在很多场景下我们都需要基于标准数据类型来定制我们自己的数据类型,新增/改写方法,这就用到了我们刚学的继承/派生知识(其他的标准类型均可以通过下面的方式进行二次加工)

使用技术:继承+派生
我可以使用它本来的所有属性,也对于那些属性做修改,想要添加自己的属性也完全ok。

 

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()

 

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

 

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

调用属性--》先在自己实例的属性里面找--》然后到类里面找--》如果找不到,才会执行__gettattr__()

为什么称为授权:我们自己定义的属性方法,在调用的时候就用自己定义的,(我们在这个定义里,可以不进行操作,)如果没有这个属性,就调用它本身的属性,为什么我们这里没有继承也可以使用它本身的属性
重点是这句话:self.file=open(filename,mode,encoding=encoding),就相当于使用file类实例了一个对象,这个对象也有了类的那些方法。

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()

 

#练习一
class List:
    def __init__(self,seq):
        self.seq=seq

    def append(self, p_object):
         派生自己的append加上类型检查,覆盖原有的append
        if not isinstance(p_object,int):
            raise TypeError(must be int)
        self.seq.append(p_object)

    @property
    def mid(self):
        新增自己的方法
        index=len(self.seq)//2
        return self.seq[index]

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

    def __str__(self):
        return str(self.seq)

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

print(l.mid)

#基于授权,获得insert方法
l.insert(0,-123)
print(l)





#练习二
class List:
    def __init__(self,seq,permission=False):
        self.seq=seq
        self.permission=permission
    def clear(self):
        if not self.permission:
            raise PermissionError(not allow the operation)
        self.seq.clear()

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

    def __str__(self):
        return str(self.seq)
l=List([1,2,3])
# l.clear() #此时没有权限,抛出异常


l.permission=True
print(l)
l.clear()
print(l)

#基于授权,获得insert方法
l.insert(0,-123)
print(l)

 

 

原文链接:https://www.cnblogs.com/konglinqingfeng/articles/9646758.html

 

以上是关于python面向对象编程进阶的主要内容,如果未能解决你的问题,请参考以下文章

Python7 - 面向对象编程进阶

进阶学Python:Python面向对象基础!

Python之路,Day8 - 面向对象编程进阶

Python基础-第七天-面向对象编程进阶和Socket编程简介

Python 进阶 — 面向对象编程

Python 进阶 — 面向对象编程