摘要：函數建立函數在中，規定了一種定義函數的格式，下面的舉例就是一個函數，以這個函數為例來說明定義函數的格式和調用函數的方法。返回值所謂返回值，就是函數向調用函數的地方返回的數據。

在Python中，規定了一種定義函數的格式，下面的舉例就是一個函數，以這個函數為例來說明定義函數的格式和調用函數的方法。

def add_function(a, b): #冒號必須
   c = a + b  #縮進必須
   return c

if __name__ == "__main__":
   result = add_function(2, 3)
   print result               #python3: print(result)

定義函數的格式為：

def 函數名(參數1，參數2，...，參數n)：

   函數體（語句塊）

幾點說明：

函數名的命名規則要符合Python中的命名要求。一般用小寫字母和單下劃線、數字等組合，有人習慣用aaBb的樣式，但我不推薦

def是定義函數的關鍵詞，這個簡寫來自英文單詞define

函數名后面是圓括號，括號里面，可以有參數列表，也可以沒有參數

千萬不要忘記了括號后面的冒號

函數體（語句塊），相對于def縮進，按照python習慣，縮進四個空格

Python對命名的一般要求:

文件名:全小寫,可使用下劃線

函數名:小寫，可以用下劃線風格單詞以增加可讀性。如：myfunction，my_example_function。注意：混合大小寫僅被允許用于這種風格已經占據優勢的時候，以便保持向后兼容。有的人，喜歡用這樣的命名風格：myFunction，除了第一個單詞首字母外，后面的單詞首字母大寫。這也是可以的，因為在某些語言中就習慣如此。但我不提倡，這是我非常鮮明的觀點。

函數的參數：命名方式同變量（本質上就是變量）。如果一個參數名稱和Python保留的關鍵字沖突，通常使用一個后綴下劃線會好于使用縮寫或奇怪的拼寫。

變量:變量名全部小寫，由下劃線連接各個單詞。如color = WHITE，this_is_a_variable = 1。

定義函數

>>> def add(x,y):       #為了能夠更明了顯示參數賦值特點，重寫此函數
...     print "x=",x         #分別打印參數賦值結果
...     print "y=",y
...     return x+y
... 

普通調用

>>> add(10, 3)           #x=10,y=3
x= 10
y= 3
13

還可以直接把賦值語句寫到里面，就明確了參數和對象的關系。當然，這時候順序就不重要了

>>> add(x=10, y=3)       
x= 10
y= 3
13

>>> add(y=10, x=3)
x= 3
y= 10
13

多態調用

>>> def times(x, y=2):       #y的默認值為2
    ...     print "x=",x                 #Python 3: print("x={}".format(x))，以下類似，從略。
    ...     print "y=",y
    ...     return x*y
    ... 
    >>> times(3)                #x=3,y=2
    x= 3
    y= 2
    6

    >>> times(x=3)              #同上
    x= 3
    y= 2
    6
    
>>> times(3, 4)              #x=3,y=4,y的值不再是2
x= 3
y= 4
12

>>> times("qiwsir")         #再次體現了多態特點
x= qiwsir
y= 2
"qiwsirqiwsir"

下面的若干條，是常見編寫代碼的注意事項：

別忘了冒號。一定要記住復合語句首行末尾輸入“：”（if,while,for等的第一行）

從第一行開始。要確定頂層（無嵌套）程序代碼從第一行開始。

空白行在交互模式提示符下很重要。模塊文件中符合語句內的空白行常被忽視。但是，當你在交互模式提示符下輸入代碼時，空白行則是會結束語句。

縮進要一致。避免在塊縮進中混合制表符和空格。

使用簡潔的for循環，而不是while or range.相比，for循環更易寫，運行起來也更快

要注意賦值語句中的可變對象。

不要期待在原處修改的函數會返回結果,比如list.append()，這在可修改的對象中特別注意

調用函數是，函數名后面一定要跟隨著括號，有時候括號里面就是空空的，有時候里面放參數。

不要在導入和重載中使用擴展名或路徑。

所謂返回值，就是函數向調用函數的地方返回的數據。

編寫一個斐波那契數列函數:

#!/usr/bin/env python
# coding=utf-8

def fibs(n):
   result = [0,1]
   for i in range(n-2):
       result.append(result[-2] + result[-1])
   return result

if __name__ == "__main__":
   lst = fibs(10)
   print lst

    >>> def my_fun():
    ...     return 1, 2, 3
    ... 
    >>> a = my_fun()
    >>> a
    (1, 2, 3)

對這個函數，我們還可以用這樣的方式來接收函數的返回值。

 >>> x, y, z = my_fun()
    >>> x
    1
    >>> y
    2
    >>> z
    3

#!/usr/bin/env python
# coding=utf-8

def fibs(n):
   """
   This is a Fibonacci sequence. #函數文檔
   """
   result = [0,1]
   for i in range(n-2):
       result.append(result[-2] + result[-1])
   return result

if __name__ == "__main__":
   lst = fibs(10)
   print lst

    >>> def my_fun():
    ...     """
    ...     This is my function.
    ...     """
    ...     print "I am a craft."
    ... 
    >>> my_fun.__doc__  #調用打印函數文檔
    "
    This is my function.
    "

函數參數的個數也有不確定的時候，怎么解決這個問題呢？Python用這樣的方式解決參數個數的不確定性。

def func(x, *arg): 
    print x         #Python 3請自動修改為print()的格式，下同，從略。
    result = x
    print arg       #輸出通過*arg方式得到的值
    for i in arg:
        result +=i
    return result

print func(1, 2, 3, 4, 5, 6, 7, 8, 9)    #賦給函數的參數個數不僅僅是2個

   >>> def foo(**kargs):
    ...     print kargs        #Python 3:  print(kargs)
    ...
    >>> foo(a=1,b=2,c=3)    #注意觀察這次賦值的方式和打印的結果
    {"a": 1, "c": 3, "b": 2}

>>> def add(x, y):
...     return x + y
... 
>>> add(2, 3)
5

>>> bars = (2, 3)
>>> add(*bars)
5
    
>>> bars = (2, 3, 4) #元組中元素的個數，要跟函數所要求的變量個數一致,不然如下報錯
>>> add(*bars)
Traceback (most recent call last):
 File "", line 1, in 
TypeError: add() takes exactly 2 arguments (3 given)

>>> def foo(p1, p2, p3):
...     print "p1==>",p1        #Python 3用戶修改為print()格式，下同
...     print "p2==>",p2
...     print "p3==>",p3
... 
>>> foo("python", 1, ["qiwsir","github","io"])   
p1==> python
p2==> 1
p3==> ["qiwsir", "github", "io"]

>>> foo(p3=3, p1=10, p2=222)
    p1==> 10
    p2==> 222
    p3==> 3

>>> def foo(p1, p2=22, p3=33):    #設置了兩個參數p2, p3的默認值
...     print "p1==>",p1
...     print "p2==>",p2
...     print "p3==>",p3
... 
>>> foo(11)     #p1=11，其它的參數為默認賦值
p1==> 11
p2==> 22
p3==> 33
>>> foo(11, 222)     #按照順序，p2=222, p3依舊維持原默認值
p1==> 11
p2==> 222
p3==> 33
>>> foo(11, 222, 333)  #按順序賦值
p1==> 11
p2==> 222
p3==> 333

>>> foo(11, p2=122)
p1==> 11
p2==> 122
p3==> 33

>>> foo(p2=122)     #p1沒有默認值，必須要賦值的，否則報錯
Traceback (most recent call last):
 File "", line 1, in 
TypeError: foo() takes at least 1 argument (1 given)

這種方式適合于不確定參數個數的時候，在參數args前面加一個*

>>> def foo(*args): 
...     print args
... 
>>> foo("qiwsir.github.io")
("qiwsir.github.io",)
>>> foo("qiwsir.github.io","python")
("qiwsir.github.io", "python")

這種方式跟上面的區別在于，必須接收類似arg=val形式的。

>>> def foo(**args):    
...     print args
... 

>>> foo(1,2,3)   
Traceback (most recent call last):
 File "", line 1, in 
TypeError: foo() takes exactly 0 arguments (3 given)

>>> foo(a=1,b=2,c=3)
{"a": 1, "c": 3, "b": 2}

# !/usr/bin/env python
#coding=utf-8

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

ret = add(5)
print ret

lam = lambda x : x + 3
ret = lam(5)
print ret

lam = lambda x,y : x + y
ret = lam(5,5)
print ret

8
8
10

lambda函數的使用方法：

lambda后面直接跟變量；

變量后面是冒號；

冒號后面是表達式，表達式計算結果就是本函數的返回值；

lambda函數不能包含太多的命令，包含的表達式不能超過一個，不要試圖向lambda函數中塞入太多的東西，如果需要更復雜的東西，應該定義一個普通的函數。

# !/usr/bin/env python
#coding=utf-8

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

numbers = range(9)
print numbers

ret = map(add, numbers) #只引用函數名即可
print ret

ret = map(lambda x : x + 4, numbers) #
print ret

ret = [x + 4 for x in numbers] #列表解析的方式實現
print ret

map()是Python的一個內置函數，它的基本樣式是：
map(fun,seq)

func是一個函數，seq是一個序列對象。在執行的時候，序列對象中的每個對象，按照從左到右的順序依次被取出來，塞入到func函數里面，并將func的返回值依次存到一個列表中。

reduce()是橫著逐個元素進行運算

# !/usr/bin/env python
#coding=utf-8

def add(x,y): #連續相加
    return x + y

def mul(x,y): #連續相乘
    return x * y

numbers = range(9)
print numbers

ret = reduce(add, numbers) 
print ret

ret = reduce(mul, numbers) 
print ret

[0, 1, 2, 3, 4, 5, 6, 7, 8]
36
0

# !/usr/bin/env python
#coding=utf-8

numbers = range(-5,5)
print numbers

ret = filter(lambda x : x > 0, numbers) #過濾掉x < 0的數
print ret

ret = [x for x in numbers if x > 0]
print ret

ret = filter(lambda c : c != "i", "liuguoquan") #過濾掉字符i
print ret

# !/usr/bin/env python
#coding=utf-8

"""
 求解一元二次方程
 
"""

from __future__ import division
import math

def quadratic_equation(a,b,c):
    delta = b * b - 4 * a * c
    if delta < 0:
        return False
    elif delta == 0:
        return -(b / (2 * a))
    else:
        sqrt_delat = math.sqrt(delta)
        x1 = (-b + sqrt_delat) / (2 * a)
        x2 = (-b - sqrt_delat) / (2 * a)
        return x1,x2

if __name__ == "__main__":
    print "a quadratic equation: x^2 + 2x + 1 = 0"
    coefficients = (1,2,1)
    roots = quadratic_equation(*coefficients)
    if roots:
        print "the result is: ",roots
    else:
        print "this equation has no solution"
        
a quadratic equation: x^2 + 2x + 1 = 0
the result is:  -1.0

# !/usr/bin/env python
#coding=utf-8

"""
 統計考試成績
 
"""

from __future__ import division
import math

def average_score(scores):
    """
        統計平均分
    """
    score_values = scores.values()
    sum_scores = sum(score_values)
    average = sum_scores / len(score_values)
    return average

def sorted_score(scores):
    """
        對成績從高到低排序呢
    """
    score_list = [(scores[k],k) for k in scores]  #將鍵-值互換位置 score_list是列表,里面的元素是一個元組
    sort_lst = sorted(score_list,reverse = True)
    return [(i[1],i[0]) for i in sort_lst] #將鍵-值互換位置

def max_score(scores):
    """
        成績最高的姓名和分數
    """
    lst = sorted_score(scores)
    max_score = lst[0][1]
    return [(i[0],i[1]) for i in lst if i[1] == max_score]

def min_scroe(scores):
    """
        成績最低的姓名和分數
    """
    lst = sorted_score(scores)
    min_score = lst[len(lst) - 1][1]
    return [(i[0],i[1]) for i in lst if i[1] == min_score]

if __name__ == "__main__":
    scores = {"google":98,"facebook":99,"baidu":52,"alibab":80,"yahoo":49,"android":76,"apple":99,"amazon":99}
    
    ret = average_score(scores) #平均分
    print "average is: ",ret

    ret = sorted_score(scores) #成績表
    print "list of scores is: ",ret
    
    ret = max_score(scores) #學霸們
    print "學霸是: ",ret
    
    ret = min_scroe(scores) #學渣
    print "學渣是: ",ret

average is:  81.5
list of scores is:  [("facebook", 99), ("apple", 99), ("amazon", 99), ("google", 98), ("alibab", 80), ("android", 76), ("baidu", 52), ("yahoo", 49)]
學霸是:  [("facebook", 99), ("apple", 99), ("amazon", 99)]
學渣是:  [("yahoo", 49)]

質數又稱素數，指在大于1的自然數中，除了1和此整數自身外，無法被其他自然整數整除的數（也可定義為只有1和本身兩個因數的數）

# !/usr/bin/env python
#coding=utf-8

"""
尋找質數
"""
import math

def is_prime(n):
    """
    判斷一個數是否是質數
    """
    if n <=1:
        return False
    for i in range(2,int(math.sqrt(n) + 1)):
        if n % i == 0:
            return False
        return True

if __name__ == "__main__":
    
    primes = [i for i in range(2,100) if is_prime(i)]
    print primes

[5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99]     

盡量不要使用全局變量

如果參數是可變數據類型，則在函數內不要修改它

每個函數的功能和目的要單一，不要一個函數試圖做很多事情

函數的代碼行數盡量少

函數的獨立性越強越好，不要跟其他的外部東西產生關聯