目錄
一、邏輯控制語句
條件控制語句 if-else
Python 條件控制語句的形式爲：
if Condition1:
Action1
elif Condition2:
Action2
else:
Action3
注意要點
- 每個條件後面要使用冒號
:。 - 使用縮進來劃分語句塊，相同縮進數的語句在一起組成一個語句塊（IDE 會自動縮進）。
- 在 Python 中沒有 switch–case 語句。
條件控制語句實例
實例1：從控制檯輸入兩個數字 A、B，判斷大小後輸出較大數字，如果相等則輸出提示和數值。
#從控制檯輸入數據默認爲字符串類型，需要強制轉換爲int類型
A = int(input("Please enter the number A:"))
B = int(input("Please enter the number B:"))
if A > B:
print('The larger number is:',A)
elif A == B:
print('A and B are equal to ',A)
else:
print('The larger number is:',B)
執行結果：
Please enter the number A:123
Please enter the number B:456
The larger number is: 456
for 循環語句
一般，我們通過 for 循環來遍歷序列中的項目，這裏序列包括但不限於字符串、列表、元組、字典。
for循環的一般形式如下：
for <item> in <sequence>:
<actions>
實例1：求一組數據的平均值。
#測試數據集
num_set = [98,94,82,67,58,90,86]
sumOfNum = 0
#遍歷列表中的元素，求和
for element in num_set:
sumOfNum += element
#求平均值並打印結果
average = sumOfNum/len(num_set)
print("The average is:%f"%(average))
執行結果：
The average is:82.142857
實例2：通過 range() 函數遍歷數據序列，range() 函數可以生成數列，將生成的數列作爲索引，我們可以遍歷數字序列。range() 函數的參數是可變的：
- range(n)：生成步長爲1的數列：1，2，3……n；
- range(m, n)：生成步長爲1的數列：m，m+1，m+2，……，n；
- range(m, n, s)：生成步長爲s的數列：m，m+s，m+2s，……，X(<=n)
for index in range(4):
print("index:",index)
執行結果：
index: 0
index: 1
index: 2
index: 3
實例3：for 循環結合 range() 遍歷數據序列。
#測試數據集
city_set = ['BeiJin','TianJin','ShangHai','HangZhou','SuZhou']
#索引從0開始，以步長2遍歷
for index in range(0,len(city_set),2):
print("city_set[%d]:%s"%(index,city_set[index]))
執行結果：
city_set[0]:BeiJin
city_set[2]:ShangHai
city_set[4]:SuZhou
while 循環
與 for 循環不同，while 循環不是採用遍歷數據序列的方式來進行循環操作的，其循環的依據是條件判斷。
while 循環的一般形式如下，即當 condition 爲 True，則執行 Action，否則退出。
while Conditon:
Action
實例1：求一組數據的平均值。
#初始化測試數據
num_set = [98,94,82,67,58,90,86]
sumOfNum = 0
index = 0
while index < len(num_set):
sumOfNum += num_set[index]
index += 1
#求平均值並打印結果
average = sumOfNum/len(num_set)
print("The average is:%f"%(average))
執行結果：
The average is:82.142857
break 語句
break 語句用於跳出 for 和 while 循環體，也就意味着循環結束。
如下例子：檢測數據集中是否存在小於60的數字，存在則打印提示信息並終止。
#初始化測試數據
num_set = [98,94,82,67,58,90,86]
for i in range(len(num_set)):
if num_set[i] < 60:
print("Someone failed!")
break
else:
print(num_set[i])
執行結果：
98
94
82
67
Someone failed!
在實際應用中，break 語句經常和 while 語句結合使用，當條件滿足的時候跳出循環。
continue 語句
與 break 不同，continue 不會退出循環體，而是跳過當前循環塊的剩餘語句，繼續下一輪循環。
如下例子：遍歷數據集，遇到小於60的數據打印提示。
#初始化測試數據
num_set = [98,94,82,67,58,90,86]
for i in range(len(num_set)):
if num_set[i] < 60:
print("Someone failed!")
continue
print(num_set[i])
執行結果：
98
94
82
67
Someone failed!
90
86
Pass 語句
Python pass 是空語句，一般用做佔位，不執行任何實際的操作，只是爲了保持程序結構的完整性。
如下例子，else 語句本來可以不寫，但寫上更爲完整，這時候 pass 佔位的意義就體現出來了。
#初始化測試數據
num_set = [98,94,82,67,58,90,86]
for i in range(len(num_set)):
if num_set[i] < 60:
print("Someone failed!")
else:
pass
二、函數
在實際應用中，通常以函數作爲一個基本的代碼單元，對一組需求進行抽象，用於完成一項具體的任務。函數能提高應用的模塊性，和代碼的重複利用率。Python 會提供一些內建函數，比如 print()、sqrt()、append()、pop()。我們也可以自己創建函數，這種函數被稱爲用戶自定義函數。
函數的定義與調用
在 C/C++、Java 中，函數（方法）的定義形式如下：
修飾符1，修飾符2，…，返回值類型，函數名（參數列表）
public static String getPath(String basePath, String fileName)
Python 中函數的定義則“簡潔”得多，Python 函數無需聲明返回值類型，也無需修飾符，一般地，函數的定義形式如下：
函數定義符，函數名（參數列表）
def getPath(basePath, fileName):
def getName():
下面的代碼中定義了一個比較函數，並執行了3次調用。
#定義函數
def compare(parameter1, parameter2):
if (parameter1 > parameter2):
print(1)
elif (parameter1 == parameter2):
print(0)
else:
print(-1)
#調用函數
compare(123,456)
compare(3.14,1.5)
compare(12,12.1)
執行結果：
-1
1
-1
參數傳遞
變量與引用
在 Python 中，所有類型：函數、模塊、數字、字符串、列表、元組、字典等等都是對象，而變量是沒有類型的，怎麼理解呢？請看如下實例：
a = 12
print("a=", a)
a = "ABCDE"
print("a=", a)
a = [1,2,3,4,5]
print("a=", a)
a = (1,2,3,4)
print("a=", a)
a = {'key':12,'key1':13}
print("a=", a)
執行結果：
a= 12
a= ABCDE
a= [1, 2, 3, 4, 5]
a= (1, 2, 3, 4)
a= {'key': 12, 'key1': 13}
從上面的例子可以看出，同一段代碼中，同一個變量 a 先後被賦值整數、字符串、列表等多種類型，這是因爲變量本身沒有類型，它僅僅只是一個對象的引用（指針），它可以引用任何類型，上面例子中，變量 a 先後引用多種數據類型，本質上也僅僅是改變指向而已。
不可變類型
上文提及，變量沒有類型，僅僅作爲對象的引用，我們可以再深化一下，如下例子：
a = 12
a = 15
上述過程的實質就是：首先創建一個對象12，讓 a 指向它，然後再創建一個對象 15，再讓 a 指向後者，而前者12就被丟棄。這個過程是通過創建新的對象來實現的，並不是直接改變 a 的值。
這種只能通過創建新的對象才能改變對變量的賦值的數據類型，稱爲不可變類型，如整數、字符串、元組都是不可變類型。再來看一個例子：
def change(x):
x = 10
a = 5
change(a)
print("a=",a)
執行結果：
a= 5
調用 change() 函數並沒有改變變量 a 的內容，這是因爲，定義了一個變量 a，a 指向數字5，然後執行 change 函數，是複製 a 到 x，剛開始 x 也指向數字5，在函數體內執行 x=10，由於整數是不可變對象，所以將創建一個新的對象10，並將10賦值給 x 變量，此時 x 指向10，而 a 本身並沒有發生改變，仍然指向5。
在 Python 中，對於不可變對象，調用自身的任意方法，並不會改變對象自身的內容，這些方法會創建新的對象並返回，保證了不可變對象本身是永遠不可變的。
可變類型
與不可變類型相對就是可變類型，包括列表、字典、集合、隊列等。如下例子：
def change(x):
x.append(2012)
a = [1,2,3,4]
change(a)
print("a=",a)
執行結果：
a= [1, 2, 3, 4, 2012]
很明顯，a 發生了改變，原因分析：執行 change() 方法時，x 指向列表 [1,2,3,4]，因爲列表是可變對象，執行 x.append(5) 時，並不會產生新的對象，而是直接作用在原來列表對象 [1,2,3,4]上，進而列表對象改變爲 [1，2,3,4,5]。
函數的參數類型
Python 中，函數的參數有四種類型：必須參數、關鍵字參數、默認參數和不定長參數。
必須參數
函數在定義的時候，已經聲明瞭參數的數量，我們在調用函數的時候，參數的數量必須與聲明時一致，且要注意順序。
實例1：參數數量要對應。
#聲明參數爲一個
def update(arg):
arg = arg + 1
#正確
update(12)
#不正確，參數缺失
update()
#不正確，參數多餘
update(1,2)
實例2：參數順序要一致。
def printInfo(name, sex, age):
print("name:",name)
print("sex:",sex)
print("age:",age)
#正確
printInfo("Jack","female", 18)
#錯誤，參數順序不對應
printInfo(18,"Jack","female")
關鍵字參數
上面已經提到，調用函數時，不僅參數數量要相等，還要順序匹配。在 Python 中，還有一種方式可以更靈活的匹配參數：函數調用使用關鍵字參數來確定傳入的參數值。
如下實例：
def printInfo(name, sex, age):
print("name:",name)
print("sex:",sex)
print("age:",age)
#都是正確的
printInfo(name="Jack",sex="female",age=18)
printInfo(sex="female",name="Jack",age=18)
printInfo(sex="female",age=18,name="Jack")
默認參數
有些場景下，如果調用函數時，參數錯誤可能會導致不可預期的嚴重後果，因此，爲了增強函數的適應性和容錯性，可以採取一種策略：調用函數時，如果沒有傳遞參數，則會使用默認參數。如下實例：
#聲明參數爲一個
def printInfo(name, sex, age=0):
print("name:",name)
print("sex:",sex)
print("age:",age)
#正確
printInfo(name="Jack",sex="female")
不定長參數
有些場景下，我們希望設計一個參數數量不確定的函數，如任意個整數求和，調用形式可以是：sum(a)、sum(a,b,c)、sum(a,b,c,d)……，這時候我們需要使用一種不定長參數，一般定義形式如下：
def functionname([formal_args,] *var_args_tuple ):
functionbody
加了（*）的變量名會存放所有未命名的變量參數。如果在函數調用時沒有指定參數，它就是一個空元組。我們也可以不向函數傳遞未命名的變量。如下實例：
#定義一個求和函數
def sum(num, *num_list):
sum = num
for element in num_list:
sum += element
print("sum=",sum)
sum(1)
sum(1,2,3,4)
執行結果：
sum= 1
sum= 10
Return 語句
return [表達式] 語句用於退出函數，選擇性地向調用方返回一個表達式。不帶參數值的 return 語句返回 None，表示沒有任何值。如果函數沒有顯式的使用 return 語句，Python 函數也會默認返回 None 對象。
#定義比較函數
def compare(parameter1, parameter2):
if (parameter1 > parameter2):
return 1
elif (parameter1 == parameter2):
return 0
else:
return -1
result = compare(123,456)
print("result=",result)
執行結果：
result= -1
變量作用域
變量的使用非常多，有些地方甚至同名，那麼，它們會不會衝突呢？實例如下：
#這裏的a是全局變量
a = 123
def function():
a = 10 #這裏的a是局部變量
print("I a=",a)
function()
print("II a=",a)
執行結果：
I a= 10
II a= 123
上述實例可見，同名的變量並沒有發生衝突，這是因爲它們的“作用域”不同，變量只在自己的作用域內有效，a=123 處屬於全局變量，function() 函數內部 a=10 屬於局部變量，作用域不同，因此並不會衝突。
作用域分類
按作用域不同，變量可分爲四種類型：L（Local），局部作用域；E（Enclosing），閉包函數外的函數中；G（Global），全局作用域；B（Built-in），內建作用域；
使用變量時，會根據作用域進行查找，優先級順序爲：L –> E –> G –>B，即在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全局找，再者去內建中找。
三、類
Python 是一門完全面向對象的編程語言，在 Python 中，數字、字符串、列表、元組、字典等都是對象。
相較於函數，類則是更高級別的抽象結構，類（Class）是面向對象程序設計（OOP，Object-Oriented Programming）實現信息封裝的基礎。類是一種用戶定義類型，也稱類類型。每個類包含數據說明和一組操作數據或傳遞消息的函數。類的實例稱爲對象，類的實質是一種數據類型。
類的定義
與其它面向對象編程語言類似，在 Python 中，類具有多態、封裝、繼承。不過，Python 中沒有重載，類的定義細節也具有明顯差異。定義類的一般形式如下：
class ClassName:
<statement-1>
.
.
.
<statement-N>
上面提到，類的本質是一種數據結構，一個類通常包含數據成員和函數成員。數據成員用於刻畫類所描述的一類事物的屬性，如描述人，一般用姓名、年齡、性別、學歷等屬性進行刻畫，這就是數據成員；函數成員用於完成具體的任務，如查詢、設置人名、打印基本信息等。如下實例：
#定義一個簡單的類，描述一個人的基本信息
class Person:
#定義類的數據成員：姓名，年齡
name=''
age=0
#定義一個函數：打印類實例的基本信息
def printPersonInfo(self):
print('person-info:{name:%s, age:%d}'%(self.name,self.age))
#定義一個簡單的函數
def hello(self):
print("hello world!")
#實例化，創建一個對象
p1 = Person()
#訪問類的屬性：數據成員,訪問語法obj.X
print("name:",p1.name)
print("age:",p1.age)
#訪問類的函數
p1.printPersonInfo()
p1.hello()
執行結果：
name:
age: 0
person-info:{name:, age:0}
hello world!
self 參數
上述實例中，Person 類定義了兩個函數，其定義形式與函數存在明顯區別：類中的函數必須有一個額外的參數 self，並且 self 參數必須放在第一個參數的位置。那麼，對於一個實例化的對象，self 參數代表什麼呢？來看一個例子。
#定義一個簡單的類，描述一個人的基本信息
class Person:
#定義類的數據成員：姓名，年齡
name=''
age=0
#定義一個函數：打印類實例的基本信息
def printPersonInfo(self):
print('name:',self.name)
print('self:',self)
print('self class:',self.__class__)
#實例化，創建一個對象
p1 = Person()
#訪問類的函數
p1.printPersonInfo()
執行結果：
name:
self: <__main__.Person object at 0x00000000067B5F98>
self class: <class '__main__.Person
從執行結果可以看出，self 的內容是一個地址，它代表當前實例，也就是當前對象的地址。需要說明的是，self 參數並不是 Python 的保留關鍵字，而是爲了便於理解，按照慣例命名而來。事實上，換做其它名字也可以（須遵循規則：必須是類函數的第一個參數）。
實例化
上面，我們創建了一個 Person 類的對象：p1=Person()，通過對象可以訪問類的屬性和調用類的函數，語法形式爲：obj.name，其中 name 代表類的屬性名或函數名。
上述例子中存在一個疑點，例子中實例化對象的操作並不是顯式調用構造函數完成的，如下代碼：
p1 = Person()
類中並沒有定義名爲 Person() 的函數，Person 是類名，在進行實例化創建對象的時候，會自動調用__init()__函數。該函數用於創建對象，並賦予所創建對象初始狀態。
上述例子中，做了很多簡化，創建的對象的所有屬性都是默認值，在實際應用中，通常會採取更有效的方式來賦予對象初始狀態。如下實例：
#定義一個簡單的類，描述一個人的基本信息
class Person:
#定義類的數據成員：姓名，年齡
name=''
age=0
#定義構造函數，用於創建一個類實例，也就是類的具體對象
#通過參數傳遞，可以賦予對象初始狀態
def __init__(self,name,age):
self.name = name
self.age = age
#定義一個函數：打印類實例的基本信息
def printPersonInfo(self):
print('person-info:{name:%s, age:%d}'%(self.name,self.age))
#實例化，創建兩個對象，默認調用構造函數：__init__()
p1 = Person("Zhang San",12)
p2 = Person("Li Si",13)
#訪問類的屬性：數據成員,訪問語法obj.X
print("name:",p1.name)
print("age:",p1.age)
#調用函數
p1.printPersonInfo()
p2.printPersonInfo()
運行結果：
name: Zhang San
age: 12
person-info:{name:Zhang San, age:12}
person-info:{name:Li Si, age:13}
Python 中類定義與 Java、C++ 的差別
從上面的例子中可以發現，Python 中類的定義與 Java 和 C++ 的區別：
- 定義形式，Python 沒有修飾符，只有關鍵詞 class，Java 和 C++ 則有修飾符（非必須）；
- 構造函數，Python 沒有重載特性，只能定義一個構造函數，且函數名爲
__init__，若不定義構造函數，則默認爲__init__(self)，Java、C++ 則具有重載特性，可定義多個構造函數，且構造函數名必須與類名一致； - 形參定義形式不同，Python 類的方法，self 參數爲必須參數；
- 不必聲明域，上面的例子中，聲明瞭域 (name，age)，事實上，Python 可以不聲明域，例子如下：
#定義一個簡單的類，描述一個人的基本信息
class Person:
#定義構造函數，用於創建一個類實例，也就是類的具體對象
def __init__(self,name,age):
self.name = name
self.age = age
#定義一個函數：打印類實例的基本信息
def printPersonInfo(self):
print('person-info:{name:%s, age:%d}'%(self.name,self.age))
繼承
繼承可謂一種帶有褒義的懶惰行爲，一個最直觀的好處就是減少編寫重複代碼，通過繼承，子類可以重用父類中的函數和數據成員。當然，繼承的意義遠不止於此，這裏就不展開了。
關於繼承，通常將實施繼承行爲的類稱爲子類（Child Class）或者派生類（Derived Class），被繼承的類稱爲父類（Parent Class）或者基類（Base Class)。與 Java、C++ 相比，Python 中繼承的一般形式頗爲簡潔：
class childClassName(parentClassName):
<statement-1>
.
.
.
<statement-N>
下面結合實例來看一下，定義一個類 Occupation 和一個繼承 Occupation 的類 Person，繼承的定義形式爲：Person(Occupation)，無需關鍵詞聲明。
#定義一個類Occupation，描述職業
class Occupation:
#定義構造函數
def __init__(self,salary,industry):
self.salary = salary
self.industry = industry
def printOccupationInfo(self):
print('Occupation-info:{salary:%d, industry:%s}'%(self.salary,self.industry))
#定義一個簡單的類Person,繼承自類Occupation
class Person(Occupation):
def __init__(self,name,age):
self.name = name
self.age = age
#定義一個函數：打印類實例的基本信息
def printPersonInfo(self):
print('person-info:{name:%s, age:%d}'%(self.name,self.age))
#創建一個子類對象
temp = Person('Wu-Jing',38)
#訪問父類的數據成員
temp.salary = 21000
temp.industry = "IT"
#分別調用本身和父類的函數
temp.printOccupationInfo()
temp.printPersonInfo()
執行結果：
Occupation-info:{salary:21000, industry:IT}
person-info:{name:Wu-Jing, age:38}
多繼承
一些場景下，一個子類可能需要繼承多個父類，舉個例子：有三個類分別描述職業信息，購物信息，銀行賬戶信息，現在定義一個類Person來描述一個人，顯然，Person涉及上述三個類的信息，爲了重複利用代碼，降低開發難度，可以直接繼承上述三個類，這便是多繼承的應用。如上所述，多繼承定義形式如下：
class childClassName(parentClassName1，parentClassName2，…):
<statement-1>
.
.
.
<statement-N>
關於多繼承，實例如下：
#定義一個類BankAccount，描述銀行賬戶
class BankAccount:
def __init__(self,number, balance):
self.number = number
self.balance = balance
#計算並返回年利息
def getAnnualInterest (self):
return self.balance*0.042
#定義一個類Occupation，描述職業
class Occupation:
def __init__(self,salary,industry):
self.salary = salary
self.industry = industry
def printOccupationInfo(self):
print('Occupation-info:{salary:%d, industry:%s}'%(self.salary,self.industry))
#定義一個類Person,繼承自類BankAccount和BankAccount
class Person(Occupation,BankAccount):
def __init__(self,name,age):
self.name = name
self.age = age
#定義一個函數：打印類實例的基本信息
def printPersonInfo(self):
print('person-info:{name:%s, age:%d}'%(self.name,self.age))
#創建一個子類對象
temp = Person('Wu-Jing',38)
#訪問父類數據成員
temp.number = 622202050201
temp.balance = 1000000.99
temp.salary = 21000
temp.industry = "IT"
#分別調用本身和父類的函數
temp.printOccupationInfo()
temp.printPersonInfo()
print('Annual interest:',temp.getAnnualInterest())
執行結果：
Occupation-info:{salary:21000, industry:IT}
person-info:{name:Wu-Jing, age:38}
Annual interest: 42000.041580000005
需要注意的是，多繼承中，子類繼承了不同父類中的屬性和函數，這些屬性和函數可能存在同名的情況，在子類使用這些同名的函數或屬性時，在沒有指定的情況下，Python 將根據一定順序進行搜索：首先搜索子類，如果未找到則根據多繼承定義的順序，從左至右在父類中查找。
如下實例：
#定義一個類 BankAccount，描述銀行賬戶
class BankAccount:
def printInfo(self):
print('BankAccount-info')
#定義一個類 Occupation，描述職業
class Occupation:
def printInfo(self):
print('Occupation-info')
#定義一個類 Person,繼承自類 BankAccount 和 BankAccount
class Person(Occupation,BankAccount):
def __init__(self,name,age):
self.name = name
self.age = age
def printPersonInfo(self):
print('person-info')
#創建一個子類對象
temp = Person('Wu-Jing',38)
#調用父類中的函數
temp.printInfo()
執行結果：
Occupation-info
很明顯，根據定義順序，優先調用父類 Occupation 中的 printInfo()。
函數的重寫
一些場景下，從父類繼承來的函數並不能完全滿足需求，需要在子類中對其進行修改，這就是重寫的概念：在子類中重寫父類中的函數，當子類對象調用該名稱的函數時，會調用子類中重寫的函數，父類中的同名函數將被覆蓋。
實例如下：
#定義一個類Occupation，描述職業
class Occupation:
#定義構造函數
def __init__(self,salary,industry):
self.salary = salary
self.industry = industry
def printInfo(self):
print('salary:%d, industry:%s}'%(self.salary,self.industry))
#定義一個簡單的類Person,繼承自類Occupation
class Person(Occupation):
def __init__(self,name,age):
self.name = name
self.age = age
#定義一個函數：打印類實例的基本信息
def printInfo(self):
print('name:%s, age:%d'%(self.name,self.age))
print('salary:%d, industry:%s'%(self.salary,self.industry))
#創建一個子類對象
temp = Person('Wu-Jing',38)
#訪問父類的數據成員
temp.salary = 21000
temp.industry = "IT"
#分別調用函數printInfo()
temp.printInfo()
執行結果：
name:Wu-Jing, age:38
salary:21000, industry:IT
私有屬性與私有方法
前面的實例中，類的屬性和函數都是“公有”的，可以通過類對象直接訪問。但是，在某些場景下，我們並不希望對外暴露類的內部細節，爲了限制外部訪問，我們可以將對應的屬性和函數設置爲私有。將類的屬性和函數設置爲私有的一般形式爲以下兩種。
1.定義私有屬性
__attribute：屬性名前面加兩個下劃線，即聲明該屬性爲私有，不能在類的外部直接訪問，在類內部訪問時用 self.__attribute。
2.定義私有函數
__function：函數名前面加兩個下劃線，即聲明該函數爲私有，不能在類的外部直接訪問，在類內部訪問時用 self.__ function。
實例如下：
#定義一個簡單的類，描述一個人的基本信息
class Person:
#定義兩個私有屬性name,age
def __init__(self,name,age):
self.__name = name
self.__age = age
#定義公有函數，在類外部可以訪問
def getName(self):
self.__fun()
return self.__name
def getAge(self):
return self.__age
#定義一個私有函數，只能在類內部使用
def __fun(self):
print('hello')
#實例化
p1 = Person("Zhang San",12)
#訪問類的私有屬性和私有函數，將會報錯
print("name:",p1.__age)
print("age:",p1.__name)
p1.__fun()
對於私有屬性和私有函數，如果需要在類外訪問，可以通過公有函數實現，這與 Java 和 C++ 是一致的。
如下實例：
#定義一個簡單的類，描述一個人的基本信息
class Person:
#定義兩個私有屬性name,age
def __init__(self,name,age):
self.__name = name
self.__age = age
#定義公有函數，在類外部可以訪問
def getName(self):
self.__fun()
return self.__name
def getAge(self):
return self.__age
#定義一個私有函數，只能在類內部使用
def __fun(self):
print('hello')
#實例化
p1 = Person("Zhang San",12)
#訪問類的公有函數
print("name:",p1.getName())
執行結果：
hello
name: Zhang San