首先, 什么是Python? 用python作者Guido van Rossum自己的話來(lái)說(shuō)，Python是這樣的一門語(yǔ)言：

"它是一門高級(jí)編程語(yǔ)言, 它的核心設(shè)計(jì)理念是讓所有代碼變得更易閱讀，并給開發(fā)者們提供一種“僅僅幾行代碼就能編寫編程邏輯”的語(yǔ)法。

那么，對(duì)我來(lái)說(shuō)，讓我學(xué)習(xí)Python的第一個(gè)理由，就是它漂亮而優(yōu)雅，能夠順暢自然地實(shí)現(xiàn)我的想法。

另一個(gè)理由，就是Python支持多種編程領(lǐng)域，如：

數(shù)據(jù)科學(xué)

web開發(fā)

機(jī)器學(xué)習(xí)

比如，Quora、Pinterest、Spotify，這些項(xiàng)目，都是使用python開發(fā)他們的后端。

那么，接下來(lái)，就開始學(xué)習(xí)Python吧！

基礎(chǔ)

1. 變量

可以把變量簡(jiǎn)單理解為一個(gè)存儲(chǔ)值的單詞。

講道理，變量是什么就不用特地解釋了…大家都懂。

在Python里面，定義變量、給變量賦值都非常簡(jiǎn)單。比如你想把數(shù)字1存儲(chǔ)到一個(gè)變量里面，而這個(gè)變量名叫one，那么，你只需要這樣：

one =1

非常簡(jiǎn)單吧? 舉一反三，完全可以自由發(fā)揮，就像下面，把2賦值給two，把10000賦值給some_number：

two =2

some_number =10000

當(dāng)然，除了整型以外，我們也可以設(shè)置布爾類型、字符串、單精度，以及一些其他數(shù)據(jù)類型。如下：

# booleans

true_boolean =True

false_boolean =False

# string

my_name ="Leandro Tk"

# float

book_price =15.80

2.流程控制: 分支語(yǔ)句

if，這個(gè)語(yǔ)句用來(lái)判斷是否符合條件，它的后面緊跟著邏輯表達(dá)式，表達(dá)式最后的值為True或False，如果是true，則執(zhí)行if里面的語(yǔ)句。如下：

ifTrue:

print("Hello Python If")

if2>1:

print("2 is greater than 1")

因?yàn)?大于1，條件成立，所以print語(yǔ)句就會(huì)被執(zhí)行

當(dāng)然，如果不滿足條件，那么else就派上用場(chǎng)了！

如果，if后面跟著的邏輯表達(dá)式最終值是false，則會(huì)運(yùn)行else里面的程序，如下：

if1>2:

print("1 is greater than 2")

else:

print("1 is not greater than 2")

你也可以使用elif，是else if的縮寫，但千萬(wàn)別寫錯(cuò)~

if1>2:

print("1 is greater than 2")

elif2>1:

print("1 is not greater than 2")

else:

print("1 is equal to 2")

3. 循環(huán) /?迭代器

在Python中，我們有多種迭代的方式，我在這里說(shuō)兩種：

While?循環(huán): 當(dāng)邏輯表達(dá)式為true的時(shí)候，while下縮進(jìn)的代碼塊就會(huì)被循環(huán)執(zhí)行. 所以下面的代碼片段，將會(huì)從1打印到10。

num =1

whilenum <=10:

print(num)

num +=1

上面這種循環(huán)方式，需要一個(gè)循環(huán)條件，如果循環(huán)條件是true，就會(huì)繼續(xù)進(jìn)行迭代，在上面的例子中，當(dāng)num變成11的時(shí)候，循環(huán)條件就會(huì)等于False"

再看看下面的基礎(chǔ)代碼塊，以便于理解:

loop_condition =True

whileloop_condition:

print("Loop Condition keeps: %s"%(loop_condition))

loop_condition =False

只要循環(huán)條件為True，就會(huì)被一直循環(huán)執(zhí)行，直到循環(huán)條件變成False

For循環(huán): 與其他語(yǔ)言一樣，這用于計(jì)次循環(huán)，它循環(huán)的次數(shù)，取決于后面那個(gè)range方法。

range，代表從在循環(huán)里，它用于表示從x到n，如下，就是從1到11，第三個(gè)參數(shù)可空，意思是每次遞進(jìn)的加數(shù)，默認(rèn)每循環(huán)一次給i加1，填2的話，就給i加2

foriinrange(1,11):

print(i)

列表: 集合 | 數(shù)組 | 數(shù)據(jù)結(jié)構(gòu)

想象一下，你想把整數(shù)1存儲(chǔ)在一個(gè)變量中。 但也許現(xiàn)在你想要存儲(chǔ) 2 和 3，4，5 。。。

我是否有另一種方法來(lái)存儲(chǔ)我想要的所有整數(shù)，但不是以百萬(wàn)計(jì)的變量？ 你猜對(duì)了 —— 確實(shí)有另一種方法來(lái)存儲(chǔ)它們。

List是一個(gè)可以用來(lái)存儲(chǔ)一列值的集合（比如你想要的這些整數(shù)）。 那么讓我們使用它：

my_integers = [1,2,3,4,5]

這真的很簡(jiǎn)單，我們創(chuàng)建了一個(gè)數(shù)組并將其存儲(chǔ)到my_integer里。

但是也許你在問(wèn)： 『 我怎樣才能從這個(gè)列表中獲得值？ 』

很好的問(wèn)題。List有一個(gè)叫做索引的概念。 第一個(gè)元素獲取索引 0 （零）。 第二個(gè)取 1 ，依此類推。 明白了吧。

為了使其更清楚，我們可以用它的索引來(lái)表示數(shù)組和每個(gè)元素。 我可以畫出來(lái)：

使用 Python 語(yǔ)法，它也很容易理解：

my_integers = [5,7,1,3,4]

print(my_integers[0])# 5

print(my_integers[1])# 7

print(my_integers[4])# 4

想象一下現(xiàn)在你不想存儲(chǔ)整數(shù)了。你只是想存儲(chǔ)字符串，就像你親戚名字的列表一樣。 看起來(lái)像這樣：

relatives_names = [

"Toshiaki",

"Juliana",

"Yuji",

"Bruno",

"Kaio"

]

print(relatives_names[4])# Kaio

它的工作方式與整數(shù)相同，漂亮。

我們剛剛了解到Lists索引是如何工作的。 但是我仍然需要告訴你如何將一個(gè)元素添加到List數(shù)據(jù)結(jié)構(gòu)（一個(gè)項(xiàng)目到列表）。

添加一個(gè)值到List最常見的方法是append。讓我們看看他是如何工作的：

bookshelf = []

bookshelf.append("The Effective Engineer")

bookshelf.append("The 4 Hour Work Week")

print(bookshelf[0])# The Effective Engineer

print(bookshelf[1])# The 4 Hour Work Week

append非常的簡(jiǎn)單。您只需要將元素（例如『 The Effective Engineer 』）作為『 append 』參數(shù)應(yīng)用即可。

那么，關(guān)于Lists到這里就結(jié)束了，讓我們來(lái)談?wù)劻硪粋€(gè)數(shù)據(jù)結(jié)構(gòu)。

字典: 鍵-值 數(shù)據(jù)結(jié)構(gòu)

現(xiàn)在我們知道Lists使用整數(shù)來(lái)索引. 但是如果我們不想使用整數(shù)來(lái)索引呢? 一些其他的數(shù)據(jù)結(jié)構(gòu)可以使用數(shù)字，字符串或者其他的類型來(lái)做索引.

讓我們來(lái)學(xué)習(xí)Dictionary數(shù)據(jù)結(jié)構(gòu).Dictionary是一個(gè)鍵值對(duì)集合. 它長(zhǎng)下面這樣:

dictionary_example = {

"key1":"value1",

"key2":"value2",

"key3":"value3"

}

鍵用來(lái)索引到值. 那么我們?nèi)绾卧L問(wèn)Dictionary的值呢? 你猜對(duì)啦?---?使用鍵. 試一下吧:

dictionary_tk = {

"name":"Leandro",

"nickname":"Tk",

"nationality":"Brazilian"

}

print("My name is %s"%(dictionary_tk["name"]))# My name is Leandro

print("But you can call me %s"%(dictionary_tk["nickname"]))# But you can call me Tk

print("And by the way I'm %s"%(dictionary_tk["nationality"]))# And by the way I'm Brazilian

我創(chuàng)建了一個(gè)關(guān)于我的Dictionary. 我的名字, 昵稱和國(guó)籍. 這些屬性是Dictionary的鍵.

我們知道訪問(wèn)List使用下標(biāo), 我們?cè)谶@也使用下標(biāo) (Dictionary中的鍵的內(nèi)容) 來(lái)訪問(wèn)存在Dictionary中的值.

在例子中, 我打印出了存在Dictionary中的所有關(guān)于我的短語(yǔ). 非常簡(jiǎn)單滴~?

另一件關(guān)于Dictionary非常帥氣的事情就是我們可以使用任何東西來(lái)做為字典的值.在我創(chuàng)建的Dictionary中, 我想添加鍵為?"age" 且值為我的整數(shù)年齡進(jìn)去:

dictionary_tk = {

"name":"Leandro",

"nickname":"Tk",

"nationality":"Brazilian",

"age":24

}

print("My name is %s"%(dictionary_tk["name"]))# My name is Leandro

print("But you can call me %s"%(dictionary_tk["nickname"]))# But you can call me Tk

print("And by the way I'm %i and %s"%(dictionary_tk["age"], dictionary_tk["nationality"]))# And by the way I'm Brazilian

這里我們有一個(gè)鍵?(age)?值?(24) 對(duì) 使用字符串來(lái)作為鍵，整數(shù)來(lái)作為值.

像我們學(xué)習(xí)Lists一樣,讓我們來(lái)學(xué)習(xí)如何在Dictionary中添加元素.在Dictionary中， 一個(gè)鍵指向一個(gè)值是很重要的. 這就是為什么我們?cè)谔砑釉氐臅r(shí)候討論它:

dictionary_tk = {

"name":"Leandro",

"nickname":"Tk",

"nationality":"Brazilian"

}

dictionary_tk['age'] =24

print(dictionary_tk)# {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}

我們只需要指定一個(gè)值到Dictionary的鍵上. 一點(diǎn)也不復(fù)雜，484啊?

迭代：循環(huán)Python中的數(shù)據(jù)結(jié)構(gòu)

當(dāng)我們?cè)趯W(xué)習(xí)?Python基礎(chǔ)時(shí), 會(huì)發(fā)現(xiàn)列表的迭代是一件十分簡(jiǎn)單的事情 ，通常我們Python開發(fā)者會(huì)使用For來(lái)循環(huán)迭代它. 現(xiàn)在讓我們嘗試一下:

bookshelf = [

"The Effective Engineer",

"The 4 hours work week",

"Zero to One",

"Lean Startup",

"Hooked"

]

forbookinbookshelf:

print(book)

如你所見我們已經(jīng)對(duì)書架中的書進(jìn)行了for操作，我們輸出打印了其中的書（當(dāng)然你可以在循環(huán)中對(duì)它們做任何事情）。簡(jiǎn)單而又直觀，這就是Python。

同樣對(duì)于哈希類型的數(shù)據(jù)結(jié)構(gòu)，比如像是Python中的字典，我們同樣也可以對(duì)其使用for循環(huán)進(jìn)行迭代操作，但是此時(shí)我們則需要用到key：

dictionary = {"some_key":"some_value"}

forkeyindictionary:

print("%s --> %s"%(key, dictionary[key]))

# some_key --> some_value

這是一個(gè)循環(huán)字典類型變量的小例子，對(duì)于dictionary變量我們使用for循環(huán)操作其中的key，接著我們打印輸出他的key以及其相對(duì)應(yīng)匹配的value值。

當(dāng)然我們還有另外一種方法去實(shí)現(xiàn)它，就是去使用iteritems：

dictionary = {"some_key":"some_value"}

forkey, valueindictionary.items():

print("%s --> %s"%(key, value))

# some_key --> some_value

你看我們已經(jīng)命名了兩個(gè)參數(shù)key,value，但這并不是必須的，你甚至可以給它們起任何一個(gè)名字^.^，讓我們來(lái)看一下：

dictionary_tk = {

"name":"Leandro",

"nickname":"Tk",

"nationality":"Brazilian",

"age":24

}

forattribute, valueindictionary_tk.items():

print("My %s is %s"%(attribute, value))

# My name is Leandro

# My nickname is Tk

# My nationality is Brazilian

# My age is 24

哈哈，可以看到我們已經(jīng)使用了attribute作為了Dictionary的key參數(shù)，代碼運(yùn)行十分正確。贊！

類型與對(duì)象

一點(diǎn)基礎(chǔ)理論:

對(duì)象代表現(xiàn)實(shí)世界中像轎車、狗、自行車這些事物。對(duì)象具有數(shù)據(jù)和行為兩個(gè)主要特征。

在面向?qū)ο缶幊讨?，我們把?shù)據(jù)當(dāng)作屬性，把行為當(dāng)作方法。即：

數(shù)據(jù) → 屬性 和 行為 → 方法

類型是創(chuàng)造單個(gè)對(duì)象實(shí)例的藍(lán)本。在現(xiàn)實(shí)世界中，我們經(jīng)常發(fā)現(xiàn)很多對(duì)象實(shí)例擁有相同的類型，比如轎車。他們都具有相同的構(gòu)造和模型（具有發(fā)動(dòng)機(jī)，輪子，門等等）。每輛車都是根據(jù)同一張?jiān)O(shè)計(jì)圖制作的，并且具有相同的組成部分。

Python 的面向?qū)ο缶幊棠Ｊ剑篛N

Python，作為一門面向?qū)ο缶幊痰恼Z(yǔ)言，具有類和對(duì)象的概念。

類是藍(lán)圖，對(duì)象是模型。

同樣，一個(gè)類，它只是一個(gè)模型，或者一種定義屬性和行為的方法（正如我們?cè)诶碚摬糠炙懻摰模?。例如，車輛類有自己的屬性，定義什么是車輛。車輪的數(shù)量、能源的類型、座位容量和最大速度都是車輛的屬性。

考慮到這一點(diǎn)，讓我們看看類的Python語(yǔ)法：

classVehicle:

pass

我們用一個(gè)類聲明來(lái)定義類?，僅此而已。很簡(jiǎn)單，不是嗎？

對(duì)象是一個(gè)類的實(shí)例，我們用命名類來(lái)創(chuàng)建一個(gè)實(shí)例。

car = Vehicle()

print(car)# <__main__.Vehicle instance at 0x7fb1de6c2638>

這里 ‘car’ 是 ‘Vehicle’ 類的一個(gè)對(duì)象（或者說(shuō)實(shí)例）。

記住，我們的 ‘Vehicle’ 類有四個(gè)屬性：輪子數(shù)量，能源類型，座位容量，和最大速度。我們創(chuàng)建一個(gè) ‘Vehicle’ 對(duì)象時(shí)設(shè)置所有這些屬性 。所以在這里，我們定義我們的類初始化時(shí)要接收數(shù)據(jù)時(shí)：

classVehicle:

def__init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

self.number_of_wheels = number_of_wheels

self.type_of_tank = type_of_tank

self.seating_capacity = seating_capacity

self.maximum_velocity = maximum_velocity

我們使用了 ‘init’方法。我們稱它為構(gòu)造方法。所以創(chuàng)建 ‘vehicle’ 對(duì)象時(shí)可以定義這些屬性。假設(shè)我們喜歡Tesla Model S，我們要?jiǎng)?chuàng)建這種對(duì)象。它有4個(gè)輪子，使用電能，有5個(gè)座位，最大時(shí)速250km/h (155mph）

tesla_model_s = Vehicle(4,'electric',5,250)

4個(gè)“輪子”+電能“能源”+5個(gè)“座位”+250km/h“最大速度”。

所有屬性都設(shè)置完成了。但是我們?nèi)绾潍@取這些屬性值？我們發(fā)送一個(gè)消息到對(duì)象來(lái)問(wèn)他們。 我們稱之為方法. 方法是對(duì)象的行為. 讓我們來(lái)實(shí)現(xiàn)它：

classVehicle:

def__init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

self.number_of_wheels = number_of_wheels

self.type_of_tank = type_of_tank

self.seating_capacity = seating_capacity

self.maximum_velocity = maximum_velocity

defnumber_of_wheels(self):

returnself.number_of_wheels

defset_number_of_wheels(self, number):

self.number_of_wheels = number

這里創(chuàng)建了兩個(gè)方法:?number_of_wheels?和?set_number_of_wheels. 我們稱它為獲取&設(shè)置. 因?yàn)榈谝粋€(gè)獲取了屬性值,然后第二個(gè)設(shè)置了一個(gè)新的屬性值。

Python 中，我們可以用 “@property” (“decorator”) 去定義 "getters" 和 “setters”。請(qǐng)看以下代碼：

classVehicle:

def__init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

self.number_of_wheels = number_of_wheels

self.type_of_tank = type_of_tank

self.seating_capacity = seating_capacity

self.maximum_velocity = maximum_velocity

@property

defnumber_of_wheels(self):

returnself.number_of_wheels

@number_of_wheels.setter

defnumber_of_wheels(self, number):

self.number_of_wheels = number

同時(shí)，我們可以使用這些方法作為屬性：

tesla_model_s = Vehicle(4,'electric',5,250)

print(tesla_model_s.number_of_wheels)# 4

tesla_model_s.number_of_wheels =2# setting number of wheels to 2

print(tesla_model_s.number_of_wheels)# 2

這個(gè)與定義方法有些許不同。這些方法的工作機(jī)制與屬性不同。例如，當(dāng)我們?cè)O(shè)置輪子數(shù)量時(shí)，我們需要把2賦值給一個(gè)變量，只需要設(shè)置 “number_of_wheels” 的值為2。這是一種寫 “pythonic”、 ”getter“、“setter” 代碼的方法。

而且同時(shí)我們也可以使用其他方法，比如 “make_noise” 方法。請(qǐng)看下面的例子。

classVehicle:

def__init__(self, number_of_wheels, type_of_tank, seating_capacity, maximum_velocity):

self.number_of_wheels = number_of_wheels

self.type_of_tank = type_of_tank

self.seating_capacity = seating_capacity

self.maximum_velocity = maximum_velocity

defmake_noise(self):

print('VRUUUUUUUM')

當(dāng)我們調(diào)用這個(gè)方法時(shí)，它返回字符串?”VRRRRUUUUM“。

tesla_model_s = Vehicle(4,'electric',5,250)

tesla_model_s.make_noise()# VRUUUUUUUM

封裝：信息隱藏

封裝是一種限制直接訪問(wèn)對(duì)象數(shù)據(jù)和方法的機(jī)制。但是它加快了對(duì)象方法中數(shù)據(jù)的訪問(wèn)。

"封裝可以在定義中隱藏?cái)?shù)據(jù)和函數(shù)成員，意味著從外部隱藏了對(duì)象定義中的內(nèi)部描述“--- Wikipedia

對(duì)象從外部隱藏了其內(nèi)部描述。只有對(duì)象可以與它的內(nèi)部數(shù)據(jù)進(jìn)行交互。

首先，我們需要了解 “public” 和 “non-public” 變量實(shí)例的工作機(jī)制。

Public 變量實(shí)例

對(duì)于一個(gè) Python 類型，我們可以使用構(gòu)造方法初始化一個(gè)公共變量實(shí)例。我們看這個(gè)：

通過(guò)構(gòu)造方法:

classPerson:

def__init__(self, first_name):

self.first_name = first_name

這里我們使用 “first_name” 的值作為一個(gè)參數(shù)傳遞給公共變量實(shí)例。

tk = Person('TK')

print(tk.first_name)# => TK

在類中：

classPerson:

first_name ='TK'

這里，我們不需要使用 “first_name” 作為一個(gè)參數(shù)，所有的對(duì)象實(shí)例都有一個(gè)用 “TK” 初始化的類屬性。

tk = Person()

print(tk.first_name)# => TK

漂亮。我們已經(jīng)學(xué)習(xí)到可以使用公共變量實(shí)例和類型屬性。另一件關(guān)于 “public” 部分有趣的事情是我們可以管理它的變量的值。我的意思是什么呢？我們的對(duì)象可以管理它的變量值：獲取和設(shè)置變量值。

記住 “Person” 類，我們想要設(shè)置另一個(gè)值給它的 “first_name” 變量：

tk = Person('TK')

tk.first_name ='Kaio'

print(tk.first_name)# => Kaio

好了，我們剛剛設(shè)置了另一個(gè)值（"kaio"）給對(duì)象變量 “first_name”，并且它更新了它的值。就是這么簡(jiǎn)單，因?yàn)檫@個(gè) “public” 變量，我們可以這樣做。

Non-public 變量實(shí)例

“在這里，我們不用‘私有‘來(lái)形容 ，因?yàn)樵赑ython中沒有真正“私有”的屬性（避免了一般情況下不必要的工作）?！?--?PEP?8

和公共變量實(shí)例一樣，我們可以在構(gòu)造函數(shù)或類內(nèi)部定義非公共變量實(shí)例。語(yǔ)法上的差異是： 對(duì)于非公共變量實(shí)例，我們?cè)谧兞棵凹右坏老聞澗€(_)。

“在Python中，無(wú)法從內(nèi)部訪問(wèn)‘私有’變量實(shí)例的對(duì)象是不存在的。但是，大多數(shù)Python代碼遵循一個(gè)慣例：一個(gè)名字前有一道下劃線的對(duì)象應(yīng)該被認(rèn)為是API中非公共的部分，例如_spam，無(wú)論它是一個(gè)函數(shù)、方法或是數(shù)據(jù)成員。”?---?Python Software Foundation

這是一個(gè)例子：

classPerson:

def__init__(self, first_name, email):

self.first_name = first_name

self._email = email

看到email變量了嗎？這就是定義一個(gè)非公共變量的方法。

tk = Person('TK','tk@mail.com')

print(tk._email)# tk@mail.com

所謂非公共變量只是一個(gè)慣例，沒有機(jī)制禁止我們從外部訪問(wèn)并更新它。但按照慣例，我們應(yīng)該把它作為API中非公共的部分來(lái)對(duì)待。

在類內(nèi)部，我們通常使用方法來(lái)操作“非公共變量”，讓我們實(shí)現(xiàn)兩個(gè)方法（email和update_email）來(lái)理解。

classPerson:

def__init__(self, first_name, email):

self.first_name = first_name

self._email = email

defupdate_email(self, new_email):

self._email = new_email

defemail(self):

returnself._email

現(xiàn)在，我們可以通過(guò)這些方法來(lái)訪問(wèn)、更新非公共變量。

tk = Person('TK','tk@mail.com')

print(tk.email())# => tk@mail.com

tk._email ='new_tk@mail.com'

print(tk.email())# => tk@mail.com

tk.update_email('new_tk@mail.com')

print(tk.email())# => new_tk@mail.com

我們以first_nameTK 和emailtk@mail.com 初始化一個(gè)Person對(duì)象。

通過(guò)方法訪問(wèn)非公共變量email，并打印出來(lái)。

從類外部直接設(shè)置一個(gè)新的email。

我們應(yīng)該把非公共變量作為API中非公共的部分來(lái)對(duì)待。

通過(guò)實(shí)例方法更新非公共變量email。

成功！我們可以通過(guò)預(yù)設(shè)的方法來(lái)更新它。

公共方法

通過(guò)公共方法, 我們也可以在我們類的外部使用這些方法了：

classPerson:

def__init__(self, first_name, age):

self.first_name = first_name

self._age = age

defshow_age(self):

returnself._age

讓我們來(lái)試下：

tk = Person('TK',25)

print(tk.show_age())# => 25

贊——用起來(lái)沒有任何問(wèn)題。

非公共方法

但是通過(guò)非公共方法我們卻無(wú)法做到這一點(diǎn)。 我們先來(lái)實(shí)現(xiàn)一個(gè)同樣的Person類，不過(guò)這回我們加個(gè)下劃線(_)來(lái)定義一個(gè)show_age的非公共方法。

classPerson:

def__init__(self, first_name, age):

self.first_name = first_name

self._age = age

def_show_age(self):

returnself._age

那么現(xiàn)在，我們來(lái)試著通過(guò)我們的對(duì)象調(diào)用這個(gè)非公共方法：

tk = Person('TK',25)

print(tk._show_age())# => 25

我們可以訪問(wèn)并且更新它。非公共方法只是一類約定俗成的規(guī)定，并且應(yīng)當(dāng)被看做接口中的非公共部分。

關(guān)于我們?cè)撛趺词褂盟?，這有個(gè)例子：

classPerson:

def__init__(self, first_name, age):

self.first_name = first_name

self._age = age

defshow_age(self):

returnself._get_age()

def_get_age(self):

returnself._age

tk = Person('TK',25)

print(tk.show_age())# => 25

這里我們有一個(gè)_get_age非公共方法和一個(gè)show_age公共方法。show_age可以由我們的對(duì)象調(diào)用（在類的外部）而_get_age只能在我們類定義的內(nèi)部使用(內(nèi)部show_age方法)。但是再次強(qiáng)調(diào)下，這只是個(gè)約定俗成的規(guī)定。

封裝總結(jié)

通過(guò)封裝我們可以從外部隱藏對(duì)象的內(nèi)部表示。

繼承：行為和特征

某些對(duì)象具有共同點(diǎn)：如行為和特征。

例如，我從我父親那里繼承了一些特征和行為。我繼承了他的眼睛和頭發(fā)作為特征，繼承了他的急躁和內(nèi)向作為行為。

在面向?qū)ο缶幊讨?，類能夠從其他類中繼承特征（數(shù)據(jù)）和行為（方法）。

讓我們看另外一個(gè)例子。

假定一輛車。輪子的數(shù)量、載客量和最高時(shí)速是車的所有屬性。那么我們可以認(rèn)為ElectricCar類從這個(gè)Car類中繼承了這些屬性。

classCar:

def__init__(self, number_of_wheels, seating_capacity, maximum_velocity):

self.number_of_wheels = number_of_wheels

self.seating_capacity = seating_capacity

self.maximum_velocity = maximum_velocity

我們的Car類實(shí)現(xiàn)之后:

my_car = Car(4,5,250)

print(my_car.number_of_wheels)

print(my_car.seating_capacity)

print(my_car.maximum_velocity)

一旦初始化后，我們可以使用所有已創(chuàng)建的實(shí)例變量。很好。

在Python中我們可以將父類作為子類定義時(shí)的參數(shù)。一個(gè)ElectricCar類能從之前的Car類中繼承。

classElectricCar(Car):

def__init__(self, number_of_wheels, seating_capacity, maximum_velocity):

Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)

簡(jiǎn)單如上。我們不需要實(shí)現(xiàn)任何其他的方法，因?yàn)檫@個(gè)類已經(jīng)有了（繼承自Car類）。讓我們確認(rèn)一下：

my_electric_car = ElectricCar(4,5,250)

print(my_electric_car.number_of_wheels)# => 4

print(my_electric_car.seating_capacity)# => 5

print(my_electric_car.maximum_velocity)# => 250

漂亮。

就到這里！

關(guān)于Python基礎(chǔ)，我們學(xué)會(huì)了很多：

變量

分支語(yǔ)句

循環(huán)語(yǔ)法

列表：集合 | 數(shù)組

字典：鍵值對(duì)的集合

如何迭代這些數(shù)據(jù)結(jié)構(gòu)

對(duì)象和類

用屬性作為對(duì)象的數(shù)據(jù)

用方法作為對(duì)象的行為

getters、setters 和 property 裝飾器

封裝：信息隱藏

繼承：行為和特征

恭喜！你完成了Python的這段密集的內(nèi)容。

堅(jiān)持學(xué)習(xí)，堅(jiān)持編程，祝你玩得開心！

覺得不錯(cuò)，請(qǐng)把這篇文章分享給你的朋友