1、變量
在Python中使用變量時，需要遵守一些規則和指南。違反這些規則將引發錯誤，而指南旨在讓你編寫的代碼更容易閱讀和理解。請務必牢記下述有關變量的規則。
- 變量名只能包含字母、數字和下劃線。變量名可以字母或下劃線打頭，但不能以數字打頭，例如，可將變量命名爲message_1，但不能將其命名爲1_message。
- 變量名不能包含空格，但可使用下劃線來分隔其中的單詞。例如，變量名greeting_message可行，但變量名greeting message會引發錯誤。
- 不要將Python關鍵字和函數名用作變量名，即不要使用Python保留用於特殊用途的單詞，如print (請參見附錄A.4)。
- 變量名應既簡短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
- 慎用小寫字母l和大寫字母O，因爲它們可能被人錯看成數字1和0。
2、字符串
2.1、修改字符串的大小寫
name = "nsh is a good boy"
print(name.title())
結果
Nsh Is A Good Boy
name = "nsh Is a Good boy"
print(name.title())
print(name.lower())
print(name.upper())
結果：
Nsh Is A Good Boy
nsh is a good boy
NSH IS A GOOD BOY
2.2、合併(拼接)字符串
name = "Good boy!"
hello = "hello,"
print(hello + name)
結果：
hello,Good boy!
2.3、使用製表符或換行符來添加空白
str = "Languages:\n\tPython\n\tC\n\tJavaScript"
print(str)
結果：
Languages:
Python
C
JavaScript
2.4、刪除空白
2.4.1、刪除末尾空格
rstrip()方法：刪除字符串末尾空格，不會改變原有變量
str = "i am a good boy! "
str2 = "i am a good boy!"
print(str.__eq__(str2))
print(str.rstrip().__eq__(str2))
結果：
False
True
2.4.2、刪除字符串開頭空格
lstrip方法：刪除字符串開頭空格，不會改變原有變量
str = " i am a good boy!"
str2 = "i am a good boy!"
str3 = " i am a good boy! "
print(str.__eq__(str2))
print(str.lstrip().__eq__(str2))
print(str3.strip().__eq__(str2))
結果：
False
True
True
2.4.3、刪除字符串兩端空格
strip方法：刪除字符串兩端空格，不會改變變量。
代碼見2.4.2
3、數字
3.1、整數
3.2、浮點數
3.3、str() 避免類型錯誤
age = 23
message = "Happy " + age + "rd Birthday!"
print(message)
結果：
Traceback (most recent call last):
File "/Users/nsh/pythonWork/study/__main__.py", line 9, in <module>
message = "Happy " + age + "rd Birthday!"
TypeError: can only concatenate str (not "int") to str
正確：
age = 23
message = "Happy " + str(age) + "rd Birthday!"
print(message)
結果：
Happy 23rd Birthday!
4、註釋
#開頭的行是註釋
（"""或'''） 三個雙引號或者三個單引號爲段註釋
5、列表
5.1、創建列表
5.1.1、創建字符串列表
arr = ["a","bc","nsh","hah"]
5.1.2、創建數值列表
5.1.2.1、使用range()函數創建
函數range() 讓你能夠輕鬆地生成一系列的數字。不是列表,要創建數字列表，可使用函數list() 將range() 的結果直接轉換爲列表。函數range() 時，還可指定步長
num = range(1,6)
print(num)
for n in num:
print(n)
print("list --------")
num2 = list(range(1,6))
print(num2)
結果：
range(1, 6)
1
2
3
4
5
list --------
[1, 2, 3, 4, 5]
5.2、訪問列表
5.2.1、訪問某個位置的元素
arr = ["a","bc","nsh","hah"] print(arr[0])
5.2.2、遍歷列表
cars = ['bmw', 'audi', 'toyota', 'subaru']
for car in cars:
print(car)
5.3、修改、添加、刪除元素
5.3.1、修改元素
arr = ["a","bc","nsh","hah"]
print(arr)
arr[0]="b"
print(arr)
結果：
['a', 'bc', 'nsh', 'hah']
['b', 'bc', 'nsh', 'hah']
5.3.2、添加元素
arr = ["a","bc","nsh","hah"]
print(arr)
arr.append("boy")
print(arr)
結果：
['a', 'bc', 'nsh', 'hah']
['a', 'bc', 'nsh', 'hah', 'boy']
5.3.3、插入元素
insert() 可在列表的任何位置添加新元素,這種操作將列表中既有的每個元素都右 移一個位置
arr = ["i","am","a","good","boy"]
print(arr)
arr.insert(0,"hello")
print(arr)
結果：
['i', 'am', 'a', 'good', 'boy']
['hello', 'i', 'am', 'a', 'good', 'boy']
5.3.4、刪除元素
5.3.4.1、使用del 刪除元素
arr = ["i","am","a","good","boy"]
print(arr)
arr.insert(0,"hello")
print(arr)
del arr[0]
print(arr)
結果：
['i', 'am', 'a', 'good', 'boy']
['hello', 'i', 'am', 'a', 'good', 'boy']
['i', 'am', 'a', 'good', 'boy']
5.3.4.2、使用pop刪除元素
pop() 可刪除並返回列表末尾的元素
arr = ["i","am","a","good","boy"]
print(arr)
arr.insert(0,"hello")
print(arr)
str = arr.pop()
print(str)
print(arr)
結果
['i', 'am', 'a', 'good', 'boy']
['hello', 'i', 'am', 'a', 'good', 'boy']
boy
['hello', 'i', 'am', 'a', 'good']
pop() 可刪除並返回列表中某個位置的元素
arr = ["i","am","a","good","boy"]
print(arr)
arr.insert(0,"hello")
print(arr)
str = arr.pop(0)
print(str)
print(arr)
結果：
['i', 'am', 'a', 'good', 'boy']
['hello', 'i', 'am', 'a', 'good', 'boy']
hello
['i', 'am', 'a', 'good', 'boy']
5.3.4.3、根據值刪除元素
有時候，你不知道要從列表中刪除的值所處的位置。如果你只知道要刪除的元素的值，可使用方法remove() 。方法remove() 只刪除第一個指定的值。
arr = ["boy","i","am","a","good","boy"]
print(arr)
arr.remove("boy")
print(arr)
結果：
['boy', 'i', 'am', 'a', 'good', 'boy']
['i', 'am', 'a', 'good', 'boy']
5.4、排序
sort() 對列表進行永久性排序
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.sort()
print(cars)
cars.sort(reverse=False)
print(cars)
cars.sort(reverse=True)
print(cars)
結果
['bmw', 'audi', 'toyota', 'subaru']
['audi', 'bmw', 'subaru', 'toyota']
['audi', 'bmw', 'subaru', 'toyota']
['toyota', 'subaru', 'bmw', 'audi']
sorted() 對列表進行臨時排序
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
print(sorted(cars))
print(cars)
結果：
['bmw', 'audi', 'toyota', 'subaru']
['audi', 'bmw', 'subaru', 'toyota']
['bmw', 'audi', 'toyota', 'subaru']
5.5、列表反轉
要反轉列表元素的排列順序，可使用方法reverse()，並非排序，只是將列表的元素反轉，永久性的
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
cars.reverse()
print(cars)
結果：
['bmw', 'audi', 'toyota', 'subaru']
['subaru', 'toyota', 'audi', 'bmw']
5.6、列表的長度
cars = ['bmw', 'audi', 'toyota', 'subaru']
print(cars)
print(len(cars))
結果：
['bmw', 'audi', 'toyota', 'subaru']
4
5.7、數值列表的簡單統計計算
num = [4,6,2,8]
print("max:"+ str(max(num)))
print("min:"+str(min(num)))
print("sum:"+str(sum(num)))
結果：
max:8
min:2
sum:20
5.8、列表解析
列表解析 將for 循環和創建新元素的代碼合併成一行，並自動 附加新元素。
num = [v for v in range(1,5)]
print(num)
num2 = [v ** 2 for v in range(1,5)]
print(num2)
結果：
[1, 2, 3, 4]
[1, 4, 9, 16]
要使用這種語法，首先指定一個描述性的列表名，如squares ;然後，指定一個左方括號，並定義一個表達式，用於生成你要存儲到列表中的值。在這個示例中，表達式 爲value**2，它計算平方值。接下來，編寫一個for循環，用於給表達式提供值，再加上右方括號。在這個示例中，for循環爲for value in range(1,11)，它將值 1~10提供給表達式value**2 。請注意，這裏的for 語句末尾沒有冒號。
5.9、列表切片
處理列表的部分元素——Python稱之爲切片，要創建切片，可指定要使用的第一個元素和最後一個元素的索引。切片會創建一個全新的列表
num = [2,5,8,2,1,6,7]
num_new = num[0:4]
print(num)
print(num_new)
num[0] = 1
print(num)
print(num_new)
結果：
[2, 5, 8, 2, 1, 6, 7]
[2, 5, 8, 2]
[1, 5, 8, 2, 1, 6, 7]
[2, 5, 8, 2]
如果省略第一個索引，Python將自動從列表開頭開始；如果省略終止索引，終止於列表末尾。
5.9.1、遍歷切片
num = [2,5,8,2,1,6,7]
num_new = num[0:4]
print(num)
print(num_new)
for n in num_new:
print(n)
結果：
[2, 5, 8, 2, 1, 6, 7]
[2, 5, 8, 2]
2
5
8
2
5.10、複製列表
通過切片實現
num = [2,5,8,2,1,6,7]
num_copy = num[:]
print(num)
print(num_copy)
print("modify data num[0] = 1")
num[0]=1
print(num)
print(num_copy)
結果：
[2, 5, 8, 2, 1, 6, 7]
[2, 5, 8, 2, 1, 6, 7]
modify data num[0] = 1
[1, 5, 8, 2, 1, 6, 7]
[2, 5, 8, 2, 1, 6, 7]
6、元組（不可變列表）
列表非常適合用於存儲在程序運行期間可能變化的數據集。列表是可以修改的，這對處理網站的用戶列表或遊戲中的角色列表至關重要。然而，有時候你需要創建一系列不可修改的元素，元組可以滿足這種需求。Python將不能修改的值稱爲不可變的 ，而不可變的列表被稱爲元組 。
6.1、定義元組
元組看起來猶如列表，但使用圓括號而不是方括號來標識。定義元組後，就可以使用索引來訪問其元素，就像訪問列表元素一樣。
num = (2,5)
print(num[0])
num[0] = 3
print(num[0])
結果：
Traceback (most recent call last): 2
File "/Users/nsh/pythonWork/study/__main__.py", line 12,
in <module> num[0] = 3
TypeError: 'tuple' object does not support item assignment
6.2、遍歷元組
和列表一樣
6.3、修改元組變量
元組內元素不可變，但是元素變量是可變的
num = (2,5,6)
print(num)
num = (4,5,7)
print(num)
結果：
(2, 5, 6)
(4, 5, 7)
7、if 語句
7.1、檢查多個條件
7.1.1、and 檢查多個條件
7.1.2、or 檢查多個條件
7.2、列表包含
cars = ['bmw', 'audi', 'toyota', 'subaru']
if "bmw" in cars:
print("包含")
else:
print("不包含")
if "nsh" not in cars:
print("不包含")
else:
print("包含")
結果：
包含
不包含
7.3、列表不包含
見7.2列表包含
8、字典
8.1、創建字典
dicts = {"name":"nsh","age":25}
print(dicts)
8.2、訪問字典
8.2.1、訪問單個鍵值對
兩種訪問字典的方式，用法類似Java的HashMap
dicts = {"name":"nsh","age":25}
print(dicts.get("name"))
print(dicts["name"])
結果：
nsh
nsh
8.2.2、遍歷字典
dic={"name":"nsh","age":25,"score":98}
for k,v in dic.items():
print(k)
print(v)
結果：
name
nsh
age
25
score
98
8.2.3、遍歷字典所有鍵
dic={"name":"nsh","age":25,"score":98}
for k in dic.keys():
print(k)
結果：
name
age
score
8.2.4、遍歷字典所有值
dic={"name":"nsh","age":25,"score":98}
for v in dic.values():
print(v)
結果：
nsh
25
98
8.3、添加、修改、刪除字典值
8.3.1、添加字典值
dicts = {"name":"nsh","age":25}
print(dicts)
dicts["sex"]="men" //dicts.__setitem__("sex","men")
print(dicts)
結果
{'name': 'nsh', 'age': 25}
{'name': 'nsh', 'age': 25, 'sex': 'men'}
8.3.2、修改字典值
dicts = {"name":"nsh","age":25}
print(dicts)
dicts["sex"]="men"
print(dicts)
dicts['name']='楊貴妃'//dicts.__setitem__("name","楊貴妃")
print(dicts)
結果
{'name': 'nsh', 'age': 25}
{'name': 'nsh', 'age': 25, 'sex': 'men'}
{'name': '楊貴妃', 'age': 25, 'sex': 'men'}
8.3.3、刪除字典值
dic={"name":"nsh","age":25}
print(dic)
del dic['name']
print(dic)
結果：
{'name': 'nsh', 'age': 25}
{'age': 25}
9、函數
9.1、函數定義
沒什麼好講的，每個語言都一樣
9.2、傳遞參數
9.2.1、位置實參
def test(a="0",b="0"):
print(a+b)
test("1","2")//位置實參
test("2","1")//位置實參
test(a="1",b="2")//關鍵字實參
test(b="2",a="1")//關鍵字實參
test()
結果：
12
21
12
12
00
9.2.2、關鍵字實參
見9.2.1位置實參
9.2.3、傳遞任意數量的實參
有時候，你預先不知道函數需要接受多少個實參，好在Python允許函數從調用語句中收集任意數量的實參。
def test(*arr):
for ar in arr:
print(ar)
test("a","b","dbsd")
結果：
a b dbsd
形參名*arr中的星號讓Python創建一個名爲arr 的空元組，並將收到的所有值都封裝到這個元組中。函數體內的print 語句通過生成輸出來證明Python能夠處理 使用一個值調用函數的情形，也能處理使用三個值來調用函數的情形。它以類似的方式處理不同的調用，注意，Python將實參封裝到一個元組中，即便函數只收到一個值也如此:
9.2.4、結合使用位置實參和任意數量實參
如果要讓函數接受不同類型的實參，必須在函數定義中將接納任意數量實參的形參放在最後。Python先匹配位置實參和關鍵字實參，再將餘下的實參都收集到最後一個形參中。
def test(a,*arr): p
rint(a)
print("__________")
for ar in arr:
print(ar)
test("a","b","dbsd")
結果：
a
__________
b
dbsd
9.2.5、使用任意數量的關鍵字實參
有時候，需要接受任意數量的實參，但預先不知道傳遞給函數的會是什麼樣的信息。在這種情況下，可將函數編寫成能夠接受任意數量的鍵—值對——調用語句提供了多少就接 受多少。
def test(a,*arr,**dic):
print(a)
print("__________")
for ar in arr:
print(ar)
for k,v in dic.items():
print("k:"+k)
print("v:"+v)
test("a","abc","d",k1="v1",k2="v2")
結果：
a
__________
abc
d
k:k1
v:v1
k:k2
v:v2
9.3、函數存儲在模塊中
9.3.1、導入整個模塊
Func.py
def func1():
print("func1")
main.py
import Func
def start():
Func.func1()
start()
只需編寫一條import 語句並在其中指定模塊名，就可在程序中使用該模塊中的所有函數。如果你使用這種import 語句導入了名爲module_name.py 的整個模塊，就可使用下面的語法來使用其中任何一個函數:
module_name.function_name()
9.3.2、導入特定的函數
//導入方法的語法如下:
from module_name import function_name
//通過用逗號分隔函數名，可根據需要從模塊中導入任意數量的函數:
from module_name import function_0,function_1,function_2
9.3.3、使用as 給函數指定別名
如果要導入的函數的名稱可能與程序中現有的名稱衝突，或者函數的名稱太長，可指定簡短而獨一無二的別名 ——函數的另一個名稱，類似於外號。要給函數指定這種特殊外 號，需要在導入它時這樣做。
from Func import func1 as f
def start():
f()
start()
9.3.4、導入模塊中的所有函數
from Func import *
def start():
func1()
start()
10、類
10.1、創建和使用類
10.1.1、創建類
class Dog(object):
def __init__(self,name="",age=0,color=""):
self.__name = name
self.__age = age
self.color = color
def sit(self):
print(self.__name+" sit")
def roll_over(self):
print(self.__name+" roll over")
- 方法__init__()
__init__() 是一個特殊的方法，每當你根據Dog 類創建新實例時，Python都會自動運行它。在這個方法的名稱中，開頭和末尾各有兩個下劃線，這是一種約定，旨在避免Python默認方法與普通方法發生名稱衝突。
我們將方法__init__() 定義成了包含三個形參:self 、name 和age 。在這個方法的定義中，形參self 必不可少，還必須位於其他形參的前面。爲何必須在方法定義中包 含形參self 呢?因爲Python調用這個__init__() 方法來創建Dog 實例時，將自動傳入實參self 。每個與類相關聯的方法調用都自動傳遞實參self ，它是一個指向實例本身 的引用，讓實例能夠訪問類中的屬性和方法。我們創建Dog 實例時，Python將調用Dog 類的方法__init__() 。我們將通過實參向Dog() 傳遞名字和年齡;self 會自動傳遞，因此我們不需要傳遞它。每當我們根據Dog 類創建實例時，都只需給最後兩個形參(name 和age )提供值。
10.1.2、創建實例
dog = Dog("tom",3,"white")
10.1.3、訪問屬性和方法
dog.color//訪問屬性
dog.sit()//調用方法
10.2、繼承
10.2.1、子類的方法 __init__()
class Car():
def __init__(self,name="",color=""):
self.__name = name
self.__color = color
class BMW(Car):
def __init__(self,name="",color="",price=0):
super().__init__(name,color)
self.__price = price
if __name__=="__main__":
bmw = BMW("bmw", "red", 23)
pass
10.2.2、Python 2.7中的繼承
在Python 2.7中，繼承語法稍有不同
class Car(object):
def __init__(self,name="",color=""):
self.__name = name
self.__color = color
class BMW(Car):
def __init__(self,name="",color="",price=0):
super(BMW,self).__init__(name,color)
self.__price = price
if __name__=="__main__":
bmw = BMW("bmw", "red", 23)
pass
函數super() 需要兩個實參:子類名和對象self 。爲幫助Python將父類和子類關聯起來，這些實參必不可少。另外，在Python 2.7中使用繼承時，務必在定義父類時在括號內指 定object 。
10.2.3、子類定義自己的屬性、方法
class Car():
def __init__(self,name="",color=""):
self.__name = name
self.__color = color
def run(self):
print(self.__name+"car is run")
class BMW(Car):
def __init__(self,name="",color="",price=0):
super().__init__(name,color)
self.__price = price //自己的屬性
def getPrice(self): //自己的方法
return self.__price
if __name__=="__main__":
bmw = BMW("bmw", "red", 23)
print(bmw.getPrice())
10.2.4、子類重寫父類方法
class Car():
def __init__(self,name="",color=""):
self.__name = name
self.__color = color
def run(self):
print(self.__name+"car is run")
class BMW(Car):
def __init__(self,name="",color="",price=0):
super().__init__(name,color)
self.__price = price
def getPrice(self):
return self.__price
def run(self):
print("bmw is run")
if __name__=="__main__":
bmw = BMW("bmw", "red", 23)
print(bmw.getPrice())
bmw.run()
10.3、導入類
10.3.1、導入單個類
下面來創建一個只包含Car 類的模塊。這讓我們面臨一個微妙的命名問題:在本章中，已經有一個名爲car.py的文件，但這個模塊也應命名爲car.py，因爲它包含表示汽車的代 碼。我們將這樣解決這個命名問題:將Car 類存儲在一個名爲car.py的模塊中，該模塊將覆蓋前面使用的文件car.py。從現在開始，使用該模塊的程序都必須使用更具體的文件 名，如my_car.py。下面是模塊car.py，其中只包含Car 類的代碼:
car.py
class Car():
def __init__(self,name="",color=""):
self.__name = name
self.__color = color
def run(self):
print(self.__name+"car is run")
下面來創建另一個文件——my_car.py，在其中導入Car 類並創建其實例:
my_car.py
from car import Car
my_new_car = Car('audi', 'red')
my_new_car.run()
10.3.2、在一個模塊中存儲多個類
雖然同一個模塊中的類之間應存在某種相關性，但可根據需要在一個模塊中存儲任意數量的類。類Battery 和ElectricCar 都可幫助模擬汽車，因此下面將它們都加入模塊
car.py中:
class Car():
def __init__(self,name="",color=""):
self.__name = name
self.__color = color
def run(self):
print(self.__name+"car is run")
class BMW(Car):
def __init__(self,name="",color="",price=0):
super().__init__(name,color)
self.__price = price
def getPrice(self):
return self.__price
def run(self):
print("bmw is run")
my_car.py
from car import BMW
my_bmw = BMW('bmw', 'red', 25)
my_bmw.run()
10.3.3、從一個模塊中導入多個類
可根據需要在程序文件中導入任意數量的類。如果我們要在同一個程序中創建普通汽車和電動汽車，就需要將Car 和ElectricCar 類都導入:
from car import BMW,Car
my_bmw = BMW('bmw', 'red', 25)
my_bmw.run()
10.3.4、導入整個模塊
你還可以導入整個模塊，再使用句點表示法訪問需要的類。這種導入方法很簡單，代碼也易於閱讀。由於創建類實例的代碼都包含模塊名，因此不會與當前文件使用的任何名稱發生衝突。
import car
my_bmw = car.BMW('bmw', 'red', 25)
my_bmw.run()
10.3.5、導入模塊中的所有類
from module_name import *
不推薦使用這種導入方式，其原因有二。首先，如果只要看一下文件開頭的import 語句，就能清楚地知道程序使用了哪些類，將大有裨益;但這種導入方式沒有明確地指出你 使用了模塊中的哪些類。這種導入方式還可能引發名稱方面的困惑。如果你不小心導入了一個與程序文件中其他東西同名的類，將引發難以診斷的錯誤。這裏之所以介紹這種導 入方式，是因爲雖然不推薦使用這種方式，但你可能會在別人編寫的代碼中見到它。
10.4、Python標準庫
10.4.1、OrderedDict
字典讓你能夠將信息關聯起來，但它們不記錄你添加鍵—值對的順序。要創建字典並記錄其中的鍵—值對的添加順序，可使用模塊collections 中的OrderedDict 類。OrderedDict 實例的行爲幾乎與字典相同，區別只在於記錄了鍵—值對的添加順序。
11、文件和異常
11.1、從文件讀取數據
11.1.1、讀取整個文件
with open('test.txt') as f:
Str = f.read()
print(Str)
11.1.2、逐行讀取文件
if __name__=="__main__":
with open('test.txt') as f:
for l in f:
print(l)
我們通過對文件對象執行循環來遍歷文件中的每一行。我們打印每一行時，發現空白行更多了；爲何會出現這些空白行呢?因爲在這個文件中，每行的末尾都有一個看不見的換行符，而print 語句也會加上一個換行符，因此每行末尾都有兩個換行符:一個來自文件，另一 個來自print 語句。要消除這些多餘的空白行，可在print 語句中使用rstrip() :
if __name__=="__main__":
with open('test.txt') as f:
for l in f:
print(l.rstrip())
或
if __name__=="__main__":
with open('test.txt') as f:
while True:
s = f.readline()
if s:
print(s)
else:
break
11.2、寫入文件
11.2.1、寫入空文件
if __name__=="__main__":
msg = "i love you"
with open('test.txt','w') as f:
f.write(msg)
在這個示例中，調用open() 時提供了兩個實參。第一個實參也是要打開的文件的名稱;第二個實參('w' )告訴Python，我們要以寫入模式 打開這個文件。打開文件 時，可指定讀取模式 ('r' )、寫入模式 ('w' )、附加模式 ('a' )或讓你能夠讀取和寫入文件的模式('r+' )。如果你省略了模式實參，Python將以默認的只讀模式打 開文件。
如果你要寫入的文件不存在，函數open() 將自動創建它。然而，以寫入('w' )模式打開文件時千萬要小心，因爲如果指定的文件已經存在，Python將在返回文件對象前清空 該文件。
函數write() 不會在你寫入的文本末尾添加換行符，因此如果你寫入多行時沒有指定換行符，文件看起來可能不是你希望的那樣:
11.3、異常
Python使用被稱爲異常 的特殊對象來管理程序執行期間發生的錯誤。每當發生讓Python不知所措的錯誤時，它都會創建一個異常對象。如果你編寫了處理該異常的代碼，程序將繼續運行;如果你未對異常進行處理，程序將停止，並顯示一個traceback，其中包含有關異常的報告。
異常是使用try-except 代碼塊處理的。try-except 代碼塊讓Python執行指定的操作，同時告訴Python發生異常時怎麼辦。使用了try-except 代碼塊時，即便出現異常，程序也將繼續運行:顯示你編寫的友好的錯誤消息，而不是令用戶迷惑的traceback。
11.3.1、使用try-except 代碼塊
if __name__=="__main__":
try:
a = 1/1
except Exception as e:
print("error")
else:
print("o")
finally:
print("f")
通過將可能引發錯誤的代碼放在try-except 代碼塊中，可提高這個程序抵禦錯誤的能力。錯誤是執行除法運算的代碼行導致的，因此我們需要將它放到try-except 代碼塊中。這個示例還包含一個else 代碼塊;依賴於try 代碼塊成功執行的代碼都應放到else 代碼塊中；finally代碼塊無論try成功與否都會執行。