2. 程式人生 > >python面向對象編程進階

python面向對象編程進階

阿新 • • 發佈：2019-04-11
成員 ron down attr python property pri sel 類型

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面向對象編程進階

相關推薦

python面向對象編程進階

成員 ron down attr python property pri sel 類型 python面向對象編程進階 一.isinstance(obj,cls)和issubclass(sub,super) isinstance(obj,cls)檢查是否obj是否是

Python基礎-第七天-面向對象編程進階和Socket編程簡介

python本篇內容：1.面向對象編程進階-靜態方法2.面向對象編程進階-類方法3.面向對象編程進階-屬性方法4.面向對象編程進階-特殊成員（內置方法）5.面向對象編程進階-反射6.異常處理、斷言7.Socket編程簡介一、面向對象編程進階-靜態方法1.靜態方法的實現通過@staticmethod裝飾器可以把

Python面向對象編程（一）

過程 函數名 err 沒有 什麽是 概念 end 流程 三個參數 1.什麽是面向對象 面向對象（oop）是一種抽象的方法來理解這個世界，世間萬物都可以抽象成一個對象，一切事物都是由對象構成的。應用在編程中，是一種開發程序的方法，它將對象作為程序的基本單元。 2.面向對象與面

python---面向對象高級進階

刪除數據 name 兩個 構造 hasattr def method res 錯誤類型 靜態方法，調用靜態方法後，該方法將無法訪問類變量和實例變量 1 class Dog(object): 2 def __init__(self,name): 3

Python 面向對象編程——初見

pla 系統 tag simpson spl font 傳遞 sans ref <什麽是面向對象> 面向對象編程(Object Oriented Programming)，簡稱OOP，是一種程序設計思想。OOP把對象作為程序的基本單元，一個對象包含了數

python面向對象基礎語言進階

python在此感謝前輩們的指導：http://python.jobbole.com/80955/ https://www.cnblogs.com/wupeiqi/p/4766801.htmlhttps://www.cnblogs.com/paomaliuju/p/5122761.html https://w

python面向對象編程 -- 基本概念（python3.5）

模塊 屬性和方法 class example 擴展 clas 3.5 通過 val 面向對象的編程簡要概括就是將要處理的問題抽象為數據和操作的集合，用類對其進行封裝。其中數據和操作都稱為類的屬性，它們是一般是不變的。 對類進行實例化生成我們所說的對象，對象有自己的屬性。對

python面向對象編程 -- 封裝、繼承（python3.5）

style 單調性 dict bsp 細節 劃線 private sel 搜索 面向對象編程三要素：封裝、繼承和多態。本文主要看和封裝、繼承相關的概念；在python中多態的概念比較模糊，本文不做討論。 1 封裝 封裝：將數據和操作組裝到一起，對外只暴露一些接口供類外部或

Python面向對象編程、類

list 所有 透明 多人 應該 喜歡 clas 更新 構造 一、面向對象編程 面向對象--Object Oriented Programming，簡稱oop，是一種程序設計思想。在說面向對象之前，先說一下什麽是編程範式，編程範式你按照什麽方式來去編程，去實現一個功能。舉個

python學習之路-第七天-python面向對象編程簡介

構造函數 represent eth 賦值 nts 數據 and 面向 七天 面向對象編程 在python中，同樣是類和對象作為重要的組成部分。 而且在python中基本數據類型如int都是有封裝類的，都有自己的方法，應該是和java裏面的Integer類似吧 類包括域和方

Python——獻給那些對Python面向對象編程不知如何應用的同學們

也看 boot class 自己 utf earch 安裝 過多 是不是 面向對象，看似不難。有的同學學過之後，還是不知道如何去使用它。有時候編寫代碼，寫著寫著就遇到坑了，比如寫著寫著就連你自己也在懷疑到底是不是面向對象編程了。 因此，本人想了一個比較簡單的例

Python面向對象編程 --- 類的定義

代碼 繼承 class 被調用 數據屬性 == string strong 面向對象 面向對象編程 — 類定義與實例化 類中的變量是類的數據屬性，函數為類的方法(函數)屬性 類定義的所有變量和函數都會被存在dict的字典中(命名空間) 類在定義之後代碼就可以被執

Python面向對象編程 綁定方法

bject style con fence pytho name people block body 類的函數屬性綁定給不同對象，是不同的綁定方法。對象調用綁定方法時會把對象本身當做self參數傳入 示例代碼 class People: country = ‘Ch

Python--面向對象編程

綁定屬性 參數 del body color 初始化 post 綁定 clas class Car(object): # 模型，模板 def __init__(self, color, window): # 構造函數，類在初始化的時候會執行它，順序無所

Python 面向對象編程

默認 urn 關鍵字 千萬 範圍 class a 靜態 dog 打印 一，類和實例 1，類是創建實例的模板，而實例則是一個一個具體的對象，各個實例擁有的數據都互相獨立，互不影響； class Student(object): pass 定義類：定義類是通過class

python-面向對象編程設計與開發

代碼 register enc margin opened 用戶名 == inpu code 編程範式 1、對不同類型的任務，所采取不同的解決問題的思路。 2、編程範式有兩種 　　1、面向過程編程 　　2、面向對象編程 面向過程編程 什麽是面向過程編程？ 過程——解決問題

python-面向對象編程小結

擴展性 handle one 每次 內容 屬性 mys PQ play 面向對象編程有到底有什麽好處呢？ 1、將數據與操作改數據的功能整合在一起。 　　A:以前我們操作數據庫的方式如下： 　　 1、通過定義數據庫操作的函數。 　　 2、每次操作時寫傳數據庫的參數和所要操作的

python學習【第九篇】python面向對象編程

同名方法 ron 重寫 結構 程序 如果 覆蓋 -a base 一、面向對象了解 　　面向對象編程——Object Oriented Programming，簡稱OOP，是一種程序設計思想。OOP把對象作為程序的基本單元，一個對象包含了數據和操作數據的函數。 　　Pytho

Python面向對象編程之我見

Python 面向對象 面向對象基本概念 面向對象是一種編程範式。範式是指一組方法論。編程範式是一組如何組織代碼的方法論。編程範式指的是軟件工程中的一種方法學。 一些主流的編程範式： OOP - 面向對象編程 世界觀：一切皆對象。 FP - 函數式編程 世界觀：一切皆函數。一般指無副作用的函數

python面向對象編程習題一

修改用戶 obj 模塊 反序 init 獲取 tin 是否 操作 1.編寫程序, 編寫一個學生類, 要求有一個計數器的屬性, 統計總共實例化了多少個學生 class Student: """學生類""" count = 0 # 計數 def _