python手把手入门_新手必看：手把手教你入门 Python
首先，Python是什么？據(jù)它的創(chuàng)始人Guido van Rossum而言，
“Python是一種高級編程語言，它的核心設計思想是代碼可讀性和允許程序員用幾行代碼來表達觀點的語法。”
就我而言，學習Python的首要理由是，它事實上是一種優(yōu)雅的編程語言，我可以很自然地進行編程和表達想法。
另一個原因就是在許多方面都可以用它來編程：數(shù)據(jù)科學、web開發(fā)以及機器學習都會通過它而大放光彩。Quora, Pinterest and Spotify都用它來做后臺web開發(fā)。那么讓我們一起來了解一下吧！
基礎
1.變量
你可以把變量當成存儲值的字符，就是這么簡單。
Python中可以很容易地定義變量并對其進行賦值。假如你想把數(shù)字1存入一個名為“one”的變量中。讓我們一起來做吧：
one= 1
這到底有多簡單呢？你只需要把值1賦給變量“one”。
two= 2
some_number= 10000
而且你可以將其它任何值賦給其它任何變量。正如上表中你看到的那樣，變量“two”存儲整數(shù)2，“some_number”存儲10000。
除了整型，我們也可以使用布爾型（真/假）、字符串型、浮點型以及其它數(shù)據(jù)類型。
2.控制流：條件語句
“If”是一種判斷語句真假的表達。若為真，就執(zhí)行“if”內部語句。比如：
ifTrue: print("Hello Python If")
if2 > 1: print("2 is greater than 1")
2比1大，因此就執(zhí)行“print”代碼。
如果“if”語句為假就會執(zhí)行“else”語句。
if1 > 2:
print("1 is greater than 2")
else:
print("1 is not greater than 2")
1不大于2，因此就會執(zhí)行“else”內部語句。
你也可以使用“elif”語句：
if1 > 2:
print("1 is greater than 2")elif 2 > 1:
print("1 is not greater than 2")
else:
print("1 is equal to 2")
3.循環(huán)/迭代
Python中有多重循環(huán)方法，我會提及兩種：while和for。
while循環(huán)：當語句為真時，將會執(zhí)行內部的代碼塊。因此代碼將會輸出1到10.
num= 1
whilenum<= 10:
print(num)
num+= 1
while循環(huán)需要“循環(huán)條件”，若它為真就會執(zhí)行循環(huán)。在本例中，當
數(shù)字為11時，循環(huán)條件為假。
另一種基本代碼更容易理解：
loop_condition = True
whileloop_condition:
print("Loop Condition keeps: %s"%(loop_condition)) loop_condition = False
循環(huán)條件為真就執(zhí)行循環(huán)直到循環(huán)條件置為假為止。
for循環(huán)：在塊內你可以使用“num”，而且“for”語句也會執(zhí)行循環(huán)。這段代碼與while代碼（從1到10）的輸出是一樣的。
fori inrange(1, 11):
print(i)
理解？很簡單。從1開始進行直到11，10是第十個元素。
列表：包|數(shù)組|數(shù)據(jù)結構
假如你想將整數(shù)1用一個變量存儲，但是現(xiàn)在你或許還想存2、3、4、5以及更多。
我有其它方法來存儲我想存的所有整數(shù)而不是百萬個變量嗎？你猜到了——事實上有另一種存儲方法。
列表
是可以用來存儲一系列值（就像你想存的這些整數(shù)）的集合。那么一起來用一下吧：
my_integers = [1, 2, 3, 4, 5]
真的很簡單。我們構造一個數(shù)組，并將它存在my_integer。
但是或許你會問：“我怎樣得到這個數(shù)組中的值？”問的好！
列表中有一個索引的概念。第一個元素的索引為0.第二個為1，以此類推，你就明白了。
為了更清楚地表示，我們可以用索引來表示數(shù)組和每個元素。我可以畫一下：
對于Python語言的使用也很容易理解：
my_integers = [5, 7, 1, 3, 4]print(my_integers[0]) # 5
print(my_integers[1]) # 7
print(my_integers[4]) # 4
假如你不想存儲整數(shù)，你想存儲字符串，像你的親人名字的集合。我的看起來是這樣的：
relatives_names = [
"Toshiaki",
"Juliana",
"Yuji",
"Bruno",
"Kaio"
]print(relatives_names[4]) # Kaio
它和整型的操作方式一樣。真棒！
我們只是學習索引如何有效使用，但是我仍然需要告訴你我們如何將一個元素加入數(shù)據(jù)結構（向列表中加入一項）。
向列表中增加一個新值最常見的方法就是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超級簡單。你只需要將這個元素當作參數(shù)使用就行（有效的工程師）。這部分足夠了。讓我們談論下一種數(shù)據(jù)結構吧。
字典：鍵值數(shù)據(jù)結構
現(xiàn)在我們都知道，列表以整數(shù)作為索引，但是我們不想用整數(shù)作為索引怎么辦？我們可以使用的數(shù)據(jù)結構有數(shù)值型、字符串型或者是其它索引類型。
讓我們一起來了解一下字典這種數(shù)據(jù)結構吧。
dictionary_example = {
"key1": "value1",
"key2": "value2",
"key3": "value3"}
字典是鍵值對的集合，值的索引指向鍵。我們如何獲取字典中的值呢？你猜對了——使用鍵。讓我們一起來試一下：
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
我構造了一個有關于我的字典，包括我的姓名、昵稱和國籍。這些屬性都是字典的鍵。正如我們學過的如何使用索引來獲取列表一樣，我們也使用索引來得到存儲在字典中的值。比如，我輸出一句有關我的語句，而它會用到所有存儲在字典中的屬性。非常簡單，對嗎？還有一件很贊的事，我們可以把任何東西當作值來使用。在我所構造的字典中，我想增加一個鍵“年齡”，而且我的真正的整數(shù)年齡也在里面：
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
這里，我們有一組鍵（年齡）值（24）對，其中鍵為字符串型，值為整型。和我們用列表做的一樣，讓我們學一下如何向字典中增加元素吧。字典中很大一部分都是鍵指向值。當我們談論向字典中增加元素的時候，
dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian"
}dictionary_tk['age'] = 24
print(dictionary_tk) # {'nationality': 'Brazilian', 'age': 24, 'nickname': 'Tk', 'name': 'Leandro'}
我們只需要給字典中的鍵賦一個值。這里沒有什么是復雜的，對嗎？
循環(huán)：通過數(shù)據(jù)結構進行循環(huán)
正如我們在Python基礎部分學習的那樣，列表循環(huán)很簡單。Python開發(fā)者一般都是用for循環(huán)。讓我們做一下吧：
bookshelf = [
"The Effective Engineer",
"The 4 hours work week",
"Zero to One",
"Lean Startup",
"Hooked"
]
forbook inbookshelf:
print(book)
對于書架上的每本書，我們（可以用它做任何事）將它打印出來。非常簡單直觀，這就是Python。
對于一個哈希數(shù)據(jù)結構，我們同樣可以使用for循環(huán)，但是我們要運用鍵。
dictionary = { "some_key": "some_value"}
forkeyin dictionary:
print("%s --> %s"%(key, dictionary[key])) # some_key --> some_value
這是一個如何使用的例子。對于字典中的每個鍵，我們都會輸出鍵和與之對應的值。另一種方法是用iteritems方法。我們的確命名兩個參數(shù)key和value，但是這不是很必要。我們可以對它們進行任意命名。讓我們一起來看一下：
dictionary_tk = {
"name": "Leandro",
"nickname": "Tk",
"nationality": "Brazilian",
"age": 24
}
forattribute, value in dictionary_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
我們可以把我們使用的屬性看作是字典key的一個參數(shù)，而且它可以正常運行。好極了！
類和對象
一點點理論
對象表示真實世界中的實體，像汽車、小狗或自行車。對象共享兩個主要特性：數(shù)據(jù)和行為。
汽車有數(shù)據(jù)，比如車輪數(shù)、車門數(shù)以及座位容量。它們也有可顯示的行為：加速、停車、顯示剩余燃料以及其它事情。
在面向對象過程中，我們把數(shù)據(jù)當作屬性，把行為當作方法。再來一次，數(shù)據(jù)——>屬性，行為——>方法。而且從所構造的個體對象來看，類是模型。在現(xiàn)實生活中，我們經常會發(fā)現(xiàn)許多相同類型的實體，比如汽車。模型和形狀都是一樣的（而且都有發(fā)動機、車輪、車門等等）每輛車都用相同的模型和組件。
Python的面向對象的編程模式：ON
Python作為一種面向對象的編程語言，有類和對象的概念。類是對象的模型。類只是一個模型，或者說是一種定義屬性和行為的方法（正如我們在理論部分所談到的那樣）。舉個例子，一個車輛類有自己的屬性，用于定義那些對象是車輛。車輪數(shù)、油箱類型、座位數(shù)和最快速度都是一輛車的屬性。帶著這些，讓我們一起來看看Python中類的語法：
classVehicle:
pass
我們通過類聲明來定義類——就是這樣，很簡單吧！對象是類的一個實例。我們通過命名類來構造一個實例。
car = Vehicle()
print(car) # <__main__.Vehicleinstanceat 0x7fb1de6c2638>
這里的car就是一個類Vehicle的一個對象（或實例）。記得我們的車輛類有四個屬性：車輪數(shù)、油箱類型、座位數(shù)和最快速度。當我們構造一個車輛對象時就需要設置這些屬性。因此這里，我們需要定義我們的類，當它初始化的時候能夠接收數(shù)據(jù)。
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方法。我們稱它為構造方法。因此當我們構造一個車輛實體時，我們可以定義這些屬性。假設我們都喜歡特斯拉模型S，我們想要構造一個這種類型的對象。它是電動的，有四個車輪和五個座位，而且最快速度為250千米/小時（155英里/小時）。讓我們創(chuàng)建一個這種對象：
tesla_model_s= Vehicle(4, 'electric', 5, 250)
對所有屬性進行設置：四個輪子+電動“油箱類型”+五個座位+最快速度為250千米/小時。但是我們如何獲取這些屬性的值呢？我們向該對象發(fā)送了一條查詢屬性值的信息，我們稱之為方法，它是對象的行為。讓我們一起來實現(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
包括兩種方法的實現(xiàn)：車輪數(shù)和車輪數(shù)的設置。我們稱為getter和setter，因為前者獲得屬性值，而后者獲得該屬性的一個新值。
在Python中，我們可以這樣做：用@property(decorators)來定義getter和setter。來看一下代碼：
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
此外，我們可以把這些方法當作屬性來使用：
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
這里有點不同于定義方法，方法和屬性的作用一樣。比如，當我們設置新的車輪數(shù)時，我們不會把2作為參數(shù)，而是把number_of_wheels的值設為2。這是一種getter和setter方法的代碼形式。但是對于其他的我們也可以用一些方法，比如“制造噪音”方法。讓我們一起來看一下：
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')
當我們調用這種方法時，它就會返回一串“VRRRRUUUUM”。
tesla_model_s = Vehicle(4, 'electric', 5, 250)tesla_model_s.make_noise() # VRUUUUUUUM
封裝：隱藏信息
封裝機制不允許直接獲取對象的數(shù)據(jù)和方法，但與此同時，它提供了對數(shù)據(jù)和方法的操作。
“封裝可以用來隱藏數(shù)據(jù)成員和功能成員，在此定義下，封裝意味著一個對象的內部表示通常對該對象以外是隱藏的”?！S基百科
“封裝可以用來隱藏數(shù)據(jù)成員和功能成員，在此定義下，封裝意味著一個對象的內部表示通常對該對象以外是隱藏的”?！S基百科
一個對象的內部表示對外界是隱藏的，只有該對象可以聯(lián)系到其內部數(shù)據(jù)。首先我們需要理解公有和非公有實例變量和方法如何運行。
公有實例變量
對于一個Python類，我們用結構化方法初始化一個公有實例變量，讓我們一起來看一下：
classPerson:def__init__(self, first_name):
self.first_name = first_name
在結構體方法中，我們用first_name的值作為對公有實例變量的聲明。
tk = Person('TK')print(tk.first_name) # => TK
在類中，我們不需要將first_name作為聲明，而且實例對象會有一個類屬性，并用初始化為TK。
tk = Person()print(tk.first_name) # => TK
很棒！現(xiàn)在我們知道我們可以使用公有實例變量和類屬性。另一件有關于公有部分的有趣的事情是我們可以管理變量的值。那意味著什么？對象可以管理和設置其變量的值。
要記得Person類，我們想給它的first_name設置另一個值：
tk = Person('TK')tk.first_name = 'Kaio'
print(tk.first_name) # => Kaio
開始了，我們只是把kaio賦給first_name這個實例變量，而且對其值進行了更新。很簡單，因為它是公有變量，所以我們可以這樣做。
非公有實例變量
這里我們不用“私有”這一術語，因為在Python中不存在真正的私有屬性（一般沒有不必要的工作量）。——PEP 8
這里我們不用“私有”這一術語，因為在Python中不存在真正的私有屬性（一般沒有不必要的工作量）?！狿EP 8
正如public instance variable一樣，我們可以用構造方法或在類內定義non-public instance variable。語法上的不同有：non-public instance variables在變量名前使用下劃線。
“在Python中不存在這樣的情況：在對象內部以外無法獲取‘private’實例變量，然而在Python代碼中一貫遵循的一個習慣是：變量名前要加下劃線前綴（比如：_spam），名字一般作為API的非公有部分（無論它是函數(shù)、方法還是數(shù)據(jù)成員）”——Python Software Foundation
有這樣一個例子：
classPerson:def__init__(self, first_name, email):
self.first_name = first_name
self._email = email
你看到email變量了嗎？它顯示了我們如何定義non-public variable：
tk= Person('TK', 'tk@mail.com')print(tk._email) # tk@mail.com
我們可以獲得并更新它。Non-public variables僅僅是種習慣，而且應該被當作API的非公有部分。因此我們用一種方法，它允許我們在類內對其進行定義。一起來實現(xiàn)以下兩個方法：email和update_email，有助于進一步理解：
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)在我們使用方法可以更新和獲取non-public variables。讓我們一起來看一下：
tk = Person('TK', 'tk@mail.com')
print(tk.email()) # => tk@mail.comtk._email = 'new_tk@mail.com'
print(tk.email()) # => tk@mail.comtk.update_email('new_tk@mail.com')
print(tk.email()) # => new_tk@mail.com
1.我們用TK和tk@mail.com對一個新對象的first_name和email進行初始化。
2.使用方法獲得non-public variable，然后輸出email。
3.試著在我們的類外設置一個新的email。
4.我們需要將non-public variable作為API的non-public部分。
5.用我們的實例方法更新non-public variable。
6.成功了！我們借助幫助方法可以在類內對其進行更新。
公有方法
我們可以在類外使用公有方法
classPerson:def__init__(self, first_name, age):
self.first_name = first_name
self._age = age
defshow_age(self):
returnself._age
讓我們一起來測試一下：
tk = Person('TK', 25)print(tk.show_age()) # => 25
棒極了——沒有任何問題！
非公有方法
對于非公有方法，我們不能那樣做。一起來實現(xiàn)一個同樣的Person類，但是現(xiàn)在我們會用下劃線表示non-public method，即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)在會通過對象來調用這個方法：
tk = Person('TK', 25)print(tk._show_age()) # => 25
我們可以獲得它并對其進行更新。Non-public methods僅僅只是個習慣，而且應該當作API的非公有部分。這里有個例子是有關于對它的使用：
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._agetk = Person('TK', 25)print(tk.show_age()) # => 25
這里我們有一個public method為show_age，我們的對象（在類外）可以使用它，而_get_age只能在類定義部分使用（在show_age方法中）。再次提醒：這只是習慣問題。
封裝總結
有了封裝，我們可以確保對象的內部表示對外是隱藏的。
繼承：行為和特性
某些對象有共同點：行為和特性
舉個例子,我繼承了我父親的一些行為和特性。我繼承了他的眼睛和頭發(fā)作為特性，他的不耐心和內向作為行為。
在面向對象編程中，類可以繼承另一個類的共同特性（數(shù)據(jù)）和行為（方法）。
讓我們一起來看另一個例子，并用Python對其進行實現(xiàn)。
假定有一輛汽車，它的屬性有：車輪數(shù)、座位數(shù)和最快速度。我們可以說電動車類繼承普通車類的這些相同屬性。
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
已經實現(xiàn)了我們的汽車類：
my_car = Car(4, 5, 250)
print(my_car.number_of_wheels)
print(my_car.seating_capacity)
print(my_car.maximum_velocity)
一旦對其進行初始化，我們就可以使用所構造的所有instance variables。非常棒！在Python中，我們可以將parent class作為child class的一個參數(shù)。一個電動車類可以繼承我們的汽車類。
classElectricCar(Car):def__init__(self, number_of_wheels, seating_capacity, maximum_velocity): Car.__init__(self, number_of_wheels, seating_capacity, maximum_velocity)
就是這么簡單。我們不需要實現(xià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
非常漂亮！
僅此而已！
有關Python基礎，我們已經學了很多：
Python的變量如何工作
Python條件聲明如何實現(xiàn)
Python循環(huán)如何實現(xiàn)
如何使用List：Collection|Array
字典鍵值對集合
如何利用這些數(shù)據(jù)結構實現(xiàn)循環(huán)
對象和類
屬性作為對象的數(shù)據(jù)
方法作為對象的行為
使用Python的getters和setters和property裝飾器
封裝：隱藏信息
繼承：行為和特性
祝賀你！你已經完成了有關Python的難理解的部分。
如果你想學習完整的Python課程，學習更多的編程技巧和項目搭建，建議試一下One Month Python Bootcamp部分
有關我的日志學習和編程掌握的更多故事和帖子，可以關注我所發(fā)布的The Renaissance Developer。
玩的開心，繼續(xù)學習并保持編程！
我的Instagram，Twitter，GithubLinkdle。
想要繼續(xù)查看該篇文章相關鏈接和參考文獻？
戳鏈接：
http://www.gair.link/page/TextTranslation/830
AI研習社每日更新精彩內容，點擊文末【閱讀原文】即可觀看更多精彩內容：
良心推薦：一份 20 周學習計算機科學的經驗貼（附資源）
多目標追蹤器：用OpenCV實現(xiàn)多目標追蹤（C++/Python)
為計算機視覺生成大的、合成的、帶標注的、逼真的數(shù)據(jù)集
悼念保羅·艾倫，除了他科技圈還有哪些大佬值得信仰？
等你來譯：
自動文本提取
用 4 種卷積神經網絡，輕松分類時尚圖像
使用 SKIL 和 YOLO 構建產品級目標檢測系統(tǒng)
很有啟發(fā)性的25個開源機器學習項目
號外號外~
想要獲取更多AI領域相關學習資源，可以訪問AI研習社資源板塊下載，
所有資源目前一律限時免費，歡迎大家前往社區(qū)資源中心
（http://www.gair.link/page/resources）下載喔~
總結
以上是生活随笔為你收集整理的python手把手入门_新手必看：手把手教你入门 Python的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python3.9特性_Python3.
- 下一篇： flutter控制显示隐藏_leafle