1、封裝

什么是封裝？

　　1.對外部隱藏內部的屬性，以及實現細節，給外部提供使用的接口

　　　　注意：封裝有隱藏的意思，但不是單純的隱藏

　　　　學習封裝的目的：就是為了能夠限制外界對內部數據的訪問

　　python中屬性的權限分為兩種：

　　1.公開的

　　　　沒有任何限制，誰都可以訪問

　　2.私有的

　　　　只有當前類本身能狗訪問

　　默認為公共的

為什么要封裝？

　　1.提高安全性

　　　　封裝屬性

　　2.隔離復雜度

　　　　封裝方法

　　一個類中分為兩種數據：屬性和方法

封裝屬性

class Student:

def __init__(self,name,age,gender,id_card):
self.name = name
self.age = age
self.gender = gender
self.__id_card = id_card

def show_id_card(self):
?可以在這里添加額外的任何邏輯代碼 來限制外部的訪問

在類的內部 可以訪問
print(self.__id_card)

對私有屬性的訪問以及修改

class Student:
def __init__(self,name,age,gender,id_card):
self.name = name
self.age = age
self.gender = gender
self.__id_card = id_card

?訪問被封裝的屬性 稱之為訪問器
def get_id_card(self,pwd):
?可以在這里添加額外的任何邏輯代碼 來限制外部的訪問
?在類的內部 可以訪問
if pwd =="123":
return self.__id_card
raise Exception("密碼錯誤!")

?修改被封裝的屬性 稱之為設置器
def set_id_crad(self,new_id):
?身份證必須是字符串類型
?長度必須是18位
if isinstance(new_id,str) and len(new_id) == 18:
self.__id_card = new_id
else:
raise Exception("身份證號碼 必須是字符串 且長度必須為18!")

什么樣的方法應該被封裝起來？

　　一個為內部提供支持的方法，不應該讓外界直接訪問，那就封裝起來，如下例中的 ?user_auth

class ATM:

　　def withdraw(self):

　　　　self.__user_auth()

　　　　self.__input_money()

　　　　self.__save_record()

　　　　# 輸入賬號和密碼
　　　　# 顯示余額
　　　　# 輸入取款金額
　　　　# 保存記錄

　　def __user_auth(self):

　　　　print('請輸入賬號密碼...')

　　def __input_money(self):

　　　　print('余額為1000000000，請輸入取款金額！')

　　def __save_record(self):

　　　　print('記錄流水......')

封裝原理：

python是通過 變形的方式來實現的封裝
如何變形 在名稱帶有雙下劃線開頭的變量名字前添加_類名 如_Person__id_card
當然通過變形后的名字可以直接訪問被隱藏的屬性 但通過不應該這么做
變形僅在類的定義階段發生一次 后續再添加的帶有雙下劃線的任何屬性都不會變形 就是普通屬性

什么時候用？

封裝屬性：

　　當這個對象存在一個機密性的屬性，例：身份證信息，銀行卡密碼等，這樣屬性不應該被外界直接訪問到時就將其封裝。

封裝方法：

　　一個為內部提供支持的方法，不應該讓外界直接訪問，那就將其封裝。

?

Prorety

作用：將一個方法偽裝成普通屬性；用property是為了希望將訪問私有屬性和普通屬性的方式變得一致。

與Prorety相關的兩個裝飾器：

setter:用 . (點)語法給屬性賦值是觸發

deleter:用 . (點)語法刪除屬性時觸發

例：

calss Teacher:

　　def __init__(self,name,age.salary):

　　　　self.name=name

　　　　self.age=age

　　　　self.__salary=salary

　　@property　　# getter ? # 用于訪問私有屬性的值 ? 也可以訪問普通屬性

　　def salary(self):

　　　　return self.__salary

　　@salary.setter　　# 用來設置私有屬性的值 ?也可以設置普通屬性

　　def salary(self):

　　　　self.__salary=new_salary

　　@salary.deleter　　?# 用來設置私有屬性的值 ?也可以刪除普通屬性

　　　　# print("can not delete salary!")

　　　　del ?self.__dict__['Teacher__salary']

Property 計算屬性使用場景：

什么是計算屬性：

　　一個屬性它的值不是固定死的，而是通過計算動態產生的。

class Person：

　　def __inin__(self,name,height,weight):

　　　　self.name=name

　　　　self.height=height

　　　　self.weight=weight

　　@aproperty

　　def ?BMI(self):

　　　　　return sdlf.weight/(self.height**2)

　　@setter

　　def ?BMI(self,new_BMI):

　　　　print('BMI 不支持自定義......')

p=person('egon',1.7,80)

print(p.BMI)

P.BMI=10

?

多態：?多態不是一個具體的技術或代碼，指的是，多個不同類型對象，可以響應同一個方法，產生不同結果

使用多態的好處：

　　只需要學習積累中的使用方法即可，不需要關心具體的哪一個類，實現 ?

　　?以不變應萬變 ?提高靈活性 ?提高擴展性

　　如果沒有多態，需要分別學習 person cat pig 的不同使用方法，這對于使用者而言太麻煩了

　　鴨子類型：就是典型的多態，多重不同類型 使用方法一樣

案例：

class Cat():
　　def bark(self):
　　　　print("喵喵喵")
　　def run(self):
　　　　print("四條腿跑!")
　　def sleep(self):
　　　　print("趴著睡!")

class Pig():
　　def bark(self):
　　　　print("哼哼哼!")
　　def run(self):
　　　　print("四條腿跑!")
　　def sleep(self):
　　　　print("側躺著睡!")

# 一個用來管理動物的方法 只要你傳入是一個動物 我就按照動物的標準來使用 完全不用考慮你具體是什么類型
def management_animal(animal):
　　print("==================正在溜%s=============" % animal.__class__.__name__)
animal.bark()
animal.run()
animal.sleep()

?

常用的內置函數

__str__

對象轉成字符串是被強制執行

__del__

__del__:當對象被刪除前會自動調用 ，該方法聲明時候會刪除對象？

　　　　1.程序運行結束，解釋器退出，將自動刪除所有數據

　　　　2.手動調用del 時也會刪除對象

　　　　注意：該函數不是用來刪除對象的

使用場景：

　　當你的對象在創建時，開啟了不屬于解釋器的資源，例如打開一個文件必須保證對象被刪除時，

同時關閉額外的資源，如文件。

__del__也稱之為析構函數，析構，構造的反義詞

　　構造：值得是從無到有

　　析構：至從有到無

　　簡單的說就對象所有數據全部刪除

總結：__del__該函數，用于在對象刪除前做一些清理操作

class Person:
　　def __init__(self,name,path,mode="rt",encoding="utf-8"):
　　　　self.name = name
　　　　self.file = open(path,mode,encoding=encoding)

?

# 讀取數據的方法
def read_data(self):
　　return self.file.read()

def __del__(self):
　　print("del run!")
　　self.file.close()

?

反射（英文中叫反省，自省）

　　面向對象中的反省值的是，一個對象必須具備，發現自身屬性，以及修改自身屬性的能力

　　一個對象在設計初期，可能考慮不夠周全后期需要刪除或修改已經存在的屬性，和增加屬性

反射就是通過字符串來操作對象屬性

涉及到方法：

hasattr 判斷是否存在某個屬性

getattr 獲取某個屬性的值

setattr 新增或修改某個屬性

delattr 刪除某個屬性

案例:

class MY_CMD:
?
 ? ?def dir(self):
 ? ? ? ?os.system("dir")
?
 ? ?def ipconfig(self):
 ? ? ? ?os.system("ipconfig")
?
cmd = MY_CMD()
?
while True:
 ? ?name = input("請輸入要執行的功能:")
 ? ?if hasattr(cmd,name):
 ? ? ? ?method = getattr(cmd,name)
 ? ? ? ?print(method)
 ? ? ? ?method()
 ? ?else:
 ? ? ? ?print("sorry this method is not exists....!")

?

動態導入模塊

直接寫import 稱之為靜態導入 建立在一個基礎上:提前已經知道有這個模塊
動態導入 指的是 在需要的任何時候 通過指定字符串類型的包名稱來導入需要的模塊
import importlib
mk = importlib.import_module(m_name)
mk 即導入成功的模塊
"""
該方式常用在框架中 因為框架設計者不可能提前預知后續需要的模塊和類

?

?

?

?

　　

轉載于:https://www.cnblogs.com/sry622/p/10896914.html

總結

以上是生活随笔為你收集整理的第二十五章 面向对象------封装、内置函数、反射、动态导入的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。