1.面向物件
??面向物件編程是在面向程序編程的基礎上發展來的，它比面向程序編程具有更強的靈活性和擴展性，所以可以先了解下什么是面向程序編程：
??面向程序編程的核心是程序，就是分析出實作需求所需要的步驟，通過函式一步一步實作這些步驟，接著依次呼叫即可，再簡單理解就是程式
??從上到下一步步執行,從頭到尾的解決問題；
??而面向物件編程是把構成事物的整個需求按照特點、功能劃分，將這些存在共性的部分封裝成物件，創建物件的目的不是為了完成某一個步驟，
??而是為了描述某個事物在整個解決問題的步驟中的行為， ????
??eg： 小明用美的洗衣機洗臟衣服，流程是怎樣的？
??面向程序的解決方法：
????1、執行加洗衣液方法；
????2、執行開啟洗衣機方法；
????3、執行加水方法；
????4、執行洗衣服方法；
????5、執行甩干方法；
????6、取出衣服；
????以上就是將解決這個問題的程序拆成一個個方法，通過按順序執行方法來解決問題，
??面向物件的解決方法：
????1、可以先歸納出兩個物件：“美的洗衣機”物件和“小明”物件
????2、針對物件“美的洗衣機”加入一些它的方法：“自動注水方法”“洗衣方法”、“烘干方法”
????3、針對物件“小明”加入他的方法：“加洗衣液方法”、“開啟洗衣機方法”、“取出衣服方法”
????4、然后執行，使用物件.動作 的方式，執行各步驟
????小明.加洗衣液
????小明.開啟洗衣機
????美的洗衣機.自動注水
????美的洗衣機.洗衣服
????美的洗衣機.烘干
????小明.取出衣服
????解決同一個問題 ，面向物件編程就是先抽象出物件，然后用物件執行方法的方式解決問題，
2.類
??如果想通過面向物件編程，首先需要創建一個類(class)，才能實體化（或叫具象化）物件；
??（洗衣例子中要先有人這個類，才能有“小明”物件、先有洗衣機類，才能有“美的洗衣機”這個物件）
??類可以理解成一個模板，通過它可以創建出無數個具體實體（物件）；
??使用類的關鍵字class，來宣告類，首字母大寫，多個單詞時每個單詞首字母要大寫（駝峰命名法）；
??eg： class MyName(object):
??????(object)可以不寫，object是python中的一個通用物件，添加它后可以使用更多的內置功能；
class Test(object):
name = 'test' # 定義一個類屬性
def run(self):
print(f'{self.name}在跑步!')
xiaoming = Test() # 實體化一個物件xiaoming
print(xiaoming.name) # 物件xiaoming可以呼叫類屬性
xiaoming.run() # 物件xiaoming可以呼叫類方法
'''
test
test在跑步!
'''??類的引數self
??可以看到類的方法中默認第一個引數是self，且是必填的；（python中的self關鍵字只用于類的方法中）；
??self也是一個物件，它代表實體化變數(例子中的xiaoming)本身（xiaoming可以呼叫name屬性和run方法，都是self幫助找到的）
class Person(object):
name = None # 類屬性（也叫類實體化屬性）
age = None
def run(self):
print('可以直接使用self呼叫類屬性')
print('列印屬性:'+str(self.name))
a = 'new' # 類方法中定義的變數無self時，屬于方法中的區域變數
print('列印區域變數:'+a)
def work(self):
print('利用self可直接呼叫類中其它類函式')
self.run()
def jump():
print('不添加self引數，就不屬于類函式，就不可以被實體化的物件呼叫')
# 實體化一個物件xiaoming
xiaoming = Person()
# 可以直接呼叫類屬性（類實體化屬性）
print(xiaoming.name) # None
# 也可為類屬性（類實體化屬性）重新賦值
xiaoming.name = 'xiaoming'
# 呼叫類方法, 呼叫時無需傳遞self引數值
xiaoming.work()
'''
利用self呼叫類中其它函式
可以直接使用self呼叫類屬性
列印屬性:xiaoming （此時類屬性值已被實體化物件修改）
列印區域變數:new
'''
# print(xiaoming.a) # AttributeError: 'Person' object has no attribute 'a' 方法中的區域變數不可被實體化物件呼叫
# 實體化另一個物件xiaohong
xiaohong = Person()
print(xiaohong.name) # None # 物件xiaohong并不會使用到物件xiaoming修改的類屬性（類實體化屬性）值;物件修改的類屬性（類實體化屬性），只能作用于物件本身
xiaohong.jump() # 非類函式無法被物件呼叫，直接報錯
'''
Traceback (most recent call last):
File "D:\python_exercise\test_calss.py", line 44, in <module>
xiaohong.jump()
TypeError: Person.jump() takes 0 positional arguments but 1 was given
'''
# 可以看到報錯資訊是函式無引數值，卻被傳遞了一個，說明物件在呼叫方法時，自動傳遞了self引數，所以直接報錯了
3.類的建構式
??類中的一種默認函式，用來將類實體化的同時，將引數傳入類中；（類似于函式執行時，可以傳一些引數）
??def __init__(self, a, b):
????self.a = a # 類實體化物件的屬性
????self.b = b
??此時self.a和self.b就可以在類的各個類函式中使用了；
class Person(object):
def __init__(self, name):
self.name = name # self.宣告的變數是類實體屬性
def run(self):
print(f"{self.name}在跑")
test = Person('x')
test.run() # x在跑
'''
此時已經見過了類中可定義的多種變數
類下直接定義的變數，屬于類屬性、又屬于類實體化物件屬性 （可被實體化后的物件直接參考）
建構式中self.開頭定義的屬性，屬于類實體化物件屬性，不屬于類屬性（可被實體化后的物件直接參考）（作業中多用，且多在建構式中提前定義好）
類函式中a=''定義的變數，屬于區域變數，既不屬于類實體化物件屬性，也不屬于類屬性（不可被實體化后的物件直接參考）
'''
4.物件的生命周期
??一個物件從出生到消亡的程序；
??實體化物件后，會呼叫內置函式__init__, 此時物件生命開始，該物件會被記憶體分配一個記憶體塊；
??物件不再使用類中的方法屬性時、或整個腳本結束執行時，物件會自動呼叫內置函式__del__通知記憶體管家，從記憶體中釋放占用的記憶體塊，物件生命結束；
??無論是數字、字串、串列、元組等物件，生命周期皆是如此；
??python中會讓物件自動呼叫__del__的操作，無需在程式中書寫；
??__def__所有這種書寫形式的方法，都是類的內置函式，定義類時書寫object（class Name(object)），就可以呼叫這些內置函式了，
5.私有函式和私有變數
??私有：獨有的、不公開；
??無法被實體化后的物件呼叫的類中的函式和變數，就是私有函式、私有變數；
??類的內部可以在類函式中呼叫私有函式和私有變數；
??使用場景：某一方法只希望內部業務呼叫使用，不希望被使用者呼叫；
??定義方法：在類函式、類變數前添加__ (兩個下劃線)；
class Cat(object):
def __init__(self, name):
self.name = name
self.__sex = 'boy' # 私有類實體化屬性
def run(self):
# 類函式可以呼叫私有函式
self.__run(self.__sex)
# 私有函式
def __run(self, sex):
# 私有函式可以使用類實體化屬性
print(f'{self.name}，是個{sex}，它在跑!')
cat = Cat('ll')
cat.run() # ll，是個boy，它在跑!
# 物件不可呼叫私有函式,直接報錯
# cat.__run() # AttributeError: 'Cat' object has no attribute '__run'
# 也有可呼叫的方法，但既然創建了私有函式、私有變數，建議遵守使用規則
print(dir(cat)) # 列印所有類的內置函式，就可以看到私有函式的呼叫名了
'''
['_Cat__run', '_Cat__sex', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__',
'__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'run']
'''
cat._Cat__run('girl') # ll，是個girl，它在跑!
print(cat._Cat__sex) # boy
6.python中封裝
??python中封裝的概念：
????我們在類中把某些屬性和方法隱藏起來、定義為私有，只能在類的內部使用，外部無法訪問，或者留下少量的介面（函式）供外部訪問，就是封裝的概念；
????這樣做的目的是為了保護隱私、明確區分內外，
7.類的裝飾器
??裝飾器也是一種函式；
??它可以接收函式作為引數；且可以回傳一個函式；
??接收一個函式，內部對其進行處理，然后回傳一個新函式，動態的增強函式功能；
# 簡單梳理下裝飾器的大概由來
# 有一個業務函式print_test()
def print_test(info):
print('業務函式'+info)
'''
此時想在執行業務函式前后增加日志輸出,
且有多個類似的業務函式需要完成同樣的操作，
可以撰寫另一個公用函式，以業務函式為引數，業務函式前后完成相應日志輸出
'''
def add_info(func, info):
print('開始的日志')
func(info)
print('結束的日志')
# 執行add_info
add_info(print_test, 'test')
'''
開始的日志
業務函式test
結束的日志
'''
# 但是這樣改變了原有的print_test(info)完成業務操作的寫法，可以借助裝飾器寫法優化下
def add_info_new(func):
def wrapper(*args, **kwargs):
print('列印開始的日志')
func(*args, **kwargs)
print('列印結束的日志')
return wrapper
print_test = add_info_new(print_test)
print_test('test')
'''
列印開始的日志
業務函式test
列印結束的日志
'''
# python中可以借助@語法糖，優化上面print_test = add_info_new(print_test)的寫法
@add_info_new
def print_test_final(info):
print('借助語法糖的業務函式'+info)
print_test_final('test')
'''
列印開始的日志
借助語法糖的業務函式test
列印結束的日志
'''
# 裝飾器呼叫時，也可以傳遞引數，對業務處理進行再次的判斷
def add_print_args(handle):
def decorator(func):
def wrapper(*args, **kwargs):
print('依舊執行前列印日志')
func(*args, **kwargs)
print('依舊執行后列印日志')
if handle:
print('額外處理')
return wrapper
return decorator
@add_print_args(handle=True)
def print_test_args(info):
print('列印一下'+info)
print_test_args('test')
'''
依舊執行前列印日志
列印一下test
依舊執行后列印日志
額外處理
'''
'''
使用裝飾器后，被裝飾函式的元資訊會被修改，例如__name__, doc等
'''
print(print_test_args.__name__)
# wrapper （這里也很好理解，已經被回傳成新的裝飾函式了）
'''
若想保存元資訊不變，
可以使用wrap庫，from functools import wraps
wraps也是一個裝飾器，它是把原函式元資訊拷貝到了裝飾器函式中
'''
from functools import wraps
def add_print_wrap(func):
@wraps(func)
def wrapper(*args, **kwargs):
print('執行前列印')
func(*args, **kwargs)
print('執行后列印')
return wrapper
@add_print_wrap
def print_test_wrap(info):
print('業務函式'+info)
print_test_wrap('test')
print(print_test_wrap.__name__)
'''
執行前列印
業務函式test
執行后列印
print_test_wrap
'''
'''
類裝飾器
通過內置函式__call__處理額外操作
'''
class AddPrint(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print('開始的列印foo')
self.func(*args, **kwargs)
print('結束的列印foo')
@AddPrint
def print_test_foo(info):
print('業務函式'+info)
print_test_foo('test')
'''
開始的列印foo
業務函式test
結束的列印foo
'''
'''
類裝飾器也可以通過傳參欄位外操作
'''
class Foo(object):
def __init__(self, handle):
self.handle = handle
def __call__(self, func):
def wrapper(*args, **kwargs):
print('執行前操作')
func(*args, **kwargs)
print('執行后操作')
if self.handle:
print('額外操作')
return wrapper
@Foo(handle=True)
def print_test5(info):
print('業務操作'+info)
print_test5('test')
'''
執行前操作
業務操作test
執行后操作
額外操作
'''??
8.幾種內置的常見裝飾器
??@classmethod
??將類的函式定義為可以不經過實體化而直接被呼叫；此時可以不實體化，直接呼叫該方法；
class Foo(object):
def __init__(self, a):
self.a = a
def run(self):
print('run')
@classmethod
def jump(cls):
print('jump')
# 此時self被替換成cls，代表類本身
# Foo.run()
'''
Traceback (most recent call last):
File "D:\python_exercise\test5.py", line 21, in <module>
Foo.run()
TypeError: Foo.run() missing 1 required positional argument: 'self'
因為正常我們實體化的時候，python會自動幫我們將self引數傳遞進去
此時沒有實體化，所以報錯沒有傳self引數
'''
Foo.jump() # jump
# 類函式就可以不用實體化直接呼叫了??cls函式不可參考self函式
class Foo(object):
def __init__(self, a):
self.a = a
def run(self):
print('run')
@classmethod
def jump(cls):
print('jump')
cls.run()
Foo.jump()
'''
TypeError: Foo.run() missing 1 required positional argument: 'self'
'''??self函式可以參考cls函式
class Foo(object):
def __init__(self, a):
self.a = a
def run(self):
print('run')
self.jump()
@classmethod
def jump(cls):
print('jump')
foo = Foo('test')
foo.run()
foo.jump() # 實體化物件也可使用cls函式
'''
run
jump
jump
'''??@staticmethod
??將類函式定義為可以不經過實體化而直接被呼叫，且該函式不需要傳遞self或cls，且無法在該函式內呼叫其它類函式或類變數；
class Foo(object):
def __init__(self):
pass
def run(self):
print('run')
self.jump()
@staticmethod
def jump():
print('jump')
Foo.jump() # jump
foo = Foo()
foo.jump() # jump (也可以通過物件呼叫)
foo.run() # static函式也可以被其它類函式呼叫
'''
run
jump
'''??@property
??將類函式的呼叫免去括弧，類似于呼叫屬性；
class Foo(object):
@property
def run(self):
print('run')
foo = Foo()
foo.run # run??同樣使用這種呼叫方法，需要傳參時，有自己的寫法；
class Foo(object):
@property
def run(self):
print('run')
@run.setter
def run(self, info):
print(info)
foo = Foo()
foo.run = 'test info' # test info
9.類的繼承
??通過繼承，子類可以擁有父類所有的屬性和方法；
??父類不具備子類自有的屬性和方法；
??定義方法 class Child(Parent): Child類繼承Parent類；
class Parent(object):
def __init__(self, name, age):
self.name = name
self.age = age
def walk(self):
print(f'{self.name}在行走')
class Child(Parent):
def run(self):
self.walk() # 子類可以呼叫父類的方法
print(f"{self.name}在跑步") # 子類可以直接呼叫父類的屬性
child = Child('ll', 13) # 繼承父類后，父類的初始化引數子類也要傳遞
child.walk() # ll在行走 (子類實體化物件可以呼叫父類的方法)
child.run()
'''
ll在行走
ll在跑步
'''??
10.類的多型
??子類繼承父類后，對于父類中的同一功能可以表現出多狀態變化（多種執行方式、結果等），且是通過子類對父類方法的重寫實作的；
class Parent(object):
def __init__(self, name):
self.name = name
def walk(self):
print('父類在行走')
class Child(Parent):
def walk(self):
print('子類在行走')
child = Child('兒子')
child.walk() # 子類在行走
'''
為什么要繼承
為了使用已經寫好的類中的方法
為什么要多型
為了保留子類中和父類名稱相同的函式的功能
'''
11.python中的super函式
??在子類重新書寫父類方法時，此時想既保留父類方法的邏輯、同時增加新邏輯，就可以借助super函式；
??用法：super(當前類，self(類的實體)).父類的方法()；python3.0時代，super()中兩個引數可以省略；
class Parent(object):
def __init__(self, name):
self.name = name
print('父類建構式'+self.name)
class Child(Parent):
def __init__(self, name, age):
super(Child, self).__init__(name)
self.age = age
print('子類新的建構式'+str(self.age))
child = Child('xiaoming', 23)
'''
父類建構式xiaoming
子類新的建構式23
'''
# 例子中子類對于父類中的建構式引數進行了擴充，在作業中很常用
12.類的多重繼承
??子類可以繼承多個父類；
??class Child(Parent, Parent2, Parent3...):
class Father(object):
def run(self):
print('父親跑')
def walk(self):
print('父親走')
class Mother(object):
def run(self):
print('母親跑')
def sing(self):
print('母親唱')
class Child(Father, Mother):
pass
child = Child()
child.sing() # 母親唱
child.run() # 父親跑 (多個父類有重名方法時，優先繼承寫在第一位的類)
print(Child.__mro__) # (<class '__main__.Child'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class 'object'>)
'''
__mro__ 方法可以列印類的繼承鏈
'''??
13.類的幾個高級函式
??__str__ 回傳類的描述資訊；
class Test(object):
pass
test = Test()
print(test) # <__main__.Test object at 0x00000298AC9264D0>
class Test2(object):
def __str__(self):
return 'this is a test class'
test2 = Test2()
print(test2) # this is a test class??__getattr__ 當呼叫的屬性或方法不存在時，會回傳該方法定義的資訊；
class Test(object):
pass
test = Test()
print(test.a) # 呼叫類的屬性不存在時，會直接報錯
'''
Traceback (most recent call last):
File "D:\python_exercise\test7.py", line 14, in <module>
print(test.a)
AttributeError: 'Test' object has no attribute 'a'
'''
class Test2(object):
def __getattr__(self, item):
return f'{item}不存在'
test2 = Test2()
print(test2.a) # a不存在??__setattr__ 攔截當前類中不存在的屬性和值，并做處理；
class Test(object):
def __init__(self, name, age):
self.name = name
self.age = age
def __setattr__(self, key, value):
print(key, value)
# 列印所有的屬性字典
print(self.__dict__)
self.__dict__[key] = value
print(self.__dict__)
test = Test('xiao', 32)
test.sex = 'boy'
print(test.sex)
'''
name xiao
{}
{'name': 'xiao'}
age 32
{'name': 'xiao'}
{'name': 'xiao', 'age': 32}
sex boy
{'name': 'xiao', 'age': 32}
{'name': 'xiao', 'age': 32, 'sex': 'boy'}
boy
'''
# 可以看到每一次生成新的屬性，都會呼叫__setattr__方法，無論是在建構式，還是在實體物件test.sex = 'boy'
test.name = 'new_xiaoming'
# 也可修改原屬性的值
'''
{'name': 'new_xiaoming', 'age': 32, 'sex': 'boy'}
'''??__call__ 將實體化物件直接變成函式使用；
class Test(object):
def __call__(self, *args, **kwargs):
print(f'call 函式開始: {args[0]}')
test = Test()
test('test') # call 函式開始: test# eg: 撰寫一個可以通過 物件.a.b.c() 執行的類
class Test(object):
def __init__(self, args=''):
print('------')
self.args = args
def __getattr__(self, item):
print('開始的item:'+item)
print('self.args:'+self.args)
if self.args:
item = f'{self.args}.{item}'
print('后來的item:'+item)
return Test(item)
def __call__(self, *args, **kwargs):
print('ttttt')
test = Test()
test.a.b.c() # ttttt
'''
------
開始的item:a
self.args:
后來的item:a
------
開始的item:b
self.args:a
后來的item:a.b
------
開始的item:c
self.args:a.b
后來的item:a.b.c
------
ttttt
'''
總結
??
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/538809.html
標籤：其他