Python面向物件編程
? 學了這么久的python面向物件編程. 現在做一個系統的總結吧. 本文將按照我學習的順序進行模塊知識點式總結. 文章篇幅較長. 可以通過標簽導航欄進行跳轉查閱. 后期還會補充一個案例 -> 學生選課系統 . 那么直接上代碼了
1.類與物件.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/3 12:00
# @author: Maxs_hu
"""
面向物件編程:
優點: 可拓展性高
缺點: 編程難度提高
"""
# 創建一個類:
class StudentSchool:
school = 'oldboy'
def choose_subject(self):
print("please choose school")
# 類體代碼會在類定義階段就立刻執行，會產生一個類的名稱空間
# print(StudnetSchool.__dict__)
print(StudentSchool.__dict__['choose_subject'](123)) # 通過名稱空間去呼叫函式
StudentSchool.country = 'china' # 添加物件
# print(StudnetSchool.choose_subject(123)) # 直接呼叫
# 1. 類本質就是一個名稱空間. 可以在此名稱空間中進行增刪改查. python定義呼叫的都是類的屬性
school = StudentSchool.school # 查
StudentSchool.school = '池州學院' # 改
StudentSchool.avg = 475 # 增
del StudentSchool.avg # 刪
# 2. 后呼叫類產生物件. 呼叫類的程序稱之為實體化.
# 類就像一個巨大的工廠. 可以產生不同的產品. 這里稱之為一個一個的物件/實體
stu1 = StudentSchool() # 實體化物件. 回傳一個具體存在的物件實體/物件
stu2 = StudentSchool() # 實體化物件. 回傳一個具體存在的物件實體/物件
2.屬性查找.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/6 9:31
# @author: Maxs_hu
class StudentCourse:
# 資料屬性
school = 'oldBoy'
count = 0
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
StudentCourse.count += 1 # 想類的資料屬性發生改變. 不可加上self. 要從類處開始呼叫. 原因在本文最后有介紹
print(self.count)
# 函式屬性
def choose_course(self):
print('is choose course!')
stu1 = StudentCourse('maxs_hu', 10, 'm')
print(stu1.count)
stu2 = StudentCourse('Mokeke', 30, 'w')
print(stu2.count)
# 實作了每次實體化進行計數功能
# 類屬性不會被實體屬性左右. 也可以說成類屬性與實體屬性無關.
# 那么self.count += 1實質就是self有創建了一個新的資料屬性. 且創建的新的資料屬性和舊的資料屬性同名.
# 所以self.count只是訪問到了新的資料屬性的值. 原來的資料屬性沒有發生變化
3.系結方法.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/6 10:08
# @author: Maxs_hu
"""
bound method
"""
class StudentCourse:
# 資料屬性
school = 'oldBoy'
count = 0
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
StudentCourse.count += 1 # 想類的資料屬性發生改變. 不可加上self. 要從類處開始呼叫
# 函式屬性
def choose_course(self):
print(self.name, 'is choose course!')
stu1 = StudentCourse('maxs_hu', 10, 'm')
stu2 = StudentCourse('Mokeke', 20, 'w')
# 類中的函式屬性在用類名進行訪問就是一個普通函式. 該傳值傳值. 在物件中呼叫則是一個系結方法. 不需要傳值
print(StudentCourse.choose_course) # function
print(stu1.choose_course) # bound method
# 在物件中呼叫系結方法. 每一個實體化物件手上都有一個指標. 指向類方法中的地址(好像是每次都重新開辟了一個空間)
print(id(stu1.choose_course))
print(id(stu2.choose_course))
# 系結的效果: 系結給誰. 就應該由誰來呼叫. 誰呼叫就會將誰作為第一個引數傳入self. 將松散的資料集合在一起
# 這樣傳參大大減少了傳參的次數. 可以呼叫到當前物件擁有的資料屬性: self.name self.age ...
stu1.choose_course()
# 類中定義的函式. 類確實可以使用. 但是大多數情況都是系結給物件使用的. 所以前面都默認跟一個self
4.繼承與派生.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/6 10:47
# @author: Maxs_hu
'''
1、什么是繼承
繼承是一種新建類的方式，新建的類稱為子類，被繼承的類稱為父類
繼承的特性是：子類會遺傳父類的屬性
強調：繼承是類與類之間的關系
2、為什么用繼承
繼承的好處就是可以減少代碼的冗余
3、如何用繼承
在python中支持一個類同時繼承多個父類
在python3中
如果一個類沒有繼承任何類，那默認繼承object類
在python2中：
如果一個類沒有繼承任何類，不會繼承object類
新式類
但凡繼承了object的類以及該類的子類，都是新式類
經典類
沒有繼承object的類以及該類的子類，都是經典類
在python3中都是新式類，只有在python2中才區別新式類與經典類
新式類vs經典類?
'''
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
# 物件查找屬性的順序: 物件自己 -> 物件的類 -> 父類 -> 父類
obj = Bar()
obj.f2() # Foo.f2 Bar.f1
# self表示當前當前呼叫的物件本身
5.繼承的應用.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/6 10:49
# @author: Maxs_hu
"""
繼承能別用就盡量別用: 因為他是將兩個甚至更多個類耦合到一起. 叫做強耦合. 與解耦合思想觀念不同. 容易亂
"""
class OldboyPeople:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
class OldboyStudent(OldboyPeople):
school = 'oldBoy'
def choose_course(self):
print(self.name, 'is choosing course!')
class TeacherStudent(OldboyPeople):
school = 'oldBoy'
def __init__(self, name, age, sex, level):
# self.name = name
# self.age = age
# self.sex = sex
OldboyPeople.__init__(self, name, age, sex) # 直接通過類呼叫. 相當于一個普通函式的呼叫
self.level = level
def score(self):
print(self.name, 'is scoring now!')
stu1 = OldboyStudent('maxs_hu', 10, 'male')
print(stu1.__dict__) # {'name': 'maxs_hu', 'age': 10, 'sex': 'male'}
tea1 = TeacherStudent('egon', 30, 'male', 1)
print(tea1.__dict__) # {'name': 'egon', 'age': 30, 'sex': 'male', 'level': 1}
# 再強調一下屬性的尋找順序: 物件自己 -> 物件的類 -> 父類 -> 父類
6.組合.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/7 9:41
# @author: Maxs_hu
"""
什么是組合:
組合就是一個類的物件具備某一個屬性，該屬性的值是指向另外外一個類的物件
"""
class course:
def __init__(self, name, price, period):
self.name = name
self.price = price
self.period = period
def course_info(self):
msg = """
課程名稱: %s
課程價格: %s
課程周期； %s
""" % (self.name, self.price, self.period)
print(msg)
class OldboyPeople:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
class OldboyStudent(OldboyPeople):
school = 'oldboy'
def __init__(self, stu_id, name, age, sex):
super(OldboyStudent, self).__init__(name, age, sex) # 嚴格按照繼承查找. 可以簡寫為super().__init__()
self.stu_id = stu_id
def choose_course(self):
print(self.name, 'is choosing course!')
class OldboyTeacher(OldboyPeople):
school = 'oldboy'
def __init__(self, level, name, age, sex):
OldboyPeople.__init__(self, name, age, sex) # 通過類名指名道姓查找. 相當于呼叫普通函式. 和繼承無關
self.level = level
def score(self, stu, num):
stu.score = num # 為學生設定對應的分數
print("%s正在為%s打%s分" % (stu.name, self.name, num))
# 實體化學生和老師物件
stu1 = OldboyStudent('maxs_hu', 18, 'male', 1)
tea1 = OldboyTeacher('egon', 17, 'male', 10)
# 實體化課程
Python = course('python', 5999, '5mons')
linux = course('linux', 3999, '5mons')
Go = course('go', 6999, '5mons')
# 將課程和學生老師進行組合
stu1.course = Python
tea1.course = linux
# print(stu1.course.__dict__) # {'name': 'python', 'price': 5999, 'period': '5mons'}
# print(stu1.course.name, stu1.course.price, stu1.course.period)
# print(tea1.course.name, tea1.course.price, tea1.course.period)
# 組合呼叫
stu1.course.course_info()
tea1.course.course_info()
# 為一個學生添加很多課程. 將每一個課程詳細資訊都列印出來
stu1.course = []
stu1.course.append(Python)
stu1.course.append(linux)
stu1.course.append(Go)
for item in stu1.course:
item.course_info()
7.菱形繼承問題.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/7 21:08
# @author: Maxs_hu
'''
1、菱形繼承
當一個子繼承多個父類時，多個父類最終繼承了同一個類，稱之為菱形繼承
2、菱形繼承的問題：
python2區分經典類與新式類(新式類繼承了object或object的子類)，如果子的繼承是一個菱形繼承，那么經典類與形式的區別為？
經典類下查找屬性：深度優先查找 -> 一條路走到黑
新式類下查找屬性：廣度優先查找 -> 最后一個找最深的類
'''
class G(object):
# def test(self):
# print('from G')
pass
class E(G):
# def test(self):
# print('from E')
pass
class B(E):
# def test(self):
# print('from B')
pass
class F(G):
# def test(self):
# print('from F')
pass
class C(F):
# def test(self):
# print('from C')
pass
class D(G):
# def test(self):
# print('from D')
pass
class A(B, C, D):
def test(self):
print('from A')
# pass
obj = A()
print(A.mro()) # python呼叫底層的c3演算法生成的mro串列 -> 繼承查找關系
# 遵循三個原則:
# 1.子類會先于父類被檢查
# 2.多個父類會根據他們在串列中的位置被檢查
# 3.對于下一個父類.如果存在兩個合法選擇.則選擇第一個父類(廣度優先)
obj.test() # A->B->E-C-F-D->G->object
8.子類派生和繼承父類的兩種方式.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/7 22:13
# @author: Maxs_hu
"""
1. 指名道姓法: 類名.函式名() -> 和繼承沒有關系
2. super函式: super.方法名() -> 嚴格遵循mro串列的順序
"""
class D:
def f1(self):
print("D.f1")
class C:
def f2(self):
super().f1() # 直接按照mro串列找到D類下的f1
print("C.f2")
class B(C, D):
pass
obj = B()
print(B.mro()) # [<class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>]
obj.f2() # 從B開始呼叫. 所以super是從B開始查找
# D.a
# C.b
9.多型.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/7 23:16
# @author: Maxs_hu
'''
1 什么是多型
多型指的是同一種事物的多種形態
水-》冰、水蒸氣、液態水
動物-》人、狗、豬
2 為和要用多型
多型性：
繼承同一個類的多個子類中有相同的方法名
那么子類產生的物件就可以不用考慮具體的型別而直接呼叫功能
3 如何用
'''
import abc # abstract
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod
def speak(self):
print('11111')
@abc.abstractmethod
def eat(self):
pass
# Animal() # 強調：父類是用來指定標準的，不能被實體化
class People(Animal):
def speak(self):
print('say hello')
def eat(self):
pass
class Dog(Animal):
def speak(self):
print('汪汪汪')
def eat(self):
pass
class Pig(Animal):
def speak(self):
print('哼哼哼')
def eat(self):
pass
peo1 = People()
dog1 = Dog()
pig1 = Pig()
#
#
peo1.speak()
dog1.speak()
pig1.speak()
# def my_speak(animal):
# animal.speak()
#
# my_speak(peo1)
# my_speak(dog1)
# my_speak(pig1)
# python多型的實體
l = [1, 2, 3]
s = 'helllo'
t = (1, 2, 3)
print(l.__len__())
print(s.__len__())
print(t.__len__())
# def len(obj):
# return obj.__len__()
print(len(l)) # l.__len__()
print(len(s)) # s.__len__()
print(len(t))
# python推崇的是鴨子型別，只要你叫的聲音像鴨子，并且你走路的樣子也像鴨子，那你就是鴨子
class Disk:
def read(self):
print('disk read')
def write(self):
print('disk wirte')
class Process:
def read(self):
print('process read')
def write(self):
print('process wirte')
class File:
def read(self):
print('file read')
def write(self):
print('file wirte')
obj1 = Disk()
obj2 = Process()
obj3 = File()
obj1.read()
obj1.write()
10.封裝(1).py
# -*- encoding:utf-8 -*-
# @time: 2022/7/19 9:27
# @author: Maxs_hu
"""
1. 什么是封裝:
封: 屬性對外的是隱藏的. 對內是開放的
裝: 申請一個名稱空間. 并向名稱空間中放置一系列屬性
3. 如何使用封裝
"""
# 怎么進行封裝: 在屬性以__開頭
# 1. 該封裝僅僅只是對語法上的變形操作
# 2. 這種語法的變形只在類定義階段執行一次. 因為類體代碼只在定義階段檢測一次
# 3. 封裝是對內不對外的. 即內部可以訪問. 外部無法直接訪問(只能間接訪問). 因為在定義階段. 類體代碼會因為封裝發生一次變形
class Foo:
__country = 'china' # 加上__ -> 封裝 _Foo__country = 'china'
def __init__(self, name, age):
self.__name = name # self._Foo__name = name
self.age = age
def eat(self):
print("eat...")
print(Foo.__country)
print(self.__name)
Foo.eat(111) # 通過訪問eat. 從而訪問到__country
# print(Foo.__country) # 報錯
peo1 = Foo('maxs_hu', 18)
peo1.eat()
# print(peo1.__name) # 報錯
print(peo1.__dict__) # _Foo__name
# 4. 如果不想讓子類覆寫父類. 可以在父類(子類)前面加上一個__
class Fun:
def __f1(self): # _Fun__f1
print('Fun.f1')
def f2(self):
print('Fun.f2')
self.__f1() # _Fun__f1
class Bar(Fun):
def __f1(self):
print('Bar.f1')
obj = Bar()
obj.f2() # 先呼叫到父類中f2函式. f2中呼叫__f1. self先到子類當中去找. 再到父類中找到__f1
10.封裝(2).py
# -*- encoding:utf-8 -*-
# @time: 2022/7/19 9:27
# @author: Maxs_hu
"""
1. 什么是封裝:
封: 屬性對外的是隱藏的. 對內是開放的
裝: 申請一個名稱空間. 并向名稱空間中放置一系列屬性
3. 如何使用封裝
"""
# 怎么進行封裝: 在屬性以__開頭
# 1. 該封裝僅僅只是對語法上的變形操作
# 2. 這種語法的變形只在類定義階段執行一次. 因為類體代碼只在定義階段檢測一次
# 3. 封裝是對內不對外的. 即內部可以訪問. 外部無法直接訪問(只能間接訪問). 因為在定義階段. 類體代碼會因為封裝發生一次變形
class Foo:
__country = 'china' # 加上__ -> 封裝 _Foo__country = 'china'
def __init__(self, name, age):
self.__name = name # self._Foo__name = name
self.age = age
def eat(self):
print("eat...")
print(Foo.__country)
print(self.__name)
Foo.eat(111) # 通過訪問eat. 從而訪問到__country
# print(Foo.__country) # 報錯
peo1 = Foo('maxs_hu', 18)
peo1.eat()
# print(peo1.__name) # 報錯
print(peo1.__dict__) # _Foo__name
# 4. 如果不想讓子類覆寫父類. 可以在父類(子類)前面加上一個__
class Fun:
def __f1(self): # _Fun__f1
print('Fun.f1')
def f2(self):
print('Fun.f2')
self.__f1() # _Fun__f1
class Bar(Fun):
def __f1(self):
print('Bar.f1')
obj = Bar()
obj.f2() # 先呼叫到父類中f2函式. f2中呼叫__f1. self先到子類當中去找. 再到父類中找到__f1
11.property的使用.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/19 13:24
# @author: Maxs_hu
"""
property裝飾器用于將被裝飾的方法偽裝成一個資料屬性. 在使用時可以不加上括號直接訪問
"""
class Foo:
def __init__(self, name, weight, height):
self.name = name
self.weight = weight
self.height = height
@property # 裝飾成資料屬性.可以不加括號直接呼叫
def bmi(self):
return self.weight / (self.height ** 2)
obj = Foo('maxs_hu', 55, 1.75)
bmi = obj.bmi
print(bmi)
# property和封裝結合: 可以提供給用戶相同的呼叫方式. 但是底層完全不同
class People:
def __init__(self, name):
self.__name = name # 封裝資料屬性
# 新式的寫法
@property # 查詢
def name(self):
return '名字是:%s' % self.__name
@name.setter # 修改
def name(self, name):
self.__name = name
@name.deleter # 洗掉
def name(self):
raise TypeError('不允許洗掉')
# 古老的寫法
# def check_name(self):
# return '名字是:%s' % self.__name
#
# def set_name(self, val):
# self.__name = val
#
# def del_name(self):
# raise TypeError('不允許洗掉')
#
# name = property(check_name, set_name, del_name)
peo1 = People('maxs_hu')
print(peo1.name)
peo1.name = 'xiaoergu'
print(peo1.name)
del peo1.name
12.系結方法與非系結方法.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/19 22:20
# @author: Maxs_hu
'''
1、系結方法
特性：系結給誰就應該由誰來呼叫，誰來呼叫就會將誰當作第一個引數自動傳入
《《《精髓在于自動傳值》》》
系結方法分為兩類:
1.1 系結給物件方法
在類內部定義的函式（沒有被任何裝飾器修飾的），默認就是系結給物件用的
1.2 系結給類的方法：
在類內部定義的函式如果被裝飾器@classmethod裝飾，
那么則是系結給類的，應該由類來呼叫，類來呼叫就自動將類當作第一個引數自動傳入
2、非系結方法
類中定義的函式如果被裝飾器@staticmethod裝飾，那么該函式就變成非系結方法
既不與類系結，又不與物件系結，意味著類與物件都可以來呼叫
但是無論誰來呼叫，都沒有任何自動傳值的效果，就是一個普通函式
3 應用
應該將該函式定義成系結給類的方法
如果函式體代碼需要用外部傳入的物件，則應該將該函式定義成系結給物件的方法
如果函式體代碼既不需要外部傳入的類也不需要外部傳入的物件，則應該將該函式定義成非系結方法/普通函式
'''
# class Foo:
# @classmethod
# def f1(cls):
# print(cls)
#
# def f2(self):
# print(self)
#
#
# obj=Foo()
# print(obj.f2)
# print(Foo.f1)
# Foo.f1()
# print(Foo)
# 1、f1系結給類的
# 了解：系結給類的應該由類來呼叫，但物件其實也可以使用，只不過自動傳入的仍然是類
# print(Foo.f1)
# print(obj.f1)
# Foo.f1()
# obj.f1()
# 2、f2是系結給物件的
# obj.f2()
# Foo.f2(obj)
import settings
import uuid
class Mysql:
def __init__(self, ip, port, net):
self.uid = self.create_uid()
self.ip = ip
self.port = port
self.net = net
def tell_info(self):
print('%s:%s' % (self.ip, self.port))
@classmethod # 類系結方法. cls就是類.
def from_conf(cls):
return cls(settings.IP, settings.NET, settings.PORT) # 這是類系結方法最常用的方式. 使用類初始化方法
@staticmethod # 非系結方法. 相當于普通函式. 該傳遞多少引數就傳遞多少
def func(x, y):
print('不與任何人系結')
@staticmethod
def create_uid():
return uuid.uuid1()
# 默認的實體化方式：類名(..)
obj = Mysql('10.10.0.9', 3307, 27)
obj.tell_info()
# 一種新的實體化方式：從組態檔中讀取配置完成實體化
obj1 = Mysql.from_conf()
obj1.tell_info()
# obj.func(1,2)
# Mysql.func(3,4)
# print(obj.func)
# print(Mysql.func)
# print(obj.uid)
13.補充內置方法.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/20 8:58
# @author: Maxs_hu
# isinstance -> 判斷是否為該實體化
class People:
pass
peo1 = People()
print(isinstance(peo1, People))
d = {1: "1"}
print(isinstance(d, dict)) # 因此不需要用type()判斷資料型別. 有專門的內置方法
# issubclass -> 判斷是否為子類
class Foo:
pass
class Bar(Foo):
pass
print(issubclass(Bar, Foo))
print(issubclass(Foo, object)) # 所有類都繼承object
14.反射.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/20 9:07
# @author: Maxs_hu
"""
1. 什么是反射:
通過字串來操作類或者物件的屬性
2. 如果使用
hasattr
getattr
setattr
delattr
"""
class People:
country = "china"
def __init__(self, name):
self.name = name
def eat(self):
print("%s is eating" % self.name)
peo1 = People('maxs_hu')
# 通過反射尋找實體中是否有某個資料或函式屬性
print(hasattr(peo1, 'country')) # 底層是通過字串'eat'去__dict__中找是否有對應的
print(getattr(peo1, 'eat', None)) # peo1.eat 可在后面直接加()呼叫 如果沒找到直接回傳None
print(setattr(peo1, 'country', 'America')) # peo1.country = 'America'
delattr(peo1, 'country') # del peo1.country
print(peo1.__dict__)
# 安排一個案例
class Mysql:
def __init__(self, ip, port):
self.ip = ip
self.port = port
def get_addr(self):
print('<%s: %s>' % (self.ip, self.port)) # 多個引數的format需要加上括號
def set_addr(self, ip, port):
self.ip = ip
self.port = port
def run(self): # 入口
while True:
choice = input('>>>').strip()
if hasattr(self, choice): # 判斷輸入的是否為實體化物件中的屬性
attr = getattr(self, choice)
attr() # 直接呼叫方法
else:
print('不存在改命令')
obj = Mysql('127.0.0.1', 8888)
obj.run() # 呼叫run()啟動程式
15.自定義類的方法來控制類的功能.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/20 9:51
# @author: Maxs_hu
# __str__方法
class People:
def __init__(self, name, age):
self.name = name
self.age = age
# 在物件被列印的時候. 自動觸發應該在該方法內采集與物件self有關的資訊. 然后拼成字串回傳
def __str__(self):
return '<name:%s age:%s>' % (self.name, self.age) # 必須回傳字串型別
peo1 = People('maxs_hu', 18)
peo2 = People('mokeke', 28)
print(peo1) # peo1.__str__()
print(peo2) # peo2.__str__()
# __del__方法
# del會在物件被洗掉之前自動觸發
class File:
def __init__(self):
self.f = open('a.txt', 'r', encoding='utf-8')
def __del__(self):
# 物件會在程式結束后被自動回收. 但是控制檔案開關的作業系統不會.
# 所以這個del可以用來做系統資源回收的事情
self.f.close()
print('file is closed')
obj = File()
# 若主動洗掉.則會提前回收obj. 輸出file is closed.
# 不主動洗掉. 程式也會在結束的時候自動回收python資源
del obj
print(111)
16.元類.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/21 7:48
# @author: Maxs_hu
"""
1. 什么是元類:
在python中一切皆物件. 那么我們用class關鍵字定義的類本身也是一個物件.
負責產生該物件的類稱之為元類. 即元類可以稱之為類的類
class Foo: # Foo = 元類()
pass
2. 為何要使用元類:
元類是負責產生類的. 所以我們學習元類和自定義元類的目的是為了控制類的產生程序. 還可以控制物件的生產程序
"""
# 一. 知識儲備 -> exec內置的用法
cmd = """
name = "maxs_hu"
age = 18
print("->>>>>")
def eat():
pass
"""
local_dic = {}
exec(cmd, {}, local_dic)
print(local_dic)
# 二. 創造類的方式有兩種
# 大前提: 如果說類也是物件的話. 那么用class關鍵字去創建類也是一個實體化的程序
# 該實體化的目的是為了得到一個類. 呼叫的是元類
# 方式1:使用默認的元類type
class People1: # People = type(...)
country = "china"
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('%s is eating' % self.name)
# 創建類的三個要素: 類名. 基類. 類的名稱空間
# People = type(類名, 基類, 類的名稱空間)
class_name = "People"
class_bases = (object,)
class_dic = {}
cmd = """
country = "china"
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print('%s is eating' % self.name)
"""
exec(cmd, {}, class_dic) # 執行內置函式. 創造名稱空間
People = type(class_name, class_bases, class_dic)
print(People) # <class '__main__.People'>
peo1 = People('maxs_hu', 18)
peo1.eat() # 可以正常實體化和呼叫
# 方式二: 使用自定義的元類
class Mymate(type): # 繼承元類type保留原有代碼
def __init__(self, class_name, class_bases, class_dic):
print(self) # 因為該元類實體化過后為People類. 所以self是People
super(Mymate, self).__init__(class_name, class_bases, class_dic) # 重寫父類功能
# 分析class運行原理:
# 1. 先拿到一個字串格式的類名class_name = 'people'
# 2. 拿到一個類的基類們class_bases = (object,)
# 3. 執行類體代碼. 拿到一個類的名稱空間class_dic = {...}
# 4. 呼叫People = type(class_name, class_bases, class_dic)
class People(object, metaclass=Mymate): # 由自定義的Mymeta創造的一個類 -> People = Mymeta(...)
""" """
country = "china"
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print("%s is eating" % self.name)
print(People.__dict__)
# 應用 -> 使用元類實作功能
# 1. 類的代碼體中必須有檔案中注釋
# 2. 生成自定的類名首字母必須大寫
class Mymate(type):
def __init__(self, class_name, class_bases, class_dic):
if class_dic.get('__doc__') is None or len(class_dic.get('__doc__').strip()) == 0:
raise TypeError('類中必須有文本注釋且不能為只為空格')
if not class_name.istitle():
raise TypeError("類名首字母必須大寫")
super(Mymate, self).__init__(class_name, class_bases, class_dic) # 重寫父類功能
class People(object, metaclass=Mymate):
"""這是一個People類"""
country = "china"
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print("%s is eating" % self.name)
print(People.__dict__)
# 三. 知識儲備 -> __call__的使用 -> 用于元類控制實體的物件的操作
class Bar:
# __call__的觸發是在呼叫實體化物件時
def __call__(self, *args, **kwargs):
print(self)
print(args)
print(kwargs)
obj = Bar()
obj(1, 2, x=3) # 呼叫實體化物件時觸發
17.單例模式的三種實作方式.py
# -*- encoding:utf-8 -*-
# @time: 2022/7/21 15:31
# @author: Maxs_hu
"""
1. 什么是單例模式:
基于某種方法實體化多次得到的是實體是同一個
2. 為何使用使用單例模式:
當實體化多次得到物件中存放的屬性都一樣的情況下. 應該將多個實體化物件指向同一個記憶體.即同一個實體
"""
import setting
# 實作單例的方式一:
# 實體化傳入的資料相同. 且重復多次的實體化. 就可以使用單例模式一次實體化節省名稱空間
class Mysql:
__instance = None
def __init__(self, ip, port):
self.ip = ip
self.port = port
@classmethod # 系結給類的一個方法
def from_conf(cls):
if cls.__instance is None: # 判斷是否已經實體化
cls.__instance = cls(setting.IP, setting.PORT)
return cls.__instance # 只有第一次需要實體化. 后面直接指向之前的名稱空間就行
obj1 = Mysql.from_conf()
obj2 = Mysql.from_conf()
obj3 = Mysql.from_conf()
print(obj1)
print(obj2)
print(obj3)
# 實作單例的方式二(裝飾器):
# 判斷如果沒有引數就按照默認進行實體化. 如果含有引數就按照引數實體化
def singe(cls): # 傳入被裝飾的函式名
_instance = cls(setting.IP, setting.PORT) # 先將實體化放在這里 也可以放到類里面cls.__instance. 這樣類也可以直接訪問到
def wrapper(*args, **kwargs):
if len(args) == 0 and len(kwargs) == 0:
return _instance
# 如果有引數傳入. 則需要按照引數重新實體化并回傳
res = cls(*args, **kwargs)
return res
return wrapper
@singe
class Mysql: # Mysql = singe(Mysql) wrapper = Mysql
def __init__(self, ip, port):
self.ip = ip
self.port = port
obj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql('1.1.1.3', 4323)
print(obj1)
print(obj2)
print(obj3)
"""
obj1: <__main__.Mysql object at 0x00000198D0E40F70>
obj2: <__main__.Mysql object at 0x00000198D0E40F70>
obj3: <__main__.Mysql object at 0x00000198D0E40EE0>
"""
# 實作單例的方式三(元類):
class Mymeta(type): # 利用__init__方法在執行__call__之前將默認實體化物件造出來
def __init__(self, class_name, class_bases, class_dic): # self=Mysql
super(Mymeta, self).__init__(class_name, class_bases, class_dic)
self.__instance = self.__new__(self) # 造出一個Mysql的空物件
self.__init__(self.__instance, setting.IP, setting.PORT) # 從組態檔中加載配置完成Mysql物件的初始化
def __call__(self, *args, **kwargs): # self=Mysql
if len(args) == 0 and len(kwargs) == 0: # 如果無引數傳入
return self.__instance
# 如果有引數傳入. 則需要按照引數重新實體化并回傳
obj = self.__new__(self)
self.__init__(obj, *args, **kwargs)
return obj
class Mysql(object, metaclass=Mymeta): # Mysql=Mymeta(...)
def __init__(self, ip, port):
self.ip = ip
self.port = port
obj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql()
obj4 = Mysql('10.10.10.11', 3308)
print(obj1)
print(obj2)
print(obj3)
print(obj4)
基本代碼注釋都是非常詳細的
后期會基于面向物件實作學生選課系統...
本文來自博客園，作者：{Max}，僅供學習和參考
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/499960.html
標籤：Python
上一篇：Python批量爬取大眾點評資料