⑴ python之面向對象
面向對象（OOP）是一種對現實世界理解和抽象的方法，對象的含義是指在現實生活中的具體事物， 一切皆對象 ，Python 是一門面向對象的語言，面向對象編程簡單來說就是一種 封裝代碼 的方式。
Python 中類的定義使用 class 關鍵字定義類，語法如下所示：
舉例，定義一個類 Cat
構造方法 init() 會在類實例化時自動調用。無論構造方法還是其他方法都需要將 self 作為第一個參數，它代表類的實例。
類創建好後，可以直接通過類名訪問屬性，格式為： 類名.屬性名 ，比如我們訪問 Cat 類的 color 屬性，如下所示：
創建對象也稱類的實例化，比如我們通過 Cat 類創建對象，如下所示：
創建好對象後,使用它訪問屬性和調用方法了，如下所示：
內部私有屬性和方法是可以被訪問和調用的。
我們來一起看個例子，如下所示：
輸出結果：
Python 支持類的繼承，而且支持多繼承，語法格式為：
示例如下所示：
如果繼承的父類方法不能滿足我們的需求，這時子類可以 重寫 父類方法，如下所示：
⑵ python如何理解對象方法
類是面向對象程序設計的一部分。面向對象程序設計或者簡稱為 OOP 致力於創建可重用代碼塊稱之為類。當你想在你的程序中使用類時，你會從類中創建一個對象，這也是面向對象一詞的由來。Python 並不總是面向對象的，但是你會在你的項目中用到對象。
⑶ Python其實很簡單 第十五章 文件操作
在各種變數中保存的數據都是臨時的，隨著程序運行結束都會丟失。要做到數據長期有效，必須建立在磁碟中建立文件，將數據輸入到文件中並保存。需要獲取數據時需要打開文件讀取。
而我們自己建立的程序都是應用程序，從本質上講，應用程序是無法直接操作計算機的硬體的，譬如讀寫磁碟中文件，這就需要調用操作系統中的相應命令。接下來我們使用的Python內置函數open()、write()都是通過調用操作系統的相關命令才實現文件讀寫的，至於其中的細節，我們就不需要考慮了。
15.1創建和打開文件
在Python 中創建或打開文件，實際上是建立一個對象，該對象通過調用內置的open()函數創建或打開一個文件。
語法：
file object = open(filename [, mode][, buffering])
參數說明如下：
filename：file_name變數是一個包含了你要訪問的文件名稱的字元串值；
mode：mode決定了打開文件的模式：只讀，寫入，追加等。所有可取值見如下的完全列表。這個參數是非強制的，默認文件訪問模式為只讀(r)。
Buffering：如果buffering的值被設為0，就不會有寄存；如果buffering的值取1，訪問文件時會寄存行；如果將buffering的值設為大於1的整數，表明了這就是的寄存區的緩沖大小；如果取負值，寄存區的緩沖大小則為系統默認。
mode參數的參數值及說明
對於其中最難區別的r、r+、w、w+、a、a+幾個參數的區別總結如下，要特別注意指針的位置：
下面舉例說明open( )函數的使用方法。
例1：
>>> file=open(Ƈ.py')
如果文件「1.py」存在，則可以打開此文件；如果文件「1.py」不存在，則會出現如下提示：
Traceback (most recent call last):
File " ", line 1, in
file=open(Ƈ.py')
FileNotFoundError: [Errno 2] No such file or directory: Ƈ.py'
例2：
>>> file=open(Ɗ.py',』a+』)
雖然文件「4.py」不存在，但運行並未出現錯誤，參見上表，「a+」的含義是以讀寫模式打開文件，如果該文件已經存在，新內容將以追加方式寫入；如果該文件不存在，則新建文件用於寫入。查看文件夾，發現已經生成了一個新的文件4.py。
例3：
file=open('python.png','rb')
print(file)
運行結果：
這就是說，雖然Python可以打開一個圖片格式的文件，但print()並不能將其輸出，還需要第三方庫中模塊的相應方法去處理，如PIL中的open()f方法。
例4：
file = open("f.txt", "w",encoding='utf-8')
# 以只寫模式打開文件f.txt，編碼方式為utf-8
print( "文件名: ", file.name) # 輸出文件名
print( "是否已關閉 : ", file.closed) # 文件是否打開
print( "訪問模式 : ", file.mode) # 文件訪問模式
運行結果：
文件名: f.txt
是否已關閉 : False
訪問模式 : w
例5：
15.2關閉文件
打開文件使用後要及時關閉，以免造成不必要的破壞，同時也可以釋放內存。在Python中使用close()方法可以關閉文件。
語法格式：
file.close()
其中，file為文件對象。
15.3 with語句
with 語句適用於對資源進行訪問的場合，確保不管使用過程中是否發生異常都會執行必要的「清理」操作，釋放資源，比如文件使用後自動關閉、線程中鎖的自動獲取和釋放等。
with語句的語法格式如下：
with expression as target:
with-body
其中，expression用於指定一個表達式，譬如打開文件的open()函數。target用於指定一個變數，並且將expression的結果保存到該變數中，譬如文件對象file。with-body用於指定with語句體，譬如一些文件操作的相關語句，如果沒有要執行的語句體，則直接用pass語句代替。
假設python當前目錄下存在一個test.txt文件，其內容如下：
Python是一種解釋型語言： 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
Python是互動式語言： 這意味著，您可以在一個 Python 提示符 >>> 後直接執行代碼。
Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發。
舉例如下：
with open('test.txt','r',encoding='utf-8') as file:
line=file.readline() # readline()方法可以讀取文件一行數據，接下來就會講到。
print(line)
運行結果如下：
Python是一種解釋型語言： 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
而此時，我們給該段代碼with語句之外再增加一個讀取文件的語句，代碼如下：
with open('test.txt','r',encoding='utf-8') as file:
line=file.readline()
print(line)
line2=file.readline()
print(line2)
發現出現了如下錯誤提示：
Traceback (most recent call last):
File "C:/Users/zym/AppData/Local/Programs/Python/Python39/3.py", line 5, in
line2=file.readline()
ValueError: I/O operation on closed file.
意思是要讀取的文件已經被關閉了。
由此可知，當with語句運行結束後，被打開的test.txt文件就自動關閉了。
15.4讀取文件
在Python 中讀取文件的方法有：
1、讀取指定個數的字元
格式如下：
File.read([size])
其中，file為打開的文件對象。size為可選參數，可以指定要讀取的字元個數，省缺表示讀取所有內容。
在調用read()方法讀取文件內容時，文件必須是以r（只讀）或者r+(讀寫）方式打開。
如：
with open('test.txt','r',encoding='utf-8') as file:
txt=file.read() （或txt=file.read(10)）
print(txt)
將讀取、輸出test.txt文件的全部內容（或前10個字元）。
2、移動文件的指針
對於剛打開的文件，文件指針總是指向文件頭的。也可以通過seek()方法將文件的指針移動到新的位置。
格式如下：
file.seek(offset[,whence])
其中，file表示已經打開的文件對象；offset用於指定移動的字元個數；whence表示從哪個位置起始計算個數，其值為0表示從文件頭開始計算，其值為1表示從當前位置開始計算，其值為2表示從文件尾開始計算，默認值為0。
例如：
with open('test.txt','r',encoding='utf-8') as file:
string=file.read(9)
print('取9個字元： '+string)
file.seek(2) #指針從文件頭開始移動2個字元
string=file.read(9) #從當前位置讀取10個字元
輸出結果：
取9個字元：
Python是一種
取9個字元：
thon是一種解釋
而下面的代碼會拋出錯誤：
with open('test.txt','r',encoding='utf-8') as file:
file.seek(2,1) #指針從當前位置開始移動2個字元
string=file.read(10) #從當前位置讀取10個字元
print('取10個字元： '+string)
錯誤提示為：
Traceback (most recent call last):
File "C:.py", line 7, in
file.seek(2,1) #指針從當前位置開始移動2個字元
io.UnsupportedOperation: can't do nonzero cur-relative seeks
原因在於，必須使用b模式（即rb）打開文件，才能使用whence參數。但是，b模式（二進制）不適合文本文件。對於test.txt這樣的文本文件，為了解決通過改變指針讀取任意位置字元，可以採用加一個位置變數的方法來存儲指針的值。
例如：
with open('test.txt','r',encoding='utf-8') as file:
#utf-8漢字與英文字元都佔一個字元
string='' #設置一個空字元串
pointer=0 #當前指針為0
str1=file.read(6) #讀取6個字元
pointer+=6 #指針變數後移6個字元
string+=str1 #string用來存放已讀取的字元
print('取6個字元： ',str1)
file.seek(pointer) #指針從文件頭開始移動2個字元
str1=file.read(8) #從當前位置讀取10個字元
pointer+=8 #指針跳過已讀取的字元
string+=str1
print('再取8個字元： ',str1)
print('所有讀取的字元： ',string)
print('當前指針所處的位置： ',pointer)
str1=file.read(1)
print('當前指針所處的字元： ',str1)
運行結果如下：
取6個字元：
Python
再取8個字元：
是一種解釋型語言
所有讀取的字元：
Python是一種解釋型語言
當前指針所處的位置：
14
當前指針所處的字元：
：
3、讀取一行數據readline()方法
語法格式：
file.readline()
例：
with open('test.txt','r',encoding='utf-8') as f:
string=f.read(1) # 讀取文件的第一個字元
if string != '': # 防止文件為空文件
lineno=0
while True:
line=f.readline()
if line != '':
lineno+=1
print('第'+str(lineno)+'行：'+line,end='')
# 因為每行都有自帶的分行符，print()語句不允許換行
else:
break # 出現空行時停止讀取
else:
print('要讀取的文件為空文件！')
運行結果：
第1行：ython是一種解釋型語言： 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
第2行：Python是互動式語言： 這意味著，您可以在一個 Python 提示符 >>> 後直接執行代碼。
第3行：Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
第4行：Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發。
4、讀取全部行命令readlines()方法
語法格式：
File.readlines()
該方法與read()方法一樣，在調用read()方法讀取文件內容時，文件必須是以r（只讀）或者r+(讀寫）方式打開。
例：
with open('test.txt','r',encoding='utf-8') as f:
txt=f.readlines()
print(txt)
運行結果：
['Python是一種解釋型語言： 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。 ', 'Python是互動式語言： 這意味著，您可以在一個 Python 提示符 >>> 後直接執行代碼。 ', 'Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。 ', 'Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發。 ']
從上面的運行結果可以看出，readlines()方法的返回值為一個字元串列表。所以，也可以以讀取列表元素的方法輸出。如下所示：
with open('test.txt','r',encoding='utf-8') as f:
txt=f.readlines()
for line in txt:
print(line,end='')
運行結果：
Python是一種解釋型語言： 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
Python是互動式語言： 這意味著，您可以在一個 Python 提示符 >>> 後直接執行代碼。
Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發。
15.5 寫入文件內容
語法格式如下：
file.write(string)
其中，file為打開的文件對象，string為要寫入的字元串。
寫入文件內容時，文件必須以w（可寫）或a（追加）模式打開。否則，會拋出如下異常提示：
Traceback (most recent call last):
File "C:.py", line 2, in
f.write('人生苦短，我用Python！')
io.UnsupportedOperation: not writable
關於write()方法的用法舉例如下：
with open('test.txt','a',encoding='utf-8') as f:
f.write('人生苦短，我用Python！')
with open('test.txt','r',encoding='utf-8') as f:
txt=f.read()
print(txt)
運行結果：
Python是一種解釋型語言： 這意味著開發過程中沒有了編譯這個環節。類似於PHP和Perl語言。
Python是互動式語言： 這意味著，您可以在一個 Python 提示符 >>> 後直接執行代碼。
Python是面向對象語言: 這意味著Python支持面向對象的風格或代碼封裝在對象的編程技術。
Python是初學者的語言：Python 對初級程序員而言，是一種偉大的語言，它支持廣泛的應用程序開發。
人生苦短，我用Python！
可以看出，由於文件的打開方式為a模式（追加模式），寫入的內容被寫入到文件的末尾。
在Python中，文件操作方法里沒有類似於字元串內的計算長度、查找、替換、截取、分隔等方法，為什麼沒有？原因可能是文件的類型太復雜，譬如說二進制文件，上述操作的意義不大。如果僅僅要對文本文件進行上述操作，完全可以先把文件的內容讀取到字元串中，再用相應的字元串函數或方法去操作就可以了。譬如，要將test.txt文件中的字元串『Python』替換為』PHP』，則可以用如下代碼完成：
txt1=''
with open('test.txt','r',encoding='utf-8') as f:
txt1=f.read() #先將文件內容存入字元串txt1中
txt2=txt1.replace('Python','PHP') #將txt1中的'Python'替換為'PHP'，並存入txt2
with open('test.txt','w',encoding='utf-8') as f:
f.write(txt2) #將字元串txt2的內容寫回到文件中
這里之所以分兩步打開文件（第一次為r模式，第二次為w模式），而沒有採用一次讀寫（r+、w+方式），因為那樣比較容易出錯。實踐證明，將文件的讀操作和寫操作分開其實是非常正確的選擇。
⑷ Python對象的拷貝
Python賦值操作或函數參數傳遞，傳遞的永遠是對象引用（即內存地址），而不是對象內容。在Python中一切皆對象，對象又分為可變(mutable)和不可變(immutable)兩種類型。對象拷貝是指在內存中創建新的對象，產生新的內存地址。當頂層對象和它的子元素對象全都是immutable不可變對象時，不存在被拷貝，因為沒有產生新對象。淺拷貝(Shallow Copy)，拷貝頂層對象，但不會拷貝內部的子元素對象。深拷貝(Deep Copy)，遞歸拷貝頂層對象，以及它內部的子元素對象。
Python中一切皆對象，對象就像一個塑料盒子， 裡面裝的是數據。對象有不同類型，例如布爾型和整型，類型決定了可以對它進行的操作。現實生活中的"陶器"會暗含一些信息（例如它可能很重且易碎，注意不要掉到地上）。
對象的類型還決定了它裝著的數據是允許被修改的變數（可變的mutable）還是不可被修改的常量（不可變的immutable）。你可以把不可變對象想像成一個透明但封閉的盒子：你可以看到裡面裝的數據，但是無法改變它。類似地，可變對象就像一個開著口的盒子，你不僅可以看到裡面的數據，還可以拿出來修改它，但你無法改變這個盒子本身，即你無法改變對象的類型。
對象拷貝是指在內存中創建新的對象，產生新的內存地址。
淺拷貝(Shallow Copy)，拷貝頂層對象，但不會拷貝內部的子元素對象。
2.1.1. 頂層是mutable，子元素全是immutable
當頂層對象是mutable可變對象，但是它的子元素對象全都是immutable不可變對象時，如[1, 'world', 2]
① 創建列表對象並賦值給變數a
② 導入模塊，使用.()函數淺拷貝a，並賦值給變數b
③ 修改變數a的子元素a[0] = 3，由於整數是不可變對象，所以並不是修改1變為3，而是更改a[0]指向對象3
當頂層對象是 mutable可變對象 ，但子元素也存在 mutable可變對象 時，如 [1, 2, ['hello','world']]
① 淺拷貝 .() 只拷貝了頂層對象，沒有拷貝子元素對象['hello','world']，即a[2]和b[2]指向同一個列表對象
② 修改a[2][1] = 'china'，則b[2][1] = 'china'
當頂層對象是immutable不可變對象，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)
變數a與變數b指向的是同一個元組對象，沒有拷貝
當頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時，如(1, 2, ['hello','world'])
變數a與變數b指向的是相同的元組對象，並且a[2]與b[2]指向同一個列表，所以修改a[2][1]會影響b[2][1]
深拷貝(Deep Copy)，遞歸拷貝頂層對象，以及它內部的子元素對象
當頂層對象是mutable可變對象，但是它的子元素對象全都是immutable不可變對象時，如[1, 'world', 2]
變數a與變數b指向不同的列表對象，修改a[0]只是將列表a的第一個元素重新指向新對象，不會影響b[0]
當頂層對象是mutable可變對象，但子元素也存在mutable可變對象時，如[1, 2, ['hello','world']]
深拷貝既拷貝了頂層對象，又遞歸拷貝了子元素對象，所以a[2]與b[2]指向了兩個不同的列表對象(但是列表對象的子元素初始指定的字元串對象一樣)，修改a[2][1] = 'china'後，它重新指向了新的字元串對象（內存地址為140531581905808），不會影響到b[2][1]
當頂層對象是immutable不可變對象，同時它的子元素對象也全都是immutable不可變對象時，如(1, 2, 3)
變數a與變數b指向的是同一個元組對象，不存在拷貝
當頂層對象是immutable不可變對象時，但子元素存在mutable可變對象時，如(1, 2, ['hello','world'])
變數a與變數b指向的是不同的元組對象，同時a[2]與b[2]指向不同的列表對象，所以修改a[2][1]不會影響b[2][1]
使用=是賦值，即將列表對象的引用也賦值給變數b，可以將列表對象想像成一個盒子，變數a相當於這個盒子上的標簽，執行b = a後，相當於再在這個盒子上貼上b標簽，a和b實際上指向的是同一個對象。因此，無論我們是通過a還是通過b來修改列表的內容，其結果都會作用於雙方。
b/c/d都是a的復制，它們都指向了不同的列表對象，但是沒有拷貝子元素，a[2]和b[2]/c[2]/d[2]指向同一個列表， 相當於淺拷貝的效果
使用分片[:]操作，a和b其實是指向同一個元組，而且沒有拷貝子元素，a[2]和b[2]也指向同一個列表，相當於淺拷貝的效果
同列表類似，可以使用字典的()函數或者轉換函數dict()
變數a與變數b/c指向不同的字典，但是沒有拷貝子元素，a['jobs']和b['jobs']/c['jobs']指定同一個列表， 相當於淺拷貝的效果
同列表類似，可以使用集合的()函數或者轉換函數set()
變數a與變數b/c指向不同的集合，而集合的元素必須是hashable，所以修改集合a不會影響到b/c
⑸ 請問下學習python需要注意什麼
當我們進行Python學習的時候，一定要保持良好的邏輯思維能力，雖然說Python適合零基礎人員學習，但是學習的時候也需要較強的思維能力。
同時，Python所操作的對象可能是進行數據收集的，可能是人工智慧開發，在這方面數理化基礎也需要不斷積累提升。
簡單的來說，當我們進行Python學習的時候，一定要多看視頻、多聽老師講解，老師教授的內容都比較細致到位，可以讓我們少走彎路，在學習過程中也一定要記筆記。
學習Python，進行編程的時候，千萬不要抄寫代碼，寫代碼一定要有自己的思路，這樣學習起來才可以起到更好的作用。
對於任何人來說，做編程，一定要有自己的編程風格。
在平時學習過程中，將自己的內容做成筆記，平時多看看博客，多寫寫代碼，多與大家進行交流學習，要記住多寫多練，是學習任何一種語言非常有效的辦法，平時一定要多進行實戰項目操作。
⑹ Python方法對象的理解與運用
9.3.4. 方法對象
通常，方法通過右綁定方式調用:
x.f()
在 MyClass 示例中，這會返回字元串 'hello world'。然而，也不是一定要直接調用方法。 x.f 是一個方法對象，它可以存儲起來以後調用。例如:
xf = x.f
while True:
print(xf())
會不斷的列印 hello world。
調用方法時發生了什麼？你可能注意到調用 x.f() 時沒有引用前面標出的變數，盡管在 f() 的函數定義中指明了一個參數。這個參數怎麼了？事實上如果函數調用中缺少參數，Python 會拋出異常－－甚至這個參數實際上沒什麼用……
實際上，你可能已經猜到了答案：方法的特別之處在於實例對象作為函數的第一個參數傳給了函數。在我們的例子中，調用 x.f() 相當於 MyClass.f(x) 。通常，以 n 個參數的列表去調用一個方法就相當於將方法的對象插入到參數列表的最前面後，以這個列表去調用相應的函數。
如果你還是不理解方法的工作原理，了解一下它的實現也許有幫助。引用非數據屬性的實例屬性時，會搜索它的類。如果這個命名確認為一個有效的函數對象類屬性，就會將實例對象和函數對象封裝進一個抽象對象：這就是方法對象。以一個參數列表調用方法對象時，它被重新拆封，用實例對象和原始的參數列表構造一個新的參數列表，然後函數對象調用這個新的參數列表。
⑺ Python中類與對象的其他說明
9.4. 一些說明
數據屬性會覆蓋同名的方法屬性。為了避免意外的名稱沖突，這在大型程序中是極難發現的 Bug，使用一些約定來減少沖突的機會是明智的。可能的約定包括：大寫方法名稱的首字母，使用一個唯一的小字元串（也許只是一個下劃線）作為數據屬性名稱的前綴，或者方法使用動詞而數據屬性使用名詞。
數據屬性可以被方法引用，也可以由一個對象的普通用戶（客戶）使用。換句話說，類不能用來實現純凈的數據類型。事實上，Python 中不可能強制隱藏數據——一切基於約定（如果需要，使用 C 編寫的 Python 實現可以完全隱藏實現細節並控制對象的訪問。這可以用來通過 C 語言擴展 Python）。
客戶應該謹慎的使用數據屬性——客戶可能通過踐踏他們的數據屬性而使那些由方法維護的常量變得混亂。注意：只要能避免沖突，客戶可以向一個實例對象添加他們自己的數據屬性，而不會影響方法的正確性——再次強調，命名約定可以避免很多麻煩。
從方法內部引用數據屬性（或其他方法）並沒有快捷方式。我覺得這實際上增加了方法的可讀性：當瀏覽一個方法時，在局部變數和實例變數之間不會出現令人費解的情況。
一般，方法的第一個參數被命名為 self。這僅僅是一個約定：對 Python 而言，名稱 self 絕對沒有任何特殊含義。（但是請注意：如果不遵循這個約定，對其他的 Python 程序員而言你的代碼可讀性就會變差，而且有些 類查看器 程序也可能是遵循此約定編寫的。）
類屬性的任何函數對象都為那個類的實例定義了一個方法。函數定義代碼不一定非得定義在類中：也可以將一個函數對象賦值給類中的一個局部變數。例如:
# Function defined outside the class
def f1(self, x, y):
return min(x, x+y)
class C:
f = f1
def g(self):
return 'hello world'
h = g
現在 f， g 和 h 都是類 C 的屬性，引用的都是函數對象，因此它們都是 C 實例的方法－－ h 嚴格等於 g 。要注意的是這種習慣通常只會迷惑程序的讀者。
通過 self 參數的方法屬性，方法可以調用其它的方法:
class Bag:
def __init__(self):
self.data = []
def add(self, x):
self.data.append(x)
def addtwice(self, x):
self.add(x)
self.add(x)
方法可以像引用普通的函數那樣引用全局命名。與方法關聯的全局作用域是包含類定義的模塊。（類本身永遠不會作為全局作用域使用。）盡管很少有好的理由在方法 中使用全局數據，全局作用域卻有很多合法的用途：其一是方法可以調用導入全局作用域的函數和方法，也可以調用定義在其中的類和函數。通常，包含此方法的類也會定義在這個全局作用域，在下一節我們會了解為何一個方法要引用自己的類。
每個值都是一個對象，因此每個值都有一個 類( class ) （也稱為它的 類型( type ) ），它存儲為 object.__class__ 。
⑻ Python 使用對象模型來存儲數據
Python使用對象模型來存儲數據。構造任何類型的值都是一個對象。盡管Python通常被當成一種「面向對象的編程語言」，但你完全能夠寫出不使用任何類和實例的實用腳本。不過Python的對象語法和架構鼓勵我們使用這些特性，下面讓我們仔細研究一下Python對象。所有的Python對像都擁有三個特性:身份，類型和值。
身份:每一個對象都有一個唯一的身份標識自己，任何對象的身份可以使用內建函數id()來得到。這個值可以被認為是該對象的內存地址。你極少會用到這個值，也不用太關心它究竟是什麼。
類型對象的類型決定了該對象可以保存什麼類型的值，可以進行什麼樣的操作，以及遵循什麼樣的規則。你可以用內建函數type0查看Python對象的類型。因為在Python中類型也是對象(還記得我們提到Python是面向對象的這句話嗎?)，所以type0返回的是對象而不是簡單的字元串。
值:對象表示的數據項。
上面三個特性在對象創建的時候就被賦值，除了值之外，其他兩個特性都是只讀的。對於新式類型和類，對象的類型也是可以改變的，不過並不推薦初學者這樣做。如果對象支持更新操作，那麼它的值就可以改變，否則它的值也是只讀的。對象的值是否可以更改被稱為對象的可改變性(mutability)，我們會在後面的4.7小節中討論這個問題。只要一個對象還沒有被銷毀，這些特性就一直存在。Python有一系列的基本(內建)數據類型，必要時也可以創建自定義類型來滿足你對應用程序的需求。絕大多數應用程序通常使用標准類型，對特定的數據存儲則通過創建和實例化類來實現。
⑼ Python中常見魔法方法介紹
魔法方法 (Magic Methods) 是Python中的內置函數，一般以雙下劃線開頭和結尾，例如__ init__ 、 __del__ 等。之所以稱之為魔法方法，是因為這些方法會在進行特定的操作時會自動被調用。
在Python中，可以通過dir()方法來查看某個對象的所有方法和屬性，其中雙下劃線開頭和結尾的就是該對象的魔法方法。以字元串對象為例：
可以看到字元串對象有 __add__ 方法，所以在Python中可以直接對字元串對象使用"+"操作，當Python識別到"+"操作時，就會調用該對象的 __add__ 方法。有需要時我們可以在自己的類中重寫 __add__ 方法來完成自己想要的效果。
我們重寫了 __add__ 方法，當Python識別"+"操作時，會自動調用重寫後的 __add__ 方法。可以看到，魔法方法在類或對象的某些事件出發後會自動執行，如果希望根據自己的程序定製特殊功能的類，那麼就需要對這些方法進行重寫。使用魔法方法，我們可以非常方便地給類添加特殊的功能。
1、構造與初始化
__ new __ 、 __ init __ 這兩個魔法方法常用於對類的初始化操作。上面我們創建a1 = A("hello")時，但首先調用的是 __ new __ ;初始化一個類分為兩步:
a.調用該類的new方法，返回該類的實例對象
b.調用該類的init方法，對實例對象進行初始化。
__new__ (cls, *args, **kwargs)至少需要一個cls參數，代表傳入的類。後面兩個參數傳遞給 __ init __ 。在 __ new __ 可以決定是否繼續調用 __ init __ 方法，只有當 __ new __ 返回了當前類cls的實例，才會接著調用 __ init __ 。結合 __ new __ 方法的特性，我們可以通過重寫 __ new __ 方法實現Python的單例模式：
可以看到雖然創建了兩個對象，但兩個對象的地址相同。
2、控制屬性訪問這類魔法
方法主要對對象的屬性進行訪問、定義、修改時起作用。主要有：
__getattr__(self, name): 定義當用戶試圖獲取一個屬性時的行為。
__getattribute__(self, name)：定義當該類的屬性被訪問時的行為（先調用該方法，查看是否存在該屬性，若不存在，接著去調用getattr）。
__setattr__(self, name, value)：定義當一個屬性被設置時的行為。
當初始化屬性時如self.a=a時或修改實例屬性如ins.a=1時本質時調用魔法方法self. __ setattr __ (name,values)；當實例訪問某個屬性如ins.a本質是調用魔法方法a. __ getattr __ (name)
3、容器類操作
有一些方法可以讓我們自己定義自己的容器，就像Python內置的List,Tuple,Dict等等；容器分為可變容器和不可變容器。
如果自定義一個不可變容器的話，只能定義__ len__ 和__ getitem__ ；定義一個可變容器除了不可變容器的所有魔法方法，還需要定義__ setitem__ 和__ delitem__ ；如果容器可迭代。還需要定義__ iter __。
__len__(self):返回容器的長度
__getitem__(self,key):當需要執行self[key]的方式去調用容器中的對象，調用的是該方法
__setitem__(self,key,value):當需要執行self[key] = value時，調用的是該方法
__iter__(self):當容器可以執行 for x in container:，或者使用iter(container)時，需要定義該方法
下面舉一個例子，實現一個容器，該容器有List的一般功能，同時增加一些其它功能如訪問第一個元素，最後一個元素,記錄每個元素被訪問的次數等。
這類方法的使用場景主要在你需要定義一個滿足需求的容器類數據結構時會用到，比如可以嘗試自定義實現樹結構、鏈表等數據結構（在collections中均已有），或者項目中需要定製的一些容器類型。
魔法方法在Python代碼中能夠簡化代碼，提高代碼可讀性，在常見的Python第三方庫中可以看到很多對於魔法方法的運用。
因此當前這篇文章僅是拋磚引玉，真正的使用需要在開源的優秀源碼中以及自身的工程實踐中不斷加深理解並合適應用。
⑽ Python 面向對象的核心概念匯總
1)、將公共的屬性和方法放到父類中，自己只考慮特有的屬性和方法。
2)、覆蓋父類的方法即重寫父類方法，在運行中只會調用子類中重寫的方法不用調用父類中的方法。
3)、子類擁有一個父類叫作單繼承，子類可以擁有多個父類，並且具有所有父類的屬性和方法。
1)、指的是為不同的基礎形態（數據類型）提供著介面的能力，介面指的是函數和方法。
2)、顧名思義，多態就是多種表現形態的意思，它是一種機制，一種能力，而非某個關鍵詞。它在類的繼承中得以實現，在類的方法調用中得以體現。
3)、多態意味著變數並不知道引用的對象是什麼，根據引用對象的不同表現不同的行為方式。
4)、多態以封裝和繼承為前提，不同的子類對象調用相同的方法，產生不同的執行效果。它可以增加代碼的靈活度，以繼承和重寫父類的方法為前提，調用方法不會影響到類的內部設計
1)、通過組合技巧將一個對象作用變數保存在另一個對象中，可以模擬擁有關系。
2)、它是一種將對象或類組合成更復雜的數據結構或構件實現的方法。
3)、在組合中，一個對象可用於調用其他模塊中的成員函數，這樣一來，無需通過繼承就可以實現基本功能的跨模塊調用。
總結：
今天和大家分享的是面向對象編程的核心概念：封裝，抽象，多態、繼承、組合，可以結合代碼示例本地去運行著感受這些概念的含義。