本篇文章針對將Python作為第二語言的使用者觀看（已有Java或C基礎的使用者）
因為之前學習過Java語言，所以本篇文章主要針對Python的特徵和一些基本語法來展開介紹
下面我們將從以下角度來介紹：
首先我們需要了解一下Python的基本資訊
首先我們要了解為什麼要學習Python：
Python在計算機領域上被稱為解釋性語言：
Python在使用中有以下優點：
首先我們需要下載最近穩定版本的Python，這裡給出一個連結，直接下載即可：
Python下載 | Python中文網 官網 (p2hp.com)
我們通常書寫程式碼是在PyCharm，社群版功能基本夠用，網上也有破解版，這裡給出社群版的下載地址：
Download PyCharm: Python IDE for Professional Developers by JetBrains
下面我們來介紹Python的基本語法資訊
首先我們需要知道Python的註釋資訊標註方法：
# 用#來表示註釋資訊
# 在#後面所書寫的內容不會被注入Python執行器中
第二步我們需要了解怎麼去書寫一個Python程式碼：
# python中是不存在主函數的概念的，當然你也可以通過書寫一個main方法來當作主函數
# 我的意思是：你可以直接在編譯器中輸入對應語法並右鍵run執行，就可以執行最基本的python語言
# 例如我們只需要在編譯器中書寫print("hello,python!"),我們就可以run執行在資訊欄收到該輸出資訊
print("hello,python!")
# 當然你也可以選擇使用main方法進行輸出,在if左側會有對應的執行按鈕，相當於一個方法的執行
if __name__ == '__main__':
print("hello,python!")
# 在pyCharm編譯器中，你只需要輸入main，點下Tab鍵就會自動補全main方法語法內容：
main+Tab:
if __name__ == '__main__':
第三步我們來學習Python識別符號的命名規則：
# 識別符號可以包括英文、數位以及下劃線
# 1.開頭必須是字母或下劃線,不能以數位開頭開頭
# 2.識別符號是會區分大小寫的，例如myList和MyList是不同的兩個變數
# 3.不能出現分隔符、標點符號或者運運算元
# 4.不能使用關鍵字：def if for while class等
首先我們需要了解變數的基本概念：
然後我們需要了解Python的變數生效方法：
# Python中對於基本型別沒有固定的型別概念
# 也就是說我們的Python變數不需要初始化或者說初始化時不需要指定型別
my_intSum = 1
my_Str = "你好"
剛好我們順便來了解一下python的基本資料型別：
# Python僅僅是不需要去指定型別，但是不代表它沒有資料型別
# Python的資料是沒有上限值的，因此我們不需要擔心Python的資料會因為長度過長導致錯誤
# int整型：
# 整數：沒有小數部分的數值，分為正整數、0和負整數
my_int1 = 100
my_int2 = -100
my_int3 = 0
# float浮點數：
# 浮點數：包含小數點的數
my_float1 = 100.123
my_float2 = 2.3e2 # 科學計數法
# complex複數：
# 複數由兩部分組成：實部和虛部。複數的形式為：實部+虛部j
my_complex1 = 2+3j
my_complex2 = 0.5-0.9j
# bool布林：
# 布林型別是用來表示邏輯「是」、「非」的一種型別，它只有兩個值，True和False （首字母T和F是大寫的）
# Python將布林值True實現為1（int型別），False實現為0，所以可以參與整型運算
my_bool1 = True
my_bool2 = False
# str字串:
# Python語言中的字串是一種序列，字串用單引號、雙引號、三引號作為定界符
my_str1 = "hello,python"
# list列表:
# 列表採用"[]"進行封包裝，並且採用","來進行資料隔離，可以儲存不同型別
my_list1 = ［1,2,3,True］
my_list2 = ［「one」,「two」,「three」,「four」］
# tuple元組:
# 元組屬於一種另類的List列表，元組採用"()"進行封包裝並且採用","來進行資料隔離，但是元組的資料不能修改
my_tuple1 = (1,2,3,True)
my_tuple2 = (「one」,「two」,「three」,「four」)
# dict字典:
# 字典類似於Java中的Map，屬於鍵值對型別，採用"{}"進行封包裝並且採用","來進行資料隔離，內部採用":"進行資料賦值
my_dict1 = {"胡桃"："火屬性","鍾離":"巖屬性"}
my_dict2 = {"胡桃"：158,"鍾離":"老爺子"}
# set集合:
# 集合是由各種不可變型別的元素組成，但元素之間無序，並且元素都不重複,採用"{}"進行封包裝
my_set1 = {‘car’, ‘ship’, ‘train’, ‘bus’}
my_set2 = {"我的快樂"，"不想上班"}
我們首先需要知道Python的賦值語句格式：
# Python基本賦值語句和Java沒有區別
x = 1
y = x
a = b = 1
# 但是Python可以快速實現資料交換（python的資料不會實時更新，它是在語句執行結束後才會更新）
# 例如下述交換語句效果相同
x,y = y,x
tmp = x
x = y
y =tmp
此外我們簡單瞭解一下Python的運運算元：
# Python運運算元和Java也基本一致
# +運運算元
# 同型別+有效
1+2
"hello"+"Python"
# 不同型別」+「無效（下面是無法生效的）
3+"ab"
# *運運算元
# *運運算元可以用於數值相乘
1*2
20*30
# "*"運運算元可以用於列表、元組或字串和整數相乘，相當於多個資料相加；但是dict和set不可以，因為兩者不允許同樣的資料出現！
[1,3,5] * 2
('a','b','c') * 2
'Hello' * 2
# ** 運運算元
# 冪運算，與內建函數pow()相同
2 ** 3 = 8
# / 真除法 與 //整數除法
# / 真除法獲得全部值，但是//只會獲得保留整數的數值
5/2 = 2.5
5//2 = 2
# 關係運算子：<（小於）、<=（小於等於）、>（大於）、>=（大於等於）、==（等於）、!=（不等於）；運算結果：布林值True或False
# 列表比較大小：從左到右逐個元素的依次比較，類似字串之間的比較，但是需要注意字串和數位屬於不可比較大小的！
# 測試運運算元：in、not in、is、is not；運算結果：布林值True或False
# in（判斷屬性是否存在）
2 in [2,3,4]
# is（判斷是否是同一物件）
str1 = "abc"
str2 = "abc"
str1 is str2 # False
str1 == str2 # True
# 邏輯運運算元:and（與）、or（或）、not（非）;通過邏輯運運算元可以將任意表示式連線在一起
# 需要注意：當可以判斷結果時，後面的語句將不再執行
# Python沒有自加++與自減--
我們簡單瞭解一下Python的輸入輸出語句：
# 首先我們瞭解一下輸入語句
# input("提示資訊")
x = input("請輸入x的值：")
# 然後我們再瞭解一下輸出語句
# print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
# value：輸出內容
# sep：物件之間的間隔符，預設用一個空格分隔
# end：以什麼字元結尾，預設值是換行符
# file：表示輸出位置，可將輸出到檔案，預設是控制檯
# flush：將快取裡面的內容是否強制重新整理輸出，預設值是False
print('hello','python','!',sep=',', end='!')
# 最後再來了解一個運算語句
# 因為我們在實際使用過程中可能出現資料型別不符合條件的狀況，我們可以採用eval來進行計算獲取值
# eval(source, globals=None, locals=None, /)
# source：字串，這個字串能表示成Python表示式，或者是能夠通過編譯的程式碼
# globals：可選的引數，預設為None，如果設定屬性不為None的話，就必須是dictionary物件
# locals：可選的引數，預設為None，如果設定屬性不為None的話，可以是任何map物件
# 字串中是表示式：返回表示式的值
# 字串中是列表、元組或字典：得到真正的列表、元組或字典
# 字串中是能夠通過編譯的程式碼：執行程式碼
eval('x+1') # 表示式：x+1
eval('3+5') #8
eval('[1,2,3]') # 返回列表[1,2,3]
eval("__import__('os').getcwd()") # 執行語句：獲取當前目錄
# 我們通常將input和eval合併使用，因為我們單獨使用input輸入列表等資訊時可能出現報錯資訊：
x=eval(input("請輸入x值：")) #輸入列表格式：[1,2,3]
x=eval(input("請輸入x值：")) #輸入字典格式：{'a':1,'b':2}
下面我們以表格形式列出內建函數庫：
| 函數 | 功能 |
|---|---|
| abs(x) | 返回數位x的絕對值，如果給出複數，返回值就是該複數的模 |
| eval(s[,globals[,locals]]) | 計算字串中表示式的值並返回 |
| input(prompt=None, /) | 接受鍵盤輸入，顯示提示資訊，返回字串 |
| len(obj) | 返回物件obj（列表、元組、字典、字串、集合、range物件）的元素個數 |
| map(func, *iterables) | 包含若干函數值的map物件，其中func表示函數，iterables表示迭代物件，將函數作用於迭代物件 |
| max(x[,y,z…])、min(x[,y,z…]) | 返回給定引數的最大值、最小值，引數可以為可迭代物件 |
| pow(x,y[,z]) | pow()函數返回以x為底，y為指數的冪。如果給出z值，該函數就計算x的y次冪值被z取模的值 |
| print(value, …, sep=’ ‘, end=’\n’) | 輸出物件，預設輸出到螢幕，相鄰資料之間使用空格分隔，結尾以換行符結束 |
| range([start,]end[,step]) | 返回range物件，該物件包含按引數（[start,end)範圍內，step為步長）生成的整數 |
| round(x[,n]) | 返回浮點數x的四捨五入值，若不給出n值，則返回整數；給出n值，則代表舍入到小數點後的位數 |
| sorted(iterable, /, *, key=None, reverse=False) | 返回排序後的列表，其中iterable表示要排序的序列或迭代物件，key表示排序規則，reverse表示升序或降序，預設升序 |
| sum(iterable, start=0, /) | 返回序列iterable中所有元素之和，如果指定起始值start，則返回start+sum(iterable);如果iterable為空，則返回start |
| float(x=0, /) | 把一個數位或字串轉換成浮點數 |
| int(x[,base]) | 把數位和字串轉換成一個整數，或把base進位制的字串x轉換為十進位制，base為可選的基數，預設為十進位制 |
| list([x])、tuple([x])、dict([x])、set([x]) | 將物件x轉換成列表、元組、字典、集合，或生成空列表、空元組、空字典、空集合 |
| chr(i) | 返回Unicode編碼為i所對應的字元，0 <= i <= 0x10ffff |
| ord(x) | 返回一個字元的Unicode編碼 |
下面我們來介紹Python的流程控制語法
我們的分支流程一般採用IF進行分支劃分
下面我們來介紹一下python的基本IF使用方法：
# Python的IF語句和Java完全相同
# 單IF判斷
if x > 5:
print("x>5,符合條件")
# 多IF判斷：
if x < 3:
print("x<3")
elif x > 5:
print("x>5")
# 多IF且ELSE判斷：
if x < 3:
print("x<3")
elif x > 5:
print("x>5")
else:
print("x不滿足條件")
# 注意：Python中不存在switch流程控制
我們的迴圈流程一般採用for或者while進行迴圈
下面我們來介紹一下python的基本for和while迴圈使用方法：
# for迴圈
# for 變數 in 序列或迭代器等可迭代物件:
# 迴圈體
my_list = [20,30,40]
for i in my_list:
print("i")
# 這裡我們補充一個range方法，我們在上面的內建函數資訊中也提到了
# range(start, stop[, step])
# 其中start表示起始值，例如0，則說明該陣列從0開始
# 其中stop表示停止值，但不能包含stop，例如10，則我們的陣列到10之前結束，也就是到9結束
# 其中step表示步數，也就是我們之間相隔的個數，預設為1，即陣列從1，2，3...9，但若我們賦值為2，即陣列從1，3，5...9
for i in range(0,10):
print("i")
# 此外break和continue在Python中同樣適用
for i in range(0,10):
if i/2==0:
continue # 當i為偶數時，跳過當前回圈執行
print("i")
for i in range(0,10):
if i/2==0:
break # 當i為偶數時，直接跳出該回圈
print("i")
# while迴圈
# while迴圈和Java最基礎的while迴圈是相同的
# python的while迴圈是可以新增else語句的
# while 條件表示式:
# 迴圈體
# else：
# else語句塊
while(i>5):
i = i-1
else:
print("i已經不再大於5") # 但當while是通過break跳出迴圈時，else不再執行
# 同理，針對for也存在else情況
# for 變數 in 序列或迭代器等可迭代物件:
# 迴圈體
# else:
# else語句塊
for i in range(0,10):
print("i")
else:
print("range的迴圈輸出語句已經執行完畢")
下面我們來介紹Python中使用到的資料結構
我們首先來介紹序列中的List：
下面我們來介紹序列List的各種操作方法：
# List的建立大致分為兩種
# 直接進行賦值建立或者採用構造方法進行建立
my_list0 = []
my_list1 = [1,"小米手機",10.15]
my_list2 = list()
my_list3 = list([1,3,5])
list_sample=[['I','LOVE','YOU'],['I','HATE','YOU']]
# List的元素獲取
# List的索引和Java陣列相同，從0開始，從左到右依次遞增
my_list1[0]
# List的索引存在負數，例如-1就是最後一個元素，可以採用負數進行資料獲取
my_list1[-1]
# Python存在一種特性叫做切片，即從第i個元素到第j個元素
# my_list1[start:stop:step],同理從start開始到stop前面結束，以step為步數進行獲取
my_list[0:1] # 表示第一個元素
my_list[0:3] # 表示第一個元素到第三個元素
my_list[0:3:2] # 表示第一個元素和第三個元素
my_list[-3:-1:2] # 表示倒數第三個元素和倒數第一個元素
# List元素修改
my_list1[0] = 2
my_list1[1] = 123
# List元素修改也可以採用切片形式，當數量不夠時元素被刪除掉
my_list1[0:3] = [1,2,3]
my_list1[0:3] = [1,2]
# del命令
# del屬於命令，用於刪除元素或本體
del my_list0
del my_list1[2]
# List相加
# List相加只會建立新的list，不會影響原有的list
my_list4 = my_list1 + my_list2
my_list4 += ["bike"]
# List相乘
# List只能和整數相乘，相當於n份相同的list相加，建立新的list，不會影響原有資料
my_list5 = my_list4 * 2
# index方法
# index(value[,start=0[,stop]])
# 尋找在start和stop之間的第一個value的下標位置
# start沒指定：則從索引為0的位置開始查詢，否則從索引為strat的位置開始查詢
# stop沒指定：可以查詢到列表最後元素，否則在位於[start, stop)內的索引區間查詢。
# 如果找不到匹配項，就會引發異常
res = my_list3.index(3)
# count方法
# 統計某個元素在列表中出現的次數
res = my_list3.count(3)
# append方法
# 追加單個元素到列表的尾部，只接受一個元素
my_list.append(1)
my_list.append(my_list1[0:2]) # 這裡新增的是一個list型別，相當於巢狀的list
# extend方法
# 在列表的末尾一次性追加另一個列表中的多個值（只能有一個引數）
my_list.extend(my_list1[0:2]) # 這裡新增的是多個資料，相當於新增多個資料
# insert方法
# 將一個元素插入到指定位置
# 兩個引數：第一個引數是索引點，即插入的位置，第二個引數是插入的元素
my_list.insert(0,"第一個數")
# remove方法
# 用於移除列表中與某值匹配的第一個元素；如果找不到匹配項，就會引發異常
my_list.remove("第一個數")
# pop方法
# 移除列表中的一個元素（預設為最後一個元素），並且返回該元素的值（出棧）；可以指定索引位置
# 當不在索引範圍內或者是空列表中，均會觸發異常
my_list.pop()
my_list.pop(0) # 第0個位置的數
# clear方法
# 刪除列表中所有元素，但保留列表物件
my_list.clear()
# reverse方法
# 用於將列表中的元素位置反向存放
my_list.reverse()
# sort方法
# reverse引數：預設為False（升序），若等於True表示降序排序
my_list.sort()
然後我們來介紹序列中的Tuple：
下面我們來介紹序列Tuple的各種操作方法：
# Tuple的方法和List基本相同，下面有些重複內容不再做註釋解釋
# Tuple的建立方法
# 直接進行賦值建立或者採用構造方法進行建立
tuple4=()
tuple1 = ('a',200,'b',150, 'c',100)
tuple5 = tuple()
# Tuple的存取方法
tuple1=('train', 'bus', 'car', 'ship', 'subway', 'bicycle')
tuple1[3]
tuple1[-3]
tuple1[0:3:2]
tuple1[-3:-1:2]
# Tuple相加
tuple3 = tuple1 + tuple2
tuple3 += ("新資料")
# Tuple相乘
tuple4 = tuple3 * 2
# 列表–>元組
# tuple()函數：接受一個列表，並返回一個包含同樣元素的元組
my_tuple1 = tuple(my_list1)
# 元組–>列表
# list()函數：接受一個元組，並返回一個包含同樣元素的列表
my_list1 = list(my_tuple1)
然後我們來介紹欄位dict：
下面我們來介紹字典dict的各種操作方法：
# 建立字典
# 字典建立分為直接建立，構造方法建立，序列方法建立
# 注意：字典是無序集合，字典的顯示次序由字典在內部的儲存結構決定
my_dict1 = {}
my_dict1 = {"胡桃":10,"鍾離":20,"刻晴":30}
my_dict2 = dict()
my_dict2 = dict({"胡桃":10,"鍾離":20,"刻晴":30})
keys = ["胡桃","鍾離","刻晴"]
values = [10,20,30]
my_dict3 = dict(zip(keys,values))
# 檢視字典元素
# 通過key來查詢value
my_dict1["胡桃"]
# 修改字典元素
# 通過key來修改value
my_dict1["胡桃"] = 100
# len方法
# 獲得字典的元素個數
my_dict1.len()
# del命令
# 刪除字典元素或者字典本身
del my_dict1
del my_dict1["胡桃"]
# in方法
# 判斷該欄位是否是字典的key值
res = "胡桃" in my_dict2
# keys方法 values方法
# 獲得字典的key集合和value集合
my_dict1.keys
my_dict1.values
# items方法
# 獲得字典的items集合（key和value組合的集合）,需要轉換成list或者tuple才能檢視
list(my_dict1.items())
tuple(my_dict1.items())
# setdefault方法
# 如果字典中包含引數key對應的鍵，則返回該鍵對應的值
# 否則以引數key的值為鍵，以引數default的值為該鍵對應的值，在字典中插入鍵-值對元素，並返回該元素的值部
my_dict1.setdefault("胡桃") # 返回對應value值
my_dict1.setdefault("胡桃"，20) # default值和value值不同，返回value值
my_dict1.setdefault("小草神") # 不存在這個值，建立該key，由於無value值，該value為None（Java的null）
my_dict1.setdefault("巴爾"，50) # 不存在這個值，建立該key，且value為50
# update方法
# 將另一個字典中的所有鍵值對一次性地新增到當前字典中
# 如果兩個字典中存在有相同的鍵，則以另一個字典中的值更新當前字典
my_dict1 = dict({"胡桃":20,"鍾離":20,"刻晴":30,"wuhu":90})
my_dict2 = dict({"胡桃":10,"鍾離":20,"刻晴":30})
my_dict2.update(my_dict1) # 則胡桃變為20，且新添wuhu欄位value為90
# clear方法
# clear()方法將字典中的所有條目刪除，變成空字典
my_dict1.clear()
# pop，popitem方法
# pop()方法能夠彈出並刪除字典中的鍵值對；popitem()方法能夠彈出字典的一個元素，如果字典為空則觸發異常
my_dict1.pop()
my_dict1.popitem()
# get方法
# 返回指定鍵所對應的值，如果鍵不存在則返回預設值。預設值為None，也可以自己指定
my_dict1.get("胡桃")
# 列表與字典之間的轉化：字典–>列表
# 如果直接轉化，則預設是鍵轉化為列表
list(abbreviation)
list(abbreviation.keys())
list(abbreviation.values())
list(abbreviation.items())
# 元組與字典之間的轉化：字典–>元組
# 如果直接轉化，則預設是鍵轉化為列表
tuple(abbreviation)
tuple(abbreviation.keys())
tuple(abbreviation.values())
tuple(abbreviation.items())
然後我們來介紹集合Set：
下面我們來介紹集合Set的各種操作方法：
# 集合的建立
# 集合建立分為直接建立，構造方法建立
my_set1 = {1,2,3}
my_set1 = set() # 注意：空集合只能用構造方法建立
my_set1 = set({1,2,3})
# len() 、max()、min()、sum()方法
# 分別對應長度，最大值，最小值，總值
nums = {4,3,8,9,0,-5,7}
len(nums)
max(nums)
min(nums)
sum(nums)
# in
# 判斷某元素是否存在於集合之中，判斷結果用布林值True或False表示
res = 1 in my_set1
# 並集，交集，差集
# 並集：建立一個新的集合，該集合包含兩個集合中的所有元素
my_set1|my_set2
# 交集：建立一個新的集合，該集合為兩個集合中的公共部分
my_set1&my_set2
# 差集：A-B表示集合A與B的差集，返回由出現在集合A中但不出現在集合B中的元素所構成的集合
my_set1-my_set2
# 並集，交集，差集運算
# union()：相當於並集運算，產生新集合，不對原有集合產生影響
# intersection()：相當於交集運算，產生新集合，不對原有集合產生影響
# difference()：相當於差集運算，產生新集合，不對原有集合產生影響
# update():相當於集合元素合併運算，注意與union()方法的區別,直接將set2的資料放入set1
new_set = my_set1.union(my_set2)
new_set = my_set1.intersection(my_set2)
new_set = my_set1.difference(my_set2)
new_set = my_set1.update(my_set2)
# add方法
# 向集合中新增元素
new_set.add("新資料")
# remove方法
# 從集合中刪除元素，如果集合中沒有該元素，則出錯
new_set.remove("舊資料")
# discard方法
# 從集合中刪除元素，如果集合中沒有該元素，也不提示出錯
new_set.discard("舊資料")
# pop方法
# 從集合中刪除任一元素，並返回該元素；如果集合為空，則丟擲KeyError異常
new_set.pop()
# clear方法
# 從集合中刪除所有元素，變成一個空集合
new_set.clear()
我們首先講解一下Str字串，這裡僅講解最基本的內容：
# Str的三種構造方法
# Str可以由建構函式構造，可以直接採用成對的單引號，雙引號，三引號來構造
# 注意：若Str中存在單引號則不可以採用單引號構造，否則會出現字串提前結束問題，當然也可以採用跳脫字元"\"來解決
my_str1 = str("第一個字串")
my_str2 = '第二個字串'
my_str3 = "第三個字串"
my_str4 = "Let's Go!"
my_str4 = 'Let\'s Go!'
# 特殊構造
# 當我們在Str的構造前加一個r，我們就預設內部元素都是原始資料不會被跳脫
print(r"c:\test\net")
下面我們去講解一下字串格式化：
# 字串格式化：指字串在程式設計過程中，允許編碼人員通過特殊的預留位置，將相關對應的資訊整合或提取的規則字串
# 1.用 % 符號格式化字串
# 我們採用%進行佔位，常用的包含有%c字元，%s字串，%d整數，%f浮點數
# 我們首先採用%佔位，在字串末尾採用%+元組的形式進行資料輸入，最後產生對應的資料結果
name='Lily'
age=18
print('我叫%s，今年%d歲'%(name,age))
# 2.format()方法格式化字串
# format()方法是通過{}和:來代替傳統%方式
# 我們採用{}進行佔位，可以採用{}，也可以採用{index}，也可以採用{name}來進行佔位
# 然後我們採用format(資料)進行資料輸出，最後產生對應的資料結果
information=['胡桃',18]
'我叫{},今年{}歲'.format('胡桃',18)
'我叫{1},今年{0}歲'.format(18,'胡桃')
'我叫{},今年{}歲'.format(*information)
'我叫{name},今年{age}歲'.format(name='胡桃',age=18)
然後我們去介紹Str字串的一些常用方法：
# 字串擷取
# 字串擷取採用[]或者切片方法
my_str[0]
my_str[0:5:2]
# len,max,min方法
# 分別獲取長度，最大值，最小值（以Unicode碼為校驗值）
len(s) #字串長度
max(s) #最大字元
min(s) #最小字元：本處為空格
# ord，chr方法
# 進行Unicode和字元之間的轉換
ord('M') #獲取該字元的Unicode碼 77
chr(77) #把編碼轉換為對應的字元 'M'
# center()、ljust()、rjust()
# 意義：將字串填充至合適長度，並以中間/左側/右側對齊
# 格式：center(width, fillchar=’ ')
# width:指定寬度
# fillchar:填充的字元，預設為空格
'胡桃'.center(10)
'胡桃'.center(12，"❤")
# lower()、upper()
# 意義：將字串所有字元轉化為小寫字元/大寫字元，並返回新字串
new_str1 = old_str1.lower()
new_str2 = old_str2.upper()
# capitalize()、title()、swapcase()
# capitalize():將整個字串首字母轉換為大寫形式，其他字母轉換為小寫形式,返回新字串
# title():將每個單詞的首字母轉換為大寫形式，其他部分的字母轉換為小寫形式,返回新字串
# swapcase():將大小寫互換，返回新字串
new_str1 = old_str1.capitalize()
new_str2 = old_str2.title()
new_str3 = old_str3.swapcase()
# islower()、isupper()、isdigit()
# islower()：測試字串是否為全小寫,返回True或False
# isupper()：測試字串是否為全大寫,返回True或False
# isdigit()：測試字串是否為全數位,返回True或False
res1 = old_str1.islower()
res2 = old_str2.isupper()
res3 = old_str3.isdigit()
# find()、rfind()
# 格式：S.find(sub[, start[, end]])
# 意義：從左側/右側開始尋找第一個對應的字串，從start開始，到end前面結束，尋找sub字串，預設整個字串，如果沒有找到則返回-1
res_index = =str1.find("abc")
res_index = =str1.rfind("abc",-5,-1)
# index()、rindex()
# 格式：S.index(sub[, start[, end]])
# 意義：同find完全一樣，但是找不到時會直接丟擲異常
res_index = =str1.index("abc")
res_index = =str1.rindex("abc",-5,-1)
# count()
# 格式:S.count(sub[, start[, end]])
# 意義；在字串S中，查詢並返回[start,end)範圍內子串sub出現的次數
res_count = str1.count("ab")
# split()，rsplit()
# 意義：以指定字元為分隔符，從左往右/從右往左將字串分割開來，並將分割後的結果組成列表返回
# 如果不指定分隔符，實際上表示以任何空白字元（包括連續出現的）作為分隔符,可以新增第二引數指定劃分的最大次數
new_str = "i am apple"
new_list = new_str.split(" ")
# join()
# 意義：join()方法可用來連線序列（list或tuple）中的元素，並在兩個元素之間插入指定字元，返回一個字串
old_str = 'i am apple'
my_list = s.split()
new_str = " ".join(my_list) # 建立一個空字元進行原字串的拼接
# replace()
# 格式：replace(old,new,count=-1)
# 意義：查詢字串中old子串並用new子串來替換
# 引數count預設值為-1，表示替換所有匹配項，否則(count為其他值時）最多替換count次；返回替換後的新字串（原字串不變）
old_str = "hutao zhongli hutao hutao zhongli"
new_str = old_str.replace("hutao","keqing",2)
# strip()
# 意義：去除字串兩側的空白字元(空格、回車、製表符等）或指定字元，並返回新字串
old_str = " i love you "
new_str = old_str.strip()
最後我們介紹一下正規表示式：
# 正規表示式：正規表示式(Regular Expression)是一種文字模式，包括普通字元（例如，a 到 z 之間的字母）和特殊字元（稱為"元字元"），可以用來描述和匹配字串的特定模式
# 在模式串中常常有特殊字元，為了書寫方便，在字串前加r字首，不對其進行跳脫
# 「.」：表示任意單個字元 (除換行符以外)
# 下述案例中匹配i後面跟除換行符以外的任意字元的形式：必須是兩個字元：第一個是i，第2個是換行符以外的任意字元，可以是空白符
s='hi,i am a student.my name is Hilton.'
re.findall(r'i.',s)
# 「[]」：指定字元集
# 用來指定一個字元集合，從字元集合中必須選一個，也只能選一個字元（即單個字元）
# 下述案例中匹配mit或者mwt
s='mat mit mee mwt meqwt'
re.findall(r'm[iw]t',s)
# 「^」：匹配行首，匹配每行中以^後面的字元開頭的字串
# ^ 表示一個字串的開頭，但它用在一個方括號的開頭的時候，它表示這個字元集是否定的
# 下述案例中匹配所有開頭非a的字元+it的字串
s='mat mit mee mwt meqwt'
re.findall(r'[^a]it',s)
# 「\」：反斜槓後面可以加不同的字元以表示不同的特殊意義（四對）
# \b匹配單詞頭或單詞尾；\B與\b相反，匹配非單詞頭或單詞尾
# \d匹配任何數位字元；相當於[0-9]；\D與\d相反，匹配任何非數位字元，相當於[^0-9]
# \s匹配任何空白字元，相當於[\t\n\r\f\v]；\S與\s相反，匹配任何非空白字元，相當於[^\t\n\r\f\v]
# \w匹配任何字母、數位或下畫線字元，相當於[a-zA-Z0-9_]；\W與\w相反，匹配任何非字母、數位和下畫線字元，相當於[^a-zA-Z0-9_]
我們首先需要了解一個概念：
我們需要了解可迭代物件：
對於迭代器其實也是同理：
我們只需要瞭解對應的內建函數即可：
# enumerate方法
# 格式：enumerate(iterable, start=0)
# 功能：返回下標和值的enumerate物件。
# 引數：第1個參數列示可迭代(Iterable)物件，第2個參數列示下標的開始值，預設從0開始
# 解釋：將容器的每個元素取出來，搭配一個下標
my_list = ["劉備"，"關羽","張飛"]
res = enumerate(my_list)
for i in res:
print(i," ") # 這裡輸出的是列表(0,"劉備")...
# zip方法
# 格式：zip(iter1 [,iter2 […]])
# 功能：將多個迭代器(Iterator)物件（或者可迭代(Iterable)物件）中的元素壓縮到一起，返回一個zip物件
# 解釋：將多個容器的逐個對應元素拼合在一起（我們之前在dict章節使用過將keys和values壓縮在一起）
keys = ["胡桃","鍾離","刻晴"]
values = [10,20,30]
my_dict3 = dict(zip(keys,values))
# map方法
# 格式：map(func, *iterables)
# 功能：把一個函數func依次對映到可迭代(Iterable)物件的每個元素上，返回一個map物件。
# 解釋：將每個元素傳入func函數，把結果放入map裡
my_list1 = ['1','5.6','7.8','9']
my_list2 = map(float,aa) #將每個元素變為float型別
# filter方法
# 格式：filter(函數名 or None, 可迭代物件)
# 功能：把一個帶有一個引數的函數function作用到一個可迭代(Iterable)物件上，返回一個filter物件。
# 通俗：將容器中的元素用函數過濾一下
my_list1=[5,6,-9,-56,-309,206]
def func(x):
return x%2!=0
over_list=filter(func,my_list1)
這一章我們來介紹Python的函數
首先我們需要知道函數的定義方法：
def 函數名(形式引數):
函數體
我們對函數需要保證以下條件：
針對於函數的返回的定義方法如下：
# 如果一個函數的定義中沒有return語句，執行時，系統將自動在函數體的末尾插入return None語句
def 函數名(形式引數):
函數體
return 返回資料
當我們需要執行該函數時，我們只需要直接呼叫該函數並給出引數即可：
def add(x,y):
res = x + y
return res
if __name__ == '__main__':
n = 1
m = 2
res = add(n,m)
print(res)
然後我們再來講解一下函數的位置引數和關鍵字引數:
# 引數傳遞時有兩種方式：位置引數和關鍵字引數
# 我們之前所使用的就是位置引數，而關鍵字引數就是在我們呼叫時直接採用name進行賦值
def add(x,y):
res = x*2 + y
return res
if __name__ == '__main__':
n = 1
m = 2
res = add(y=m,x=n) # 結果為4，這裡是關鍵字傳參
print(res)
下面我們介紹一下函數的預設值：
# 函數的形參可以設定預設值。這種形參通常稱為預設引數
# 若呼叫時沒有為這些引數提供值：這些引數就使用預設值
# 若呼叫時有實參：則將實參的值傳遞給形參，形參定義的預設值將被忽略
def 函數名(非預設引數, 形參名=預設值, ……):
函數體
# 我們給出一個例子
def sayHello(s="Hello!",n=2,m=1): #3個都是預設引數
for i in range(1,n+1):
print(s*m)
if __name__ == '__main__':
sayHello(m=2) # 例如這裡我們只給m賦值了，那麼s就是Hello，n就是2，m是我們賦值的2，然後去執行操作
# 函數定義時，非預設引數與預設引數可以並存，但非預設引數之前不能有預設引數
# 即：非預設引數在前，預設引數在後（下述def就是錯誤範例）
def sayHello(s="Hello!",n,m): # s應該放在n和m的後面
for i in range(1,n+1):
print(s*m)
下面我們繼續介紹Python的可變長度引數：
# 在Python的函數的末尾，我們可以去新增一個可變長度引數
# 函數可以接收不定個數的引數：通過在形參前面使用識別符號「*」來實現
def all_1(*args):
print(args) #收集為一個元組
if __name__ == '__main__':
all_1("a") #1個引數
all_1("a"，True，[1,"胡桃"]) #3個引數
# 可變長度引數必須要放在最末尾值，順序如：非預設引數，預設引數，可變長度引數（下面是正確範例）
def all_3(s,*args):
print(s)
print(args)
# Python還提供了一種形參名前面加識別符號「**」的方式，用來參照一個字典
def all_4(**args):
print(args) # 收集為一個字典
if __name__ == '__main__':
all_4(x="a",y="b",z=2) #實參：關鍵字引數
# 可變長度字典引數必須要放在最末尾值，順序如：非預設引數，預設引數，可變長度引數，可變長度字典引數（下面是正確範例）
def all_6(a,*my_list,**my_dict):
print(a)
print(my_list)
print(my_dict)
我們還需要注意我們的序列和字典都可以作為引數進行函數傳參：
# 如果使用序列作為實參，則要滿足下列兩個條件之一
# 函數中形參也是序列
# 如果函數中形參是n個單變數，則在實參的序列變數名前加「*」，要求實參序列中的元素個數與單變數形參個數相同
def sum1(args): #形參：序列
print(args)
s=0
for i in args:
s+=i
return s
def sum2(args): #形參：字典
print(args)
s=0
for i in args.keys():
s+=args[i]
return s
if __name__ == '__main__':
aa=[1,2,3] #列表（序列）作實參
print(sum1(aa))
cc={'x': 1, 'y': 2, 'c': 3} #字典變數 作實參
print(sum2(cc))
# 針對於正常的單個資料引數，我們仍舊可以採用序列進行傳參，但是我們需要注意進行解體：
def sum3(x,y,z): #形參：多個單變數
return x+y+z
if __name__ == '__main__':
aa=[1,2,3] #列表
print(sum3(*aa)) #實參為列表變數，加字首"*"，自動解包，和形參個數相同 6
首先我們先來了解一下生成器函數：
生成器其實是一種特殊的迭代器
該方法不需要寫iter()和next()方法，只需要在函數中使用一個yield關鍵字以惰性方式逐一返回元素
我們來講解一下生成器的執行：
我們給出一個簡單範例：
def fib(n):
i, a, b = 0, 1, 1
while i < n:
yield a #表示：返回a的值，然後暫停在這兒，等著下一次next(繼續從這一行執行)。
a, b = b, a + b
i += 1
#沒有return L語句了,因為已經用yield返回值了
if __name__ == '__main__':
n=int(input('請輸入個數：'))
L=fib(n)
for x in L:
print(x) #1 1 2..
在Python中也存在Lambda表示式，我們也來簡單介紹一下：
我們給出Lambda表示式的書寫方法：
我們同樣給出一個簡單的例子：
f=lambda x,y : x+y #f是lamda函數的名字
f(5,10)
y=list(filter(lambda i : i%2==0, x))
y
這一章節我們來介紹python中的類和物件
首先我們先介紹一下Python中的物件：
然後我們延伸到類的概念：
在Python中，使用類來定義同一種型別的物件
類（class）是廣義的資料型別，能夠定義複雜資料的特性，包括靜態特性和動態特性
靜態特性主要指類的屬性，動態特性主要指類的方法，而我們所謂的類其實就是物件的抽象化概念
在目前Python3.0之後的版本中，類都被稱為新式類：
我們來講解一下Python中類的基本語法：
# Python中使用class保留字來定義類，類名的首字母一般要大寫
# 類的主要成員包括兩種型別，即描述狀態的資料成員（屬性）和描述操作的函數成員（方法）
class <類名>：
類屬性1
……
類屬性n
<方法定義1>
……
<方法定義n>
# 建立類的物件就需要使用到該類
class Person:
name = "胡桃"
age = 18
if __name__ = '__main__':
new_person = person()
# 類中的屬性可以直接被類中的方法呼叫，也可以使用物件直接呼叫public屬性
class Person:
name = "胡桃"
age = 18
def information_self(self):
print(self.name)
if __name__ = '__main__':
new_person = Person()
print(new_person.name)
# 類的屬性被劃分為物件屬性和類屬性
# 類屬性針對整個類都是共用的儲存，在初始化方法__init__()之外定義
# 物件屬性針對每個單獨的物件有單獨的儲存，在初始化方法__init__()之中定義
# 我們給出一個簡單範例
class Teacher:
school = "光明高中" # 這裡是類屬性，類屬性在init方法外定義且賦值
def __init__(self,nameSide,ageSide): # 類的所有方法的第一個引數都是self，但是不需要傳值
self.name = nameSide # 這裡的name和age就是物件屬性，在init方法中通過外界傳值來進行賦值
self.age = ageSide
def printInformation(self):
print("名稱：{}，年齡：{}"format(self.name,self.age))
if __name__ = '__main__':
new_person = Teacher("胡桃崽崽"，18) # 建立類物件
print(Teacher.school) # 呼叫類屬性
print(new_person.name) # 呼叫類物件屬性
new_person.age = 20 # 修改類物件屬性
new_person.printInformation() # 呼叫類物件方法
# 當然Python和Java一樣是劃分為public，protect和private的
# 沒有以任何下畫線開頭的屬性是public
# 「單下畫線」 開始的屬性是protect
# 「雙下畫線」 開始的屬性是private
class Person:
def __init__(self,n,y,w,h): #構造方法
self.name=n #定義公有屬性：姓名name和出生年份year
self.year=y
self.__weight=w #定義私有屬性：以千克為單位的體重weight、以米為單位的身高height
self.__height=h
def getWeight(self):
print(self.name,"的體重為",self.weight)
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
# 你可以直接存取共有屬性
person1.name
# 你存取不到私有屬性（下述操作會報錯）
person1.__weight
# 但是你可以通過方法獲取
person1.getWeight()
# 上面針對屬性設定的劃分對於方法來說也是有效的
class Book:
def __init__( self,name, author, price):
self.name = name
self.author = author
self.price = price
# 這裡以雙下劃線，為private
def __check_name(self):
if self.name == '' : return False
else: return True
def get_name(self):
if self.__check_name():print(self.name,self.author) #本類中，呼叫私有方法
else:print('No value')
# 然後我們來介紹一下del解構方法
# del()解構方法用於銷燬類的範例，如釋放物件佔用的資源
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
person2 = Person("胡桃寶寶",20,80,161)
person3 = person1
# 我們直接去刪除person2是可以刪除成功的，因為person2所指向的物件只有它一個人佔有
del person1
# 但當我們去刪除person1是無法將物件進行刪除的，它只會將這個物件的count--，當且僅當count=0時才會真正刪除該物件
# 靜態方法（和Java的靜態方法完全相同）
# 靜態方法的定義之前需要新增「@staticmethod」並且不需要表示存取物件的self引數
# 靜態方法只能存取屬於類的成員(類屬性、類方法），一個類的所有範例物件共用靜態方法
# 可以通過「類名.靜態方法名()」來存取，也可以通過「物件名.靜態方法名()」來存取
@staticmethod
def 靜態方法名([形參列表])
函數體
類名.靜態方法名([實參列表])
class Person:
number = 0
def __init__(self,n,y,w,h): #構造方法
self.name=n #定義公有屬性：姓名name和出生年份year
self.year=y
self.__weight=w #定義私有屬性：以千克為單位的體重weight、以米為單位的身高height
self.__height=h
number += 1
@staticmethod
def getNumber():
print(number)
if __name__ = '__main__':
person1 = Person("胡桃崽崽",18,90,160)
person2 = Person("胡桃寶寶",20,80,161)
print(Person.getNumber())
# 類方法
# 允許宣告屬於類本身的方法，即類方法
# 類方法中，一般對類本身進行操作,不能對特定範例進行操作，在類方法中存取物件範例屬性會導致錯誤
# 可以通過「類名.類方法名()」來存取，也可以通過「物件名.類方法名()」來存取
@classmethod
def 靜態方法名(cls,[形參列表])
函數體
類名.類方法名([實參列表])
class Foo:
classname = "Foo" #類屬性
def __init__(self, name): #初始化方法
self.name = name
print("init:",self.name)
def f1(self): #實體方法
print("f1():",self.name)
@staticmethod
def f2(): #靜態方法
print("static")
@classmethod
def f3(cls): #類方法：cls實際是Foo類名
print("classmethod",cls.classname) #存取的是類屬性classname。不能存取範例屬性。
#self.name
if __name__ = '__main__':
f = Foo("李四") #會呼叫 初始化方法__init__()
f.f1() #用 物件名.實體方法()
Foo.f2() #用 類名.靜態方法()
Foo.f3() #用 類名.類方法()
我們通常複用已有的程式碼來進行開發，用官方語言來講就是重用
針對Python類主要包含「繼承」和「組合」兩種重用方式
我們首先需要知道Python繼承的一些知識點：
下面我們直接去講解Python的繼承語法：
# 首先我們需要知道繼承的基本語法
class ChildClassName(父類別名1[, 父類別名2[,父類別名3, …]]):
類體或pass語句
# 我們還需要注意這些特點：
# 小括號()內為父類別，可以有多個父類別；
# 如果圓括號中沒有父類別，則表示從object類派生；
# 如果只是給出一個定義，尚沒有定義類體時，可以使用pass語句（空語句）代替類體。
# 由於我們這篇文章是基於Java基礎的，所以一些類似的定理我們下面就不再給出範例了
# 子類可以繼承父類別的非私有屬性（公有、保護）；針對私有屬性不能繼承也不能存取
# 子類如果定義了和父類別中名稱相同的屬性，父類別中的屬性在子類中將被覆蓋
# Python中同樣可以實現方法繼承和方法覆蓋
# 如果需要在子類中呼叫父類別中同名的方法，可以採用如下格式：super(子類類名, self).方法名稱(引數)
然後我們也簡單介紹一下組合：
這一章節我們簡單介紹一下Python的檔案操作
我們直接介紹Python中有關檔案的對應指令：
# 開啟一個檔案
# 格式：open(name[, mode [, buffering]])
# name：唯一必須提供的引數，即為檔案的路徑
# mode:可選引數，指定讀寫模式,包含w，w+，r，r+等
# buffering：可選引數，快取大小
# 呼叫open函數之後，將得到一個檔案物件
# Python開啟檔案常用格式
f = open(r'd:\test.txt') #r字首
f = open('d:\\test.txt') #反斜槓跳脫
f = open('d:/test.txt') #正斜槓
# file.closed屬性
# 用於判斷檔案是否關閉，若關閉為True，若未關閉為False
# file.mode屬性
# 返回讀寫型別，就是我們前面的mode引數
# file.name屬性
# 返回檔案的名稱資訊
# 我們通常採用read()方法讀取，採用write()方法寫入資料
f = open(r'd:\test.txt',r)
f.read()
f.close()
f = open(r'd:\test.txt',w)
f.write('abc')
f.close()
# 在開啟檔案open時，可以時用with語句，系統會自動關閉開啟的流
with open(r'd:\test.txt') as f:
f.read()
接下來我們需要去了解Python檔案的mode模式引數：
此外我們需要注意一些特殊組合：
我們下面再給出一些具體的檔案操作：
# write()：寫入部分資料
# w:會新建檔案或刪除原有資料，以覆蓋的方式寫入(不能讀取)
f=open('d:\\test.txt','w')
f.write('abc')
f.close()
# a:會以追加的形式寫入檔案，不刪除之前的資料(不能讀取)
f=open('d:\\test.txt','a')
f.write('abc')
f.close()
# writelines()可實現逐行寫入給定列表中的所有字串元素
f = open('d:\\test.txt','a')
a_list = ['胡桃老婆','胡桃貼貼']
f.writelines(a_list)
f.close()
# read():讀取部分資料
# 若括號中無數位，則直接讀取檔案中所有的字元
f = open('d:\\test.txt')
f.read()
# 若提供數位，則一次讀取指定數量位元組的字元
# 注意：檔案內部會有一個指標，每次讀取後該指標都會對應移動
# 例如下述先讀取3個字元，相當於指標移動三位，然後在讀取兩位，相當於讀取第4~5位，以此來達到逐漸讀取所有資料
f = open('d:\\test.txt')
f.read(3)
f.read(2)
# f.readline()可實現逐行讀取字元
# 若括號中無數位，則預設讀取一行
f = open('d:\\test.txt')
f.readline()
# 若括號中有數位，則讀取這一行中對應數量的字元（如果該數位大於這一行的字元數，則讀取這一行所有字元）
# 注意：當讀取該行的部分資料後該行尚未被讀取完畢，則下一個readline仍舊讀取該行
f = open('d:\\test.txt')
f.readline()
f.readline(2)
f.readline()
# f.readlines()可實現讀取一個檔案中的所有行，並將其作為一個列表返回
# 但是readlines會將檔案資料存放在記憶體中，若過大可能會導致計算機執行緩慢或其他異常
f = open('d:\\test.txt')
my_lsit = f.readlines()
# 因此我們可以採用其他方法來代替readlines
#方法1：常規迴圈
f = open('d:\\test.txt')
line = f.readline()
while line:
print(line,end='')
line = f.readline()
f.close()
#方法2：迭代器next
f = open('d:\\test.txt')
for line in iter(f):
print(line,end='')
f.close()
#方法3：直接迭代檔案
f = open('d:\\test.txt')
for line in f:
print(line,end='')
f.close()
首先我們先來介紹檔案指標：
我們是可以去操作這個指標的：
# seek()
# 格式：f.seek(offset[,where])
# 意義：該方法可以用來指定指標的移動，但是注意不能移動到檔案前面的位元組
# offset：移動的偏移量，如果offset取正值，則往檔案尾方向移動；如果offset取負值，則往檔案頭方向移動
# where：定義了指標位置的參照點，若where預設，其預設值為0，即檔案頭位置；取值為1，即為當前指標位置；取值為2，即為檔案末尾
f = open('d:\\test.txt','rb')
f.seek(3) #從頭前移3個位元組：返回值是目前的指標的位置3
f.read(3) #讀取3個位元組，讀取指標會後移
f.read(2) #讀取2個位元組
f.seek(-3,1) #從當前位置後退3個位元組：返回移動後指標所在的位置5
f.read() #讀取剩餘全部位元組
接下來我們去講解一下Object物件和JSON在Python中的轉換方法：
我們給出對應程式碼展示：
# dumps(obj)：把obj物件序列化為JSON字串
# dump(obj, fp)：把obj物件序列化為JSON字串，再寫入到檔案fp
# loads(s)：把JSON字串s反序列化後的物件
# load(fp)：從檔案fp中讀取JSON字串反序列化後的物件
#【例】物件JSON格式系列化範例
import json
#列表
data = [{'a': 'A', 'b': (2, 4), 'c': 3.0}]
str_json = json.dumps(data)
#輸出：'[{"a": "A", "c": 3.0, "b": [2, 4]}]'
str_json
data1 = json.loads(str_json)
#輸出：[{'a': 'A', 'c': 3.0, 'b': [2, 4]}]
data1
最後我們來介紹Python的例外處理機制
首先我們需要知道什麼是異常：
而針對異常，Python給出了一套處理機制：
下面我們來講解Python處理異常的具體程式碼：
# 下述程式碼針對輸入的價格來做判斷
# 若為數位順利執行，若非數位產生ValueError異常，進入except執行欄中,處理完異常後，繼續執行下面的語句
try:
price=float(input("請輸入價格："))
print('價格為:%5.2f' % price)
except ValueError:
print('您輸入的不是數位。')
print("接下來的程式碼...")
# 我們給出一個簡單的模板
try:
<可能出現異常的語句塊> # 自動丟擲標準異常類的物件
raise 自定義的異常類名字() # 或者 主動建立並丟擲 自定義異常類的物件
except <異常類名字name1>:
<例外處理語句塊1> #如果在try部份引發了'name1'異常，執行這部分語句塊
except <異常類名字name2> as e1： #將丟擲的異常物件傳給e1（處理語句需要其中的資訊）
<例外處理語句塊2> #如果在try部份引發了'name2'異常，執行這部分語句塊
except < (異常類名字name3, 異常類名字name4, …)> as e2: #本塊可以處理多種異常類物件
<例外處理語句塊3> #如果引發了'name3'、'name4'、…中任何一個異常，執行該語句塊
…
except:
<例外處理語句塊n> #如果引發了異常，但與上述異常都不匹配，執行此語句塊
else: #如果沒有上述所列的異常發生，執行else語句塊
<else語句塊>
finally: #無論有無異常，都需要執行的語句塊
<任何情況下都要執行的語句塊>
首先我們來簡單瞭解一下斷言：
斷言是一種除錯機制，用於驗證程式碼是否符合編碼人員的預期
斷言如果是正確的則無任何響應，但若是錯誤的就會丟擲異常
我們給出斷言的語法：
# 格式：assert expression [, arguments]
# expression：運算公式
# arguments：異常提示資訊
# 表示式正確，--> 斷言成功 --> 不採取任何措施
assert 2==1+1
# 表示式錯誤, -->斷言失敗 --> 丟擲異常資訊
assert 2==1*1，"運算結果錯誤"
這篇文章中詳細介紹了Python的基本語法和一些特徵 ，希望能為你學習第二語言帶來幫助
下面給出我學習和書寫該篇文章的一些參考文章，大家也可以去查閱：