Python3 的六個標準資料型別中：
- 不可變資料（3 個）：Number（數字）、String（字串）、Tuple（元組）；
- 可變資料（3 個）：List（列表）、Dictionary（字典）、Set（集合）。
列表[]
在序列中遍歷時，索引位置和對應值可以使用 enumerate() 函式同時得到：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
複製程式碼元組（）
字典 {key1 : value1, key2 : value2 }
1）不允許同一個鍵出現兩次。建立時如果同一個鍵被賦值兩次，後一個值會被記住 2）鍵必須不可變，所以可以用數字，字串或元組充當，而用列表就不行
在字典中遍歷時，關鍵字和對應的值可以使用 items() 方法同時解讀出來：
>>> knights = {'gallahad'python: 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
複製程式碼集合{}
- 集合（set）是一個無序的不重複元素序列。
可以使用大括號 { } 或者 set() 函式建立集合，注意：建立一個空集合必須用 set() 而不是 { }，因為 { } 是用來建立一個空字典。
條件語句
Python 中用 elif 代替了 else if，所以if語句的關鍵字為：if – elif – else。
注意：
1、每個條件後面要使用冒號 :，表示接下來是滿足條件後要執行的語句塊。 2、使用縮排來劃分語句塊，相同縮排數的語句在一起組成一個語句塊。 3、在Python中沒有switch – case語句。
迴圈語句
1、迴圈條件後面要使用冒號 :，表示接下來是滿足條件後要執行的語句塊。 2、使用縮排來劃分語句塊，相同縮排數的語句在一起組成一個語句塊。 3、在 Python 中沒有 do..while 迴圈。 無限迴圈語句
你可以使用 CTRL+C 來退出當前的無限迴圈。 無限迴圈在伺服器上客戶端的實時請求非常有用。
while 迴圈使用 else 語句 在 while … else 在條件語句為 false 時執行 else 的語句塊
#!/usr/bin/python3
count = 0
while count < 5:
print (count, " 小於 5")
count = count + 1
else:
print (count, " 大於或等於 5")
複製程式碼while 迴圈語句和 for 迴圈語句使用 else 的區別：
1、如果 else 語句和 while 迴圈語句一起使用，則當條件變為 False 時，則執行 else 語句。 2.如果 else 語句和 for 迴圈語句一起使用，else 語句塊只在 for 迴圈正常終止時執行！
# python 氣泡排序
def paixu(li):
max = 0
for ad in range(len(li) - 1):
for x in range(len(li) - 1 - ad):
if li[x] > li[x + 1]:
max = li[x]
li[x] = li[x + 1]
li[x + 1] = max
else:
max = li[x + 1]
print(li)
if __name__ == '__main__':
paixu([41, 23344, 9353, 5554, 44, 7557, 6434, 500, 2000])
複製程式碼#python 選擇排序
a = [1, 5, 4, 2, 2, 21, 12, 7, 0]
b = list(set(a)) # 建立新的列表，巢狀的是集合（除去冗餘元素並自動排序）
c = [] # 建立空列表，用來存放選擇排序的資料
for j in b: # 集合列表中選擇元素
for i in a: # 列表中選擇元素，
if i == j:
print(i)
c.append(i)
print(c)
複製程式碼迭代器
迭代是Python最強大的功能之一，是訪問集合元素的一種方式。 迭代器是一個可以記住遍歷的位置的物件。 迭代器物件從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。 迭代器有兩個基本的方法：iter() 和 next()。 字串，列表或元組物件都可用於建立迭代器：
>>> list=[1,2,3,4]
>>> it = iter(list) # 建立迭代器物件
>>> print (next(it)) # 輸出迭代器的下一個元素
1
>>> print (next(it))
2
>>>
複製程式碼- 迭代器物件可以使用常規for語句進行遍歷：
#!/usr/bin/python3
list=[1,2,3,4]
it = iter(list) # 建立迭代器物件
for x in it:
print (x, end=" ")#1 2 3 4
複製程式碼- 也可以使用 next() 函式：
import sys # 引入 sys 模組
list = [1, 2, 3, 4]
it = iter(list) # 建立迭代器物件
while True:
try:
print(next(it))
except StopIteration: #StopIteration 異常用於標識迭代的完成，防止出現無限迴圈的情況
sys.exit()
複製程式碼生成器
在 Python 中，使用了 yield 的函式被稱為生成器（generator）。 跟普通函式不同的是，生成器是一個返回迭代器的函式，只能用於迭代操作，更簡單點理解生成器就是一個迭代器。 在呼叫生成器執行的過程中，每次遇到 yield 時函式會暫停並儲存當前所有的執行資訊，返回 yield 的值, 並在下一次執行 next() 方法時從當前位置繼續執行。 呼叫一個生成器函式，返回的是一個迭代器物件。 例：
def get():
m = 0
n = 2
l = ['s', 1, 3]
k = {1: 1, 2: 2}
p = ('2', 's', 't')
while True:
m += 1
yield m
yield m, n, l, k, p
it = get()
print(next(it)) # m=1
print(next(it)) # m, n, l, k, p=(1, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't'))
print(next(it)) # m=2
print(next(it)) # m, n, l, k, p=(2, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't'))
print(next(it)) # m=3
print(next(it)) # m, n, l, k, p=(3, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't'))
print(type(next(it))) # <class 'tuple'>
複製程式碼- 打個比方的話，yield有點像斷點。加了yield的函式，每次執行到有yield的時候，會返回yield後面的值並且函式會暫停，直到下次呼叫或迭代終止； （這就很好的解釋了上例，在while迴圈中，計算完m的值後，就通過yield在迭代器中返回一個m的值外加一個包含當前m值的元組，然後迭代輸出，終止後繼續進行while的下次迴圈，再次返回迭代器，再次輸出....以此類推）
- yield後面可以加多個數值（可以是任意型別），但返回的值是元組型別的。
Python3 函式
- 函式是組織好的，可重複使用的，用來實現單一，或相關聯功能的程式碼段。
- 函式能提高應用的模組性，和程式碼的重複利用率。你已經知道Python提供了許多內建函式，比如print()。但你也可以自己建立函式，這被叫做使用者自定義函式。
定義一個函式
你可以定義一個由自己想要功能的函式，以下是簡單的規則：
- 函式程式碼塊以 def 關鍵詞開頭，後接函式識別符號名稱和圓括號 ()。
- 任何傳入引數和自變數必須放在圓括號中間，圓括號之間可以用於定義引數。
- 函式的第一行語句可以選擇性地使用文件字串—用於存放函式說明。
- 函式內容以冒號起始，並且縮排。
- return [表示式] 結束函式，選擇性地返回一個值給呼叫方。不帶表示式的return相當於返回 None。
語法 Python 定義函式使用 def 關鍵字，一般格式如下：
def 函式名（引數列表）:
函式體
複製程式碼可更改(mutable)與不可更改(immutable)物件
python 函式的引數傳遞：
- 不可變型別：類似 c++ 的值傳遞，如 整數、字串、元組。如fun（a），傳遞的只是a的值，沒有影響a物件本身。比如在 fun（a）內部修改 a 的值，只是修改另一個複製的物件，不會影響 a 本身。
- 可變型別：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響
python 中一切都是物件，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變物件和傳可變物件。
引數
以下是呼叫函式時可使用的正式引數型別：
- 必需引數
- 關鍵字引數
- 預設引數
- 不定長引數
著重解釋不定長引數：
你可能需要一個函式能處理比當初宣告時更多的引數。這些引數叫做不定長引數，和上述 2 種引數不同，宣告時不會命名。基本語法如下：
def functionname([formal_args,] *var_args_tuple ):
"函式_文件字串"
function_suite
return [expression]
複製程式碼加了星號 * 的引數會以元組(tuple)的形式匯入，存放所有未命名的變數引數。
# 可寫函式說明
def printinfo( arg1, *vartuple ):
"列印任何傳入的引數"
print ("輸出: ")
print (arg1)
print (vartuple)
# 呼叫printinfo 函式
printinfo( 70, 60, 50 )
輸出:
70
(60, 50)
複製程式碼還有一種就是引數帶兩個星號 **基本語法如下：
def functionname([formal_args,] **var_args_dict ):
"函式_文件字串"
function_suite
return [expression]
複製程式碼加了兩個星號 ** 的引數會以字典的形式匯入。
# 可寫函式說明
def printinfo( arg1, **vardict ):
"列印任何傳入的引數"
print ("輸出: ")
print (arg1)
print (vardict)
# 呼叫printinfo 函式
printinfo(1, a=2,b=3)
輸出:
1
{'a': 2, 'b': 3}
複製程式碼宣告函式時，引數中星號 * 可以單獨出現，例如:
def f(a,b,*,c):
return a+b+c
複製程式碼如果單獨出現星號 * 後的引數必須用關鍵字傳入。
print(f(1, 2, c=3))#正確
print(f(1, 2, 3))#錯誤
複製程式碼匿名函式
python 使用 lambda 來建立匿名函式。
所謂匿名，意即不再使用 def 語句這樣標準的形式定義一個函式。
- lambda 只是一個表示式，函式體比 def 簡單很多。
- lambda的主體是一個表示式，而不是一個程式碼塊。僅僅能在lambda表示式中封裝有限的邏輯進去。
- lambda 函式擁有自己的名稱空間，且不能訪問自己引數列表之外或全域性名稱空間裡的引數。
- 雖然lambda函式看起來只能寫一行，卻不等同於C或C++的行內函數，後者的目的是呼叫小函式時不佔用棧記憶體從而增加執行效率。
語法
lambda 函式的語法只包含一個語句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
複製程式碼例：
# 可寫函式說明
sum = lambda arg1, arg2: arg1 + arg2
# 呼叫sum函式
print ("相加後的值為 : ", sum( 10, 20 ))
print ("相加後的值為 : ", sum( 20, 20 ))
相加後的值為 : 30
相加後的值為 : 40
複製程式碼變數作用域
Python 中，程式的變數並不是在哪個位置都可以訪問的，訪問許可權決定於這個變數是在哪裡賦值的。
變數的作用域決定了在哪一部分程式可以訪問哪個特定的變數名稱。Python的作用域一共有4種，分別是：
- L （Local） 區域性作用域
- E （Enclosing） 閉包函式外的函式中
- G （Global） 全域性作用域
- B （Built-in） 內建作用域（內建函式所在模組的範圍）
以 L –> E –> G –>B 的規則查詢，即：在區域性找不到，便會去區域性外的區域性找（例如閉包），再找不到就會去全域性找，再者去內建中找。
g_count = 0 # 全域性作用域
def outer():
o_count = 1 # 閉包函式外的函式中
def inner():
i_count = 2 # 區域性作用域
複製程式碼Python 中只有模組（module），類（class）以及函式（def、lambda）才會引入新的作用域，其它的程式碼塊（如 if/elif/else/、try/except、for/while等）是不會引入新的作用域的，也就是說這些語句內定義的變數，外部也可以訪問。
global 和 nonlocal關鍵字
當內部作用域想修改外部作用域的變數時，就要用到global和nonlocal關鍵字了。
以下例項修改全域性變數 num：
num = 1
def fun1():
global num # 需要使用 global 關鍵字宣告
print(num)
num = 123
print(num)
fun1()
print(num)
1
123
123
複製程式碼如果要修改巢狀作用域（enclosing 作用域，外層非全域性作用域）中的變數則需要 nonlocal 關鍵字了，如下例項：
def outer():
num = 10
def inner():
nonlocal num # nonlocal關鍵字宣告
num = 100
print(num)
inner()
print(num)
outer()
100
100
複製程式碼