1. 循環與流程控制

(1) for

myList1 = ["A", "B", "C", "D"]

# 正序遍歷
for item in myList1:
    print(item)

# 倒序遍歷
for item in reversed(myList1):
    print(item)

myList2 = list(range(1,5))
# [1, 2, 3, 4]

# 等效于其它語言的for(i=0; i<4; i++)
for index in range(4): 
    myList2.append(myList1[index])

print(myList2)
# [1, 2, 3, 4, 'A', 'B', 'C', 'D']

# 按索引遍歷
for index in range(len(myList2)):
    print("索引", index, "對應的元素是:", myList2[index])

for循環本質上是通過不斷調用迭代器(Iterator)的next()函數來實現的：

from collections import Iterable

myList = [3, 6, 9]

for i in myList:
    print(i)

# 下面的代碼與上面的for循環等效
if isinstance(myList, Iterable):
    myIter = iter(myList)

while True:
    try:
        x = next(myIter)
        print(x)
    except StopIteration:
        break

(2) while

myList = ["A", "B", "C", "D"]

index = 0
while index < len(myList):
    print(myList[index])
    index += 1

(3) break和continue

myList = list(range(10))

# 循環到5后跳出
index = 0
while True:
    print(myList[index])
    if index==5:
        break
    index += 1

# 循環遇到偶數略過，只打印奇數
for item in myList:
    if int(item)%2==0:
        continue
    print(item)

2. 函數

# 定義一個空函數
def voidFun():
    pass

# 定義一個求和函數
def getSum(x, y):
    if not isinstance(x, (int, float)) and isinstance(y, (int, float)):
        raise TypeError("參數'x'和'y'必須為數字")
    return x + y

# 定義一個同時返回最大和最小值的函數
def getMinAndMax(x, y, z):
    return min(x, y, z), max(x, y, z)

print(voidFun())
# None

print(getSum(3, 5))
# 8

multiValue = getMinAndMax(3, 9, 6)
print(multiValue)
# 多參數返回其實是一個Tuple
# (3, 9)

minValue, maxValue = getMinAndMax(3, 9, 6)
print(minValue, maxValue)
# 3 9

默認參數示例：

def enroll(name, age, sex="male", gold=0, country="China"):
    print("name:",name,"\n",
        "age:",age,"\n",
        "sex:",sex,"\n",
        "gold:",gold,"\n",
        "country:",country)


enroll("wayne", 23)
# wayne 23 male 0 China

enroll("tina", 19, "female")
# tina 19 female 0 China

enroll("andy", 28, gold=15)
# andy 28 male 15 China

默認參數需要注意的一點是：默認值最好設置為不可變值(例如字符串或數字)，否則會帶來意料之外的狀況：

def addItemToList(myList=[]):
        myList.append("End")
        print(myList)

# 提供參數連續調用2次是正常的，因為每次是以新的參數值傳入
addItemToList([1, 2])
addItemToList([1, 2])
# [1, 2, 'End']
# [1, 2, 'End']

# 當使用默認參數連續調用2次時，第1次已經改變了默認參數指向的List
addItemToList()
addItemToList()
# ['End']
# ['End', 'End']

針對上面的例子，可以修改默認值為None：

def addItemToList(myList=None):
        if myList is None:
                myList = []
        myList.append("End")
        print(myList)

可變參數示例：

def getSum(*numbers):
        sum = 0
        for i in numbers:
                sum += i
        print(sum)
        return sum

getSum()
# 0

getSum(1, 2, 3)
# 6

myTuple = (1, 3, 5)
getSum(*myTuple)
# 9

關鍵字參數示例：

def enroll(name, age, **params):
        if "gold" in params:
                print('傳了"gold"這個參數')
        print("params:",params)

enroll("wayne", 23, gold=15, sex="male")
# 傳了"gold"這個參數
# params: {'gold': 15, 'sex': 'male'}

限制關鍵字參數必須要以key=value的形式提供參數，它的定義是以*分隔：

def enroll(name, age, *, gold, country):
        pass

# enroll("wayne", 23, 15, country="China") 未提供關鍵字將報錯

enroll("wayne", 23, gold=15, country="China")

如果函數中間存在一個可變參數，在這個可變參數后面的參數自動會被認定為限制關鍵字參數：

def enroll(name, age, *skills, gold, country):
        pass

# 未提供關鍵字"gold"將報錯
# enroll("wayne", 23, "java", "python", 15, country="China") 

enroll("wayne", 23, "java", "python", gold=15, country="China")

3. 生成器(generator)

當創建一個List或Array時，當元素個數越多，則占用的內存就越高；generator能很好的解決內存占用問題，它的特點是邊循環邊計算，在處理類似斐波拉契數列的場合非常有用。
定義generator和定義函數比較類似，python通過判斷是否含有yield關鍵字來加以區分：

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a+b
        n = n + 1

for i in fib(10):
        print(i)

4. 函數參數

python支持函數參數，示例如下:

def add(x, y):
        return x+y

def multiply(x, y):
        return x*y

def compute(x, y, fun):
        return fun(x, y)

print(compute(2, 5, add))

print(compute(3, 6, multiply))

map函數可以讓一個Iterable里面的每一個元素執行同一個函數：

def square(x):
        return x * x

myTuple = tuple(map(square, (2, 4, 6)))
# (4, 16, 36)

myList = list(map(str,[1, 3, 5]))
# ['1', '3', '5']

reduce函數把一個函數作用在一個序列上，這個函數接收兩個參數，reduce把結果繼續和序列的下一個元素做累計計算：

from functools import reduce

def multiply(x, y):
        return x*y

result = reduce(multiply, [1, 2, 3, 4])
print(result)
# 24

lambda表達式提供了一個更加簡練的函數式語法來寫匿名方法，它的調用形式是lambda argument_list: expression，argument_list是參數列表，expression是表達式，表達式中出現的參數需要在參數列表中有定義。

用法一：將lambda函數賦值給一個變量，通過這個變量間接調用該lambda函數：

add = lambda x,y:x+y

add(3,5)

用法二：將lambda函數賦值給其他函數，從而將其他函數用該lambda函數替換：

import time

# 屏蔽sleep函數
time.sleep = lambda x:None 

time.sleep(10)

print("test")

用法三：將lambda函數作為參數傳遞給其他函數。

myList = list(map(lambda x: x*x, [2, 3, 4]))

print(myList)
# [4, 9, 16]

filter函數用于過濾列表，需要實現一個過濾函數：

# 過濾出奇數
def is_odd(n):
    return n%2 == 1

myList = list(filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(myList)
# [1, 3, 5, 7, 9]

# 過濾出非空字符串
def not_empty(s):
    return s and s.strip()

myList = list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
print(myList)
# ['A', 'B', 'C']

sorted函數用于排序，它接收3個參數：列表，key函數，reverse(正向/反向)。調用sorted函數后并不更改原列表，而是返回一個排序后的可循環列表：

# 默認按升序排列，注意字符串是以ASCII碼大小來排序的
myList = ["a", "B", "c", "D"]
print(sorted(myList))
# ['B', 'D', 'a', 'c']

# 如果字符串要以"A-Z"的順序排序，可以先將字母全部轉換成大寫或小寫
myTuple = ("BOY", "apple", "Pig", "monkey")
print(sorted(myTuple, key=str.lower))
# ['apple', 'BOY', 'monkey', 'Pig']

# 按絕對值的倒序排序
myList = [15, 23, -9, 100, -36]
print(sorted(myList, key=abs, reverse=True))
# [100, -36, 23, 15, -9]