01.Python邏輯控制流

Python邏輯控制流

所謂邏輯控制流，就是控制程式的邏輯行為，一步一步的流向，可以使用流程圖來表現這種行為的流動。控制流一般分成正常控制流和異常控制流，正常就是一切按預期的方向發展，異常就是控制流的突變。

*基於python 3.6.2 tutorial整理

python邏輯控制

• 條件語句
• 迴圈語句
• 異常控制
• function（可重用邏輯語句的封裝）

if條件

if statement :
    pass
elif stat:
    pass
elif stat:
    pass
else:
    pass

迴圈

for i in <iterable object>:
    pass
###
while stat:
    pass
#range()方法，產生數字序列
range(from,to,step)
range(10)  >> [0,1,2,3,4,5,6,7,8,9]
range(1,5) >> [1,2,3,4]
range(1,10,2)>>[1,3,5,7,9]

異常控制

try:
    #do something dangerous
except Exception as e:
    # do something save
#<else>:
    pass
#<finally>: always execute this block
    pass

方法

• 方法定義

# via https://docs.python.org/3/tutorial/controlflow.html#more-on-defining-functions  
def functionname(args):
    pass
def func(a:str) #指定引數型別

• 方法引數

普通引數
    def func(a,b):
        pass
帶預設引數（也叫關鍵字引數），呼叫時b可不傳
    def func(a,b=10):
        pass

可變引數--------

#a、b之後的引數由c接收，多個引數則c為list物件
    def func(a,b,*c):
        pass
# c接收多個dict形式的引數，
    def func(a,b,**c):
        pass
# 可變引數應該是最後一個引數，要麼最後的是預設引數。*args 和**args共存時，**在後面
    def concat(*args, sep="/")：
# Unpacking Argument Lists
    # 1.
    list(range(3, 6))            # normal call with separate arguments
    #[3, 4, 5]
    args = [3, 6]
    list(range(*args))            # call with arguments unpacked from a list
    # 2.
    def parrot(voltage, state='a stiff', action='voom')
    #unpacking map obejct to args
    d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
    parrot(**d)
 
####################################

error example:
    def func(a=10,b):
    
    def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
        print("-- This parrot wouldn't", action, end=' ')
        print("if you put", voltage, "volts through it.")
        print("-- Lovely plumage, the", type)
        print("-- It's", state, "!")
    parrot()  # invalid :required argument missing
    parrot(voltage=5.0, 'dead')  #invalid: non-keyword argument after a keyword argument 
    parrot(voltage=5.0) # valid
    parrot(110, voltage=220)  # invalid:duplicate value for the same argument
    parrot(actor='John Cleese')  # invalid:unknown keyword argument

• 引數傳遞

python的引數是物件傳遞，如果物件是不可變的（immutable），則傳遞的是字面量，即為傳值；如果物件是可變的（mutable），則傳遞的是引用。

#for example

# mutable object => list object,immutable object str object
    def modify(li: list, s: str):
        s = "modify"
        li[0] = "modify"

    list0 = [1, 2, 3]
    str0 = "howareu"
    print(list0,str0) # [1, 2, 3] howareu
    modify(list0, str0)
    print(list0,str0) # ['modify', 2, 3] howareu

java中引數的傳遞，和python其實差不多，不可變的傳值，可變的傳地址（地址值，也是值），所以說java引數是傳值的。O'Reilly's Java in a Nutshell by David Flanagan (see Resources) puts it best: "java manipulates objects 'by reference,' but it passes object references to methods 'by value.'"這個value就是地址的value。

• 方法內變數查詢

方法內定義的變數，叫區域性變數，或者叫本地變數（local variable），其分配儲存在local symbol table中。當在方法內引用一個變數的時候，變數的查詢路徑是：local symbol table --->global symbol table--->build-in names.

所以，如果在方法內定義了一個和外部（方法外）名字一樣的變數，就會遮蔽外部變數，當然不會修改，只是遮蔽，使得方法內只能看到這個local變數。

• 變數的scope規則和namespace

namespace：a mapping from a name to object;是一種關係的對映，類比檔案的路徑，如果以一個檔案為基準，則可以通過相對路徑和絕對路徑，去定位一個唯一的檔案，這個路徑，就是一個namespace。和不同目錄下的同名檔案之間沒有關聯類似，不同namespace的的變數，也是無關的。

變數的scope，可以類比檔案目錄的層次來理解。namespace類比檔案所在目錄的名字加上檔名，scope則是這個檔案的活動區域，作用空間，可見範圍。

如在主要一個多層次的目錄下：

/tmp/---
    ---dir01/
            ---a.py # namespace: /tmp/dir01/a.py | scope：/tmp/dir01/
            ---b.py # namespace: /tmp/dir01/b.py | scope：/tmp/dir01/
    ---diir02/  
            ---a.py # namespace: /tmp/dir02/a.py | scope：/tmp/dir02/
            ---b.py # namespace: /tmp/dir02/a.py | scope：/tmp/dir02/
    ---a.py         # namespace: /tmp/a.py       | scope：/tmp/
    ---b.py         # namespace: /tmp/a.py       | scope：/tmp/

在一個目錄下，只能看到目錄裡面的檔案，這個可見範圍，可以理解成scope。越在外層，越能被更多的視野掃描到。

而改變一個變數（檔案）的scope，就是移動這個檔案，python提供了兩個statement，來修改變數的scope。

1. nonlocal <var>
2. global <var>

 * nonlocal：是把變數的作用域，繫結到外一層的scope中去，但不會是global；
 * global：則是繫結到global全域性scope中去，讓所有的人都能看到它的身影。

• lambda表示式

lambda表示式可用來定義一個匿名函式。在python中有諸多限制，使用場景在於去代替只有一句語句的 function定義。不是很推薦使用。

    func = lambda x: x + 1
    print(func(1))
    
    def make_incrementor(n):
        return lambda x: x + n
    f = make_incrementor(42)
    f(0) # 42

The end.