既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
類的名稱跟在class關鍵詞之後，和冒號(:)之前。類用實例變量(instance variable)來存儲數據，以及方法(method)來定義行為。關於超類的概念不必驚慌，下一章就會詳細講解，沒有超類的情況下，類名之後的括號也可以省略。
為了使定義的過程看上去儘可能簡單，語句體中只有一個 pass，也就是什麼也不做的意思。
一般的類還會包含：
- 方法：用來定義行為
- 實例變量：存儲數據
什麼是方法？
方法描述了對象的行為，本質上它是定義在類中的函數。調用對象方法的過程，和我們之前在函數一章中調用函數是相似的，比如對於字符串對象，想要調用.split()方法來進行分割（#號後面的就是輸出結果）：
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
類的名稱跟在class關鍵詞之後，和冒號(:)之前。類用實例變量(instance variable)來存儲數據，以及方法(method)來定義行為。關於超類的概念不必驚慌，下一章就會詳細講解，沒有超類的情況下，類名之後的括號也可以省略。
為了使定義的過程看上去儘可能簡單，語句體中只有一個 pass，也就是什麼也不做的意思。
一般的類還會包含：
- 方法：用來定義行為
- 實例變量：存儲數據
什麼是方法？
方法描述了對象的行為，本質上它是定義在類中的函數。調用對象方法的過程，和我們之前在函數一章中調用函數是相似的，比如對於字符串對象，想要調用.split()方法來進行分割（#號後面的就是輸出結果）：
在之前的章節習題中，我們已經接觸過了類的相關的用法。假設現有類Person，含有了一個方法，叫做 whoami，用於返回對象的名字。那我們調用這個方法的過程是這樣的：
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
類的名稱跟在class關鍵詞之後，和冒號(:)之前。類用實例變量(instance variable)來存儲數據，以及方法(method)來定義行為。關於超類的概念不必驚慌，下一章就會詳細講解，沒有超類的情況下，類名之後的括號也可以省略。
為了使定義的過程看上去儘可能簡單，語句體中只有一個 pass，也就是什麼也不做的意思。
一般的類還會包含：
- 方法：用來定義行為
- 實例變量：存儲數據
什麼是方法？
方法描述了對象的行為，本質上它是定義在類中的函數。調用對象方法的過程，和我們之前在函數一章中調用函數是相似的，比如對於字符串對象，想要調用.split()方法來進行分割（#號後面的就是輸出結果）：
在之前的章節習題中，我們已經接觸過了類的相關的用法。假設現有類Person，含有了一個方法，叫做 whoami，用於返回對象的名字。那我們調用這個方法的過程是這樣的：
其實上面這個程序 Trevor = Person() 這一行，不管你把 kaiser 改成什麼，輸出的都是我的名字。顯然，這個 whoami 方法是有問題的。
如果你把類語句體裡的 'Trevor' 改成別的內容，那就會輸出別的內容。但我們需要的是輸出這個 Person 對象的名字，大家的名字都不相同，怎麼做呢？這就需要類 Person 能夠存儲數據，也就是要有實例變量。
實例變量
介紹實例變量之前，先介紹一下初始化器（initializer或constructor）。Python 的類都自帶有一些特殊的方法，它就是其中之一。
初始化器的“初始化”，指的是對象的初始化，其實也就是類的實例化。如果我們要在實例化 Person 的時候，給它一個名字，可以加在實例化時的括號裡。
初始化器的方法名長這樣：__init__。別怕下劃線，這只是為了標明些方法的特殊性。
定義初始化器和平時定義方法是一樣的，我們需要把這個人的名字傳入到初始化器。那麼初始化器應該這樣定義：
哦，在這停頓！這裡出現的 self.name，就是我們的實例變量。實例變量的用途（第三次提起）是存儲數據，那麼這裡我們是存儲了名字。這樣實現過初始化器之後，就可以實例化 Person ，並賦予它一個名字了。
Python的所有方法，其第一個參數都是self，這個參數指代的是調用該方法的對象。調用方法時，不需要傳入self參數，Python解釋器會自動完成這一步。對象的實例變量可以在生成後修改，但是並不推薦這樣做，所以實踐當中最好隱藏變量對外的接口。在實際的開發中經常會遇到這種情況：我們不希望對象的某些實例變量被訪問和修改。為此需要隱藏這些實例變量，即定義私有實例變量。在Python中，以兩條下劃線(__)開頭的變量，就是私有實例變量。方法同樣可以定義為私有，也是以兩條下劃線(__)開頭。
四、繼承與派生
繼承(inheritance)使得開發者可以先創建一個較為寬泛的類，再逐步拓展細化成為更具體的類，就好比先定義“動物”，再繼承得出“哺乳動物”。
通過繼承，我們可以訪問所有的數據域（實例變量）和方法，此外還可以加入我們自己的變量和方法。繼承提供了一種組織代碼的方式，這樣就不用每次都從零重寫，極大地提高了編碼效率，也是一種更好的代碼風格。如果類Y繼承了類X，那麼X叫作“超類”(super class)或“基類”(base class)，Y叫作“子類”(subclass)或“派生類”(derived class)。其實就是父子關係：
創建子類的語法：
之前我們定義過的類如Person，類名之後都是沒有括號的，因為他們並沒有繼承其他超類。
與C#, Java這些語言不同，Python允許多重繼承，也就是可以認好幾個爹：
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
類的名稱跟在class關鍵詞之後，和冒號(:)之前。類用實例變量(instance variable)來存儲數據，以及方法(method)來定義行為。關於超類的概念不必驚慌，下一章就會詳細講解，沒有超類的情況下，類名之後的括號也可以省略。
為了使定義的過程看上去儘可能簡單，語句體中只有一個 pass，也就是什麼也不做的意思。
一般的類還會包含：
- 方法：用來定義行為
- 實例變量：存儲數據
什麼是方法？
方法描述了對象的行為，本質上它是定義在類中的函數。調用對象方法的過程，和我們之前在函數一章中調用函數是相似的，比如對於字符串對象，想要調用.split()方法來進行分割（#號後面的就是輸出結果）：
在之前的章節習題中，我們已經接觸過了類的相關的用法。假設現有類Person，含有了一個方法，叫做 whoami，用於返回對象的名字。那我們調用這個方法的過程是這樣的：
其實上面這個程序 Trevor = Person() 這一行，不管你把 kaiser 改成什麼，輸出的都是我的名字。顯然，這個 whoami 方法是有問題的。
如果你把類語句體裡的 'Trevor' 改成別的內容，那就會輸出別的內容。但我們需要的是輸出這個 Person 對象的名字，大家的名字都不相同，怎麼做呢？這就需要類 Person 能夠存儲數據，也就是要有實例變量。
實例變量
介紹實例變量之前，先介紹一下初始化器（initializer或constructor）。Python 的類都自帶有一些特殊的方法，它就是其中之一。
初始化器的“初始化”，指的是對象的初始化，其實也就是類的實例化。如果我們要在實例化 Person 的時候，給它一個名字，可以加在實例化時的括號裡。
初始化器的方法名長這樣：__init__。別怕下劃線，這只是為了標明些方法的特殊性。
定義初始化器和平時定義方法是一樣的，我們需要把這個人的名字傳入到初始化器。那麼初始化器應該這樣定義：
哦，在這停頓！這裡出現的 self.name，就是我們的實例變量。實例變量的用途（第三次提起）是存儲數據，那麼這裡我們是存儲了名字。這樣實現過初始化器之後，就可以實例化 Person ，並賦予它一個名字了。
Python的所有方法，其第一個參數都是self，這個參數指代的是調用該方法的對象。調用方法時，不需要傳入self參數，Python解釋器會自動完成這一步。對象的實例變量可以在生成後修改，但是並不推薦這樣做，所以實踐當中最好隱藏變量對外的接口。在實際的開發中經常會遇到這種情況：我們不希望對象的某些實例變量被訪問和修改。為此需要隱藏這些實例變量，即定義私有實例變量。在Python中，以兩條下劃線(__)開頭的變量，就是私有實例變量。方法同樣可以定義為私有，也是以兩條下劃線(__)開頭。
四、繼承與派生
繼承(inheritance)使得開發者可以先創建一個較為寬泛的類，再逐步拓展細化成為更具體的類，就好比先定義“動物”，再繼承得出“哺乳動物”。
通過繼承，我們可以訪問所有的數據域（實例變量）和方法，此外還可以加入我們自己的變量和方法。繼承提供了一種組織代碼的方式，這樣就不用每次都從零重寫，極大地提高了編碼效率，也是一種更好的代碼風格。如果類Y繼承了類X，那麼X叫作“超類”(super class)或“基類”(base class)，Y叫作“子類”(subclass)或“派生類”(derived class)。其實就是父子關係：
創建子類的語法：
之前我們定義過的類如Person，類名之後都是沒有括號的，因為他們並沒有繼承其他超類。
與C#, Java這些語言不同，Python允許多重繼承，也就是可以認好幾個爹：
最後，今天來一波毒雞湯
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
類的名稱跟在class關鍵詞之後，和冒號(:)之前。類用實例變量(instance variable)來存儲數據，以及方法(method)來定義行為。關於超類的概念不必驚慌，下一章就會詳細講解，沒有超類的情況下，類名之後的括號也可以省略。
為了使定義的過程看上去儘可能簡單，語句體中只有一個 pass，也就是什麼也不做的意思。
一般的類還會包含：
- 方法：用來定義行為
- 實例變量：存儲數據
什麼是方法？
方法描述了對象的行為，本質上它是定義在類中的函數。調用對象方法的過程，和我們之前在函數一章中調用函數是相似的，比如對於字符串對象，想要調用.split()方法來進行分割（#號後面的就是輸出結果）：
在之前的章節習題中，我們已經接觸過了類的相關的用法。假設現有類Person，含有了一個方法，叫做 whoami，用於返回對象的名字。那我們調用這個方法的過程是這樣的：
其實上面這個程序 Trevor = Person() 這一行，不管你把 kaiser 改成什麼，輸出的都是我的名字。顯然，這個 whoami 方法是有問題的。
如果你把類語句體裡的 'Trevor' 改成別的內容，那就會輸出別的內容。但我們需要的是輸出這個 Person 對象的名字，大家的名字都不相同，怎麼做呢？這就需要類 Person 能夠存儲數據，也就是要有實例變量。
實例變量
介紹實例變量之前，先介紹一下初始化器（initializer或constructor）。Python 的類都自帶有一些特殊的方法，它就是其中之一。
初始化器的“初始化”，指的是對象的初始化，其實也就是類的實例化。如果我們要在實例化 Person 的時候，給它一個名字，可以加在實例化時的括號裡。
初始化器的方法名長這樣：__init__。別怕下劃線，這只是為了標明些方法的特殊性。
定義初始化器和平時定義方法是一樣的，我們需要把這個人的名字傳入到初始化器。那麼初始化器應該這樣定義：
哦，在這停頓！這裡出現的 self.name，就是我們的實例變量。實例變量的用途（第三次提起）是存儲數據，那麼這裡我們是存儲了名字。這樣實現過初始化器之後，就可以實例化 Person ，並賦予它一個名字了。
Python的所有方法，其第一個參數都是self，這個參數指代的是調用該方法的對象。調用方法時，不需要傳入self參數，Python解釋器會自動完成這一步。對象的實例變量可以在生成後修改，但是並不推薦這樣做，所以實踐當中最好隱藏變量對外的接口。在實際的開發中經常會遇到這種情況：我們不希望對象的某些實例變量被訪問和修改。為此需要隱藏這些實例變量，即定義私有實例變量。在Python中，以兩條下劃線(__)開頭的變量，就是私有實例變量。方法同樣可以定義為私有，也是以兩條下劃線(__)開頭。
四、繼承與派生
繼承(inheritance)使得開發者可以先創建一個較為寬泛的類，再逐步拓展細化成為更具體的類，就好比先定義“動物”，再繼承得出“哺乳動物”。
通過繼承，我們可以訪問所有的數據域（實例變量）和方法，此外還可以加入我們自己的變量和方法。繼承提供了一種組織代碼的方式，這樣就不用每次都從零重寫，極大地提高了編碼效率，也是一種更好的代碼風格。如果類Y繼承了類X，那麼X叫作“超類”(super class)或“基類”(base class)，Y叫作“子類”(subclass)或“派生類”(derived class)。其實就是父子關係：
創建子類的語法：
之前我們定義過的類如Person，類名之後都是沒有括號的，因為他們並沒有繼承其他超類。
與C#, Java這些語言不同，Python允許多重繼承，也就是可以認好幾個爹：
最後，今天來一波毒雞湯
小編在此謝謝大家的觀看！python很容易學！
最後，想學習Python的小夥伴們！
請關注+私信回覆：“學習”就可以拿到一份我為大家準備的Python學習資料！
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
類的名稱跟在class關鍵詞之後，和冒號(:)之前。類用實例變量(instance variable)來存儲數據，以及方法(method)來定義行為。關於超類的概念不必驚慌，下一章就會詳細講解，沒有超類的情況下，類名之後的括號也可以省略。
為了使定義的過程看上去儘可能簡單，語句體中只有一個 pass，也就是什麼也不做的意思。
一般的類還會包含：
- 方法：用來定義行為
- 實例變量：存儲數據
什麼是方法？
方法描述了對象的行為，本質上它是定義在類中的函數。調用對象方法的過程，和我們之前在函數一章中調用函數是相似的，比如對於字符串對象，想要調用.split()方法來進行分割（#號後面的就是輸出結果）：
在之前的章節習題中，我們已經接觸過了類的相關的用法。假設現有類Person，含有了一個方法，叫做 whoami，用於返回對象的名字。那我們調用這個方法的過程是這樣的：
其實上面這個程序 Trevor = Person() 這一行，不管你把 kaiser 改成什麼，輸出的都是我的名字。顯然，這個 whoami 方法是有問題的。
如果你把類語句體裡的 'Trevor' 改成別的內容，那就會輸出別的內容。但我們需要的是輸出這個 Person 對象的名字，大家的名字都不相同，怎麼做呢？這就需要類 Person 能夠存儲數據，也就是要有實例變量。
實例變量
介紹實例變量之前，先介紹一下初始化器（initializer或constructor）。Python 的類都自帶有一些特殊的方法，它就是其中之一。
初始化器的“初始化”，指的是對象的初始化，其實也就是類的實例化。如果我們要在實例化 Person 的時候，給它一個名字，可以加在實例化時的括號裡。
初始化器的方法名長這樣：__init__。別怕下劃線，這只是為了標明些方法的特殊性。
定義初始化器和平時定義方法是一樣的，我們需要把這個人的名字傳入到初始化器。那麼初始化器應該這樣定義：
哦，在這停頓！這裡出現的 self.name，就是我們的實例變量。實例變量的用途（第三次提起）是存儲數據，那麼這裡我們是存儲了名字。這樣實現過初始化器之後，就可以實例化 Person ，並賦予它一個名字了。
Python的所有方法，其第一個參數都是self，這個參數指代的是調用該方法的對象。調用方法時，不需要傳入self參數，Python解釋器會自動完成這一步。對象的實例變量可以在生成後修改，但是並不推薦這樣做，所以實踐當中最好隱藏變量對外的接口。在實際的開發中經常會遇到這種情況：我們不希望對象的某些實例變量被訪問和修改。為此需要隱藏這些實例變量，即定義私有實例變量。在Python中，以兩條下劃線(__)開頭的變量，就是私有實例變量。方法同樣可以定義為私有，也是以兩條下劃線(__)開頭。
四、繼承與派生
繼承(inheritance)使得開發者可以先創建一個較為寬泛的類，再逐步拓展細化成為更具體的類，就好比先定義“動物”，再繼承得出“哺乳動物”。
通過繼承，我們可以訪問所有的數據域（實例變量）和方法，此外還可以加入我們自己的變量和方法。繼承提供了一種組織代碼的方式，這樣就不用每次都從零重寫，極大地提高了編碼效率，也是一種更好的代碼風格。如果類Y繼承了類X，那麼X叫作“超類”(super class)或“基類”(base class)，Y叫作“子類”(subclass)或“派生類”(derived class)。其實就是父子關係：
創建子類的語法：
之前我們定義過的類如Person，類名之後都是沒有括號的，因為他們並沒有繼承其他超類。
與C#, Java這些語言不同，Python允許多重繼承，也就是可以認好幾個爹：
最後，今天來一波毒雞湯
小編在此謝謝大家的觀看！python很容易學！
最後，想學習Python的小夥伴們！
請關注+私信回覆：“學習”就可以拿到一份我為大家準備的Python學習資料！
既然Python是一門面向對象的編程語言，那麼今天我們著重講一下如何處理"對象"
一、文件
之前接觸到的一系列數據值，都是在內存中的，也就是不會永久保存。當數據量非常小的時候，當然可以每次都臨時定義生成，但如果數據量稍大，這樣處理就不合適了。結合我們平時使用電腦的習慣，其實大部分數據都是以“文件”式存在於硬盤裡的，比如.avi, .torrent, .exe, .txt等。
1.open函數
利用python的內置函數open()可以執行打開文件的操作，對於一些python的數據科學庫像numpy和panda有自己的文件讀取函數。下面我們通過一個簡單的例子展示一下：
open("hope.txt", "r")
open函數與我們之前介紹的print函數不同，接受了兩個參數，參數之間以逗號隔開。
- "hope.txt"：目標文件名，字符串類型；
- "r"：打開模式，"r"代表“只讀”(read)。另有"w"表示“寫入”(write)，"a"表示“增補”(append)。
- 但是open函數並不會顯示文件的內容,比如看下面的這個例子：
當你運行這段代碼將會得到
<_io.TextIOWrapper name='taijian.txt' mode='r' encoding='UTF-8'>
答案：
data = f.read()mons = data.split('
')for i in mons:mons_data.append(i.split(','))
如果有一個函數，只要指定目標csv文件，就可以直接生成二維數組，豈不美哉？但是Python並沒有內置這樣的功能，那就需要定義自己的函數。函數定義的關鍵字是def，也就是"define"的縮寫。定義語句格式與for循環有些類似，同樣包括語句頭和語句體，需要特別注意的仍然是語句頭結尾的冒號(:)和語句體的縮進：
我們希望能夠有一個函數，讀取指定的csv文件，返回經過切分的二維數組，那麼這個函數應該是這樣的：
- 函數名：tokenize，想要調用這個自定義函數的時候，直接寫tokenize()即可，就像我們使用print(), type()一樣。
- 參數：想要處理的數據文件名，對於Dota2的例子，就是dota2_heroes.csv。
- 函數體：也就是上一節所寫的代碼段，為了函數更加通用，我修改了部分變量名稱。
- 返回值：關鍵字return之後是經過函數得到的結果。
三、類和對象
類(class)描述和規範了某一類事物的特徵和行為。比如有一個類，叫“車”。那麼這個類就描述了一種物體的特徵和行為，特徵比如有輪子，行為比方說會移動。車這個類好比一張藍圖，各種各樣的車都是根據車的基本特徵設計製造出來的。
“類”的概念是抽象的，我們雖然修過了一輛輛車，但不會真的關注“車”作為類的本質等哲♂學命題。具體到某一輛車就是對象(object)，對象是類的實例，如果說類是藍圖，對象就是把一張藍圖繪到底。
Python是一門面向對象的編程語言，可以說在Python中所有東西都是對象（你們有對象了嗎？），比如int, str, bool這些我們已經見過的數據類型，甚至模塊、函數，全都是對象。這個按照藍圖造車的過程，就叫類的實例化。你擁有的車就是類的實例，即對象。所以說，要有對象，首先要定義類。
如何定義一個類呢？
和定義函數一樣，定義類也是一個“語句頭+語句體”組成的複合語句，用到的關鍵字是 class。定義一個名為 Creature 的類，其語法結構如圖：
類的名稱跟在class關鍵詞之後，和冒號(:)之前。類用實例變量(instance variable)來存儲數據，以及方法(method)來定義行為。關於超類的概念不必驚慌，下一章就會詳細講解，沒有超類的情況下，類名之後的括號也可以省略。
為了使定義的過程看上去儘可能簡單，語句體中只有一個 pass，也就是什麼也不做的意思。
一般的類還會包含：
- 方法：用來定義行為
- 實例變量：存儲數據
什麼是方法？
方法描述了對象的行為，本質上它是定義在類中的函數。調用對象方法的過程，和我們之前在函數一章中調用函數是相似的，比如對於字符串對象，想要調用.split()方法來進行分割（#號後面的就是輸出結果）：
在之前的章節習題中，我們已經接觸過了類的相關的用法。假設現有類Person，含有了一個方法，叫做 whoami，用於返回對象的名字。那我們調用這個方法的過程是這樣的：
其實上面這個程序 Trevor = Person() 這一行，不管你把 kaiser 改成什麼，輸出的都是我的名字。顯然，這個 whoami 方法是有問題的。
如果你把類語句體裡的 'Trevor' 改成別的內容，那就會輸出別的內容。但我們需要的是輸出這個 Person 對象的名字，大家的名字都不相同，怎麼做呢？這就需要類 Person 能夠存儲數據，也就是要有實例變量。
實例變量
介紹實例變量之前，先介紹一下初始化器（initializer或constructor）。Python 的類都自帶有一些特殊的方法，它就是其中之一。
初始化器的“初始化”，指的是對象的初始化，其實也就是類的實例化。如果我們要在實例化 Person 的時候，給它一個名字，可以加在實例化時的括號裡。
初始化器的方法名長這樣：__init__。別怕下劃線，這只是為了標明些方法的特殊性。
定義初始化器和平時定義方法是一樣的，我們需要把這個人的名字傳入到初始化器。那麼初始化器應該這樣定義：
哦，在這停頓！這裡出現的 self.name，就是我們的實例變量。實例變量的用途（第三次提起）是存儲數據，那麼這裡我們是存儲了名字。這樣實現過初始化器之後，就可以實例化 Person ，並賦予它一個名字了。
Python的所有方法，其第一個參數都是self，這個參數指代的是調用該方法的對象。調用方法時，不需要傳入self參數，Python解釋器會自動完成這一步。對象的實例變量可以在生成後修改，但是並不推薦這樣做，所以實踐當中最好隱藏變量對外的接口。在實際的開發中經常會遇到這種情況：我們不希望對象的某些實例變量被訪問和修改。為此需要隱藏這些實例變量，即定義私有實例變量。在Python中，以兩條下劃線(__)開頭的變量，就是私有實例變量。方法同樣可以定義為私有，也是以兩條下劃線(__)開頭。
四、繼承與派生
繼承(inheritance)使得開發者可以先創建一個較為寬泛的類，再逐步拓展細化成為更具體的類，就好比先定義“動物”，再繼承得出“哺乳動物”。
通過繼承，我們可以訪問所有的數據域（實例變量）和方法，此外還可以加入我們自己的變量和方法。繼承提供了一種組織代碼的方式，這樣就不用每次都從零重寫，極大地提高了編碼效率，也是一種更好的代碼風格。如果類Y繼承了類X，那麼X叫作“超類”(super class)或“基類”(base class)，Y叫作“子類”(subclass)或“派生類”(derived class)。其實就是父子關係：
創建子類的語法：
之前我們定義過的類如Person，類名之後都是沒有括號的，因為他們並沒有繼承其他超類。
與C#, Java這些語言不同，Python允許多重繼承，也就是可以認好幾個爹：
最後，今天來一波毒雞湯
小編在此謝謝大家的觀看！python很容易學！