Python——基礎知識細節

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
複製程式碼

集合{}

1. 集合（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
複製程式碼