函式

將需要多次執行的程式碼放在一起，消除程式碼段複製貼上的重複
1. def func_name(parameter_list):
2. return value

#!/usr/bin/env python3
# coding=utf-8
import random
def getAnswer(answerNumber):
    if answerNumber == 1 :
        return 'it is certain'
    elif answerNumber == 2:
        return 'it is decidedly so'
    elif answerNumber == 3
 
:
        return 'Yes'
    elif answerNumber == 4:
        return 'Reply hazy try again'
    elif answerNumber == 5:
        return 'Ask again later'
    elif answerNumber == 6:
        return 'Concentrate and ask again'
    elif answerNumber == 7:
        return 'My reply is no'
    elif answerNumber == 8
 
:
        return 'Outlook not so good'
    elif answerNumber == 9:
        return 'Very doubtful'

print(getAnswer(random.randint(1,9)))

None值，NoneType資料型別的唯一值，表示沒有值，類似NULL
1. print()的返回值是None
2. 對於沒有return語句或不返回值的return語句的函式，python都會在末尾加上return None

>>> a = print('hello')
hello
>>> 
 
a == None
True

大多數引數是由它們在函式呼叫中的位置來識別的，比如randint(1,9)，返回[1,9]範圍的一個隨機整數

關鍵字引數，由函式呼叫時加在它們前面的關鍵字來識別的，常用於可選變元
1. print()的可選變元end–在引數末尾列印什麼，預設為換行
2. sep–在引數之間列印什麼來分隔，預設為空格

#!/usr/bin/env python3
# coding=utf-8
print('hello')
print('world')   #輸出兩行，因為print()預設換行

print('hello', end=' ')  #輸出一行，用一個空格替代了換行符
print('world')

print('cats', 'dogs', 'mice')  # 輸出cats dogs mice
print('cats', 'dogs', 'mice', sep=',') # 輸出cats,dogs,mice

區域性和全域性作用域

一個程式中只有一個全域性作用域，在程式開始時建立，程式終止時銷燬;一個函式被呼叫時，就建立了一個區域性作用域，函式呼叫返回時，屬於這個區域性作用域的變數被銷燬
1. 函式的區域性作用域：在被調函式內賦值的變元和變數
2. 全域性作用域：在所有函式之外賦值的變數
3. 全域性作用域的程式碼不能使用任何區域性變數

#!/usr/bin/env python3
# coding=utf-8
def spam():
    eggs = 10

spam()
print(eggs) # 執行將報錯NameError: name 'eggs' is not defined

1. 區域性作用域可以訪問全域性變數

#!/usr/bin/env python3
# coding=utf-8
def spam():
    print(eggs)

eggs = 10
spam()        #輸出 10
print(eggs)   #輸出 10

1. 一個函式的區域性作用域的程式碼，不能使用其他區域性作用域中的變數，一個函式中的區域性變數完全與其他函式中的區域性變數分隔開來

#!/usr/bin/env python3
# coding=utf-8
def spam():
    eggs = 99
    bacon()
    print(eggs)

def bacon():
    eggs = 0    # 這是呼叫bacon函式的區域性作用域
#呼叫spam()建立一個區域性作用域，spam()中呼叫的bacon函式建立另一個區域性作用域
spam()  # 輸出 99

1. 不同的作用域中，可以使用相同的名字命名不同的變數

#!/usr/bin/env python3
# coding=utf-8
def spam():
    eggs = 'spam local'
    print(eggs)      # prints 'spam local'

def bacon():
    eggs = 'bacon local'
    print(eggs)      # prints 'bacon local'
    spam()
    print(eggs)      # prints 'bacon local'

eggs = 'global'
bacon()
print(eggs)          # prints 'global'

這個程式中有三個相同名字的不同變數（兩個區域性，一個全域性），執行該指令碼輸出

bacon local
spam local
bacon local
global

1. global語句，在一個函式內修改全域性變數的值

#!/usr/bin/env python3
# coding=utf-8
def spam():
    global eggs  # global語句，後續使用全域性的spam，而不是在區域性作用域中建立一個
    eggs = 'spam'   # this is global

def bacon():
    eggs = 'bacon'  # this is local

def ham():
    print(eggs)    # this is global

eggs = 42  # this is global
spam()
bacon()
ham()

四條法則區分變數是區域性還是全域性：
1. 如果變數在全域性作用域中使用（所有函式之外）–全域性變數
2. 如果在一個函式中，有針對該變數的global語句 –全域性變數
3. 否則，如果該變數用於在函式中的賦值語句–區域性變數
4. 但是，如果該變數沒有用在賦值語句中–全域性變數

#!/usr/bin/env python3
# coding=utf-8
# Python看到spam()函式中有eggs的賦值語句，認為eggs是區域性變數，
# 但是在print(eggs)執行之前，區域性變數eggs並不存在
def spam():
    print(eggs)
    eggs = 'spam local'

eggs = 'gloabl'
spam()

語句print(eggs)在執行時會報錯：UnboundLocalError: local variable ‘eggs’ referenced before assignment

一個函式中，一個變數要麼總是全域性變數，要麼總是區域性變數，沒有辦法先使用名為eggs的區域性變數，稍後又在同一個函式中使用全域性eggs變數

慣例是在編寫函式時不使用全域性變數，通常不必擔心函式的程式碼會與程式的其他部分發生交叉影響

異常處理

一般程式遇到錯誤會終止，如果希望程式能檢測錯誤並處理它們–異常處理
1. 可能出錯的語句放在try子句中
2. 如果錯誤發生，程式執行就轉到接下來的except子句中進行處理

#!/usr/bin/env python3
# coding=utf-8
def spam(divedBy):
    try:
        return 42 / divedBy
    except ZeroDivisionError:
        print('Error: INvalid argument')

print(spam(2))
print(spam(0))
print(spam(1))

執行輸出

21.0
Error: INvalid argument
None
42.0

在函式呼叫的try子句中，發生的所有錯誤都會被捕捉

#!/usr/bin/env python3
# coding=utf-8
# 由呼叫者捕捉錯誤
def spam(divideBy):
    return 42 / divideBy

try:
    print(spam(2))
    print(spam(0))  # 發生除0的錯誤，直接跳到except子句
    print(spam(1))  # 發生異常在except子句處理之後，不會再回try語句塊
except ZeroDivisionError:
    print('Error: INvalid argument')

猜數字

#!/usr/bin/env python3
# coding=utf-8
# This is a guess the number game
import random
secretNumber = random.randint(1,20)
print('I am thinking of a number between 1 and 20')

# ask the player to guess 6 times
for guessesTaken in range(1,7):
    print('Take a guess')
    guessNum = int(input())   #guessNum和guessTaken都是全域性的
                              #沒有像c++那樣的for語句作用域
    if guessNum < secretNumber:
        print('Your guess is too low')
    elif guessNum > secretNumber:
        print('Your guess is too high')
    else:
        break

if guessNum == secretNumber:
    print('Good job, you guess the number in', str(guessesTaken), 'times')
else:
    print('Nope. The number I was thinking of was', str(secretNumber))

Collatz序列

對任意整數，如果是偶數，那麼對它除以2,否則計算它的三倍加一，直到該數最終等於1

#!/usr/bin/env python3
# coding=utf-8
# 讓使用者輸入一個整數，不斷呼叫該函式，直到該函式返回1

def collatz(number):
    if number % 2 == 0 :
        number = number //  2
    else:
        number = number * 3 + 1
    return number

value_in = int(input('Please input a integer value'))
while value_in != 1:
    value_in = collatz(value_in)
    print(value_in)