Python基礎教程第二版 6:抽象

Python基礎教程第2版 6:抽象 http://blog.chinaunix.net/uid-21142030-id-5676171.html

抽象與結構,事件流程

建立函數是組織程式的關鍵.def

使用函數改變資料結構(比如list,dict)是将程式抽象化的好方法.

函數定義中的參數是形參

函數調用中的參數是實參

函數通過參數擷取值.

函數内部作用域修改參數值不會影響外部值.

抽象的要點是隐藏更新時的煩瑣細節.

函數隻能修改參數對象本身.

一個将姓名查詢添加程式

點選(此處)折疊或打開

1. #!/usr/bin/env python
2.     #-*- coding:utf-8 -*-
3.     '''
4.     斐波那契數列:初始為0,1,清單中的一個數字是前兩個元素的和
6.     num=int(raw_input('請輸入要計算的斐波那契數列的數目:'))
7.     def fibs(num):
8.         '文檔字元串 fibs.__doc__檢視'
9.         result=[0,1]
10.         for i in range(num-2):
11.             result.append(result[-2]+result[-1])
12.         return result
13.     print fibs(num)
14.     #初始化資料庫
15.     def initdata(data):
16.         data['first']={}
17.         data['middle']={}
18.         data['last']={}
19.     storage={}
20.     initdata(storage)
21.     me='eric lei wang'
22.     you='talen tf HAO'
23.     her='mei liu'
24.     #查詢方法
25.     def lookup(database,lable,name):
26.         result=database[lable].get(name)
28.     #錄入資料庫
29.     def store(database,username):#把使用者存入資料庫中
30.         #1.分割使用者名
31.         names=username.split()
32.         lables=['first','middle','last']
33.         if len(names)==2:
34.             names.insert(1,'')
35.         for lable,name in zip(lables,names):
36.             #判斷是否已經存在
37.             people=lookup(database,lable,name)
38.             if people:
39.                 #如果清單中有值,直接添加
40.                 people.append(username)
41.             else:
42.                 #如果清單沒有值,新建立,注意,這裡生成的是清單.
43.                 database[lable][name]=[username]
44.     store(storage,me)
46.     store(storage,you)
47.     store(storage,her)
48.     print storage

關鍵字參數和預設值

位置參數與關鍵字參數是可以聯合使用的.除非完全清楚程式的功能和參數的意義,否則應該避免混合使用.

使用*收集任意多的參數,傳回數組.

使用**收集任意多的關鍵字參數,傳回字典.

修改一下上面的程式,支援多個名字同時錄入

29.     def store(database,*usernames):#把使用者存入資料庫中
31.         for username in usernames:
32.             names=username.split()
33.             lables=['first','middle','last']
34.             if len(names)==2:
35.                 names.insert(1,'')
36.             for lable,name in zip(lables,names):
37.                 #判斷是否已經存在
38.                 people=lookup(database,lable,name)
39.                 if people:
40.                     #如果清單中有值,直接添加
41.                     people.append(username)
42.                 else:
43.                     #如果清單沒有值,新建立,注意,這裡生成的是清單.
44.                     database[lable][name]=[username]
45.     store(storage,me,you)

點選(此處)折疊或打開

1. 請輸入要計算的斐波那契數列的數目:11
2.     [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
3.     {'middle': {'tf': ['talen tf HAO', 'talen tf HAO'], 'lei': ['eric lei wang', 'eric lei wang'], '': ['mei liu']}, 'last': {'liu': ['mei liu'], 'wang': ['eric lei wang', 'eric lei wang'], 'HAO': ['talen tf HAO', 'talen tf HAO']}, 'first': {'mei': ['mei liu'], 'eric': ['eric lei wang', 'eric lei wang'], 'talen': ['talen tf HAO', 'talen tf HAO']}}

1. 參數練習
2.     def story(**kwds):
3.         return 'Once upon a time,there was a %(job)s called %(name)s.' % kwds
4.     def power(x,y,*others):
5.         if others:
6.             print 'Received redundant parameters:',others
7.         return pow(x,y)
8.     def interval(start, stop=None,step=1):
9.         '列印指定範圍的數字'
10.         if stop is None:
11.             start,stop=0,start
12.         result=[]
13.         while start stop:
14.             result.append(start)
15.             start+=step
17.     print story(job='ttserver',name='workhard')
18.     print story(name='mile',job='assssfsffa')
19.     params={'job':'job1','name':'nameserver'}
20.     print story(**params)
21.     print power(2,3)
22.     print power(y=4,x=5)
23.     params=(5,)*2
24.     print power(*params)
25.     print power(3,3,'talen')
26.     print interval(10)
27.     print interval(1,5)
28.     print interval(3,12,4)
29.     print power(*interval(3,7))

1. Once upon a time,there was a ttserver called workhard. 
2.     Once upon a time,there was a assssfsffa called mile. 
3.     Once upon a time,there was a job1 called nameserver. 
4.     8
5.     625
6.     3125
7.     Received redundant parameters: ('talen',) 
8.     27
9.     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
10.     [1, 2, 3, 4] 
11.     [3, 7, 11] 
12.     Received redundant parameters: (5, 6) 
13.     81

嵌套函數傳回内嵌套在内的函數是帶着傳回的函數的環境和相關局部變量一起傳回的,是以可以調用外部函數時附加變量值給傳回的函數.

def A(a):

    def B(b):

        a+b

    return B

A(a)(b)或

C=A(a)

C(b)

C是A的傳回函數即C=B

遞歸

函數調用自身的行為就是遞歸

遞歸必須以最小可能性為結束

2. #-*- coding:utf-8 -*-
3. def factorial(n):
4.     result=n
5.     for i in range(1,n):
6.         result*=i
7.         print result
8.     return result
9. print('最終結果是%s' %factorial(5))
10. def factorial2(n):
11.     if n == 1 :
12.         return 1
13.     else:
14.         return n*factorial2(n-1)
15. print('階乘的結果是%s' % factorial2(6))
16. def power(x,n):
17.     result=x
18.     if n == 0:
21.         return result * power(x,n-1)
22. print(power(3,3))

1. 5
2. 10
3. 30
4. 120
5. 最終結果是120
6. 階乘的結果是720
7. 27

二進制查找

如果不自己寫,标準庫有bisect子產品可以有效實作二進制查找.

宇宙中的粒子數約為10的87次方,隻要290個問題就能分辨它們.

1. #二進制運算
2. #元素:序列,數,位置,範圍最小值位置,最大值位置
3. def search(sequence,number,lower=0,upper=None):
4.     #先判斷是否在序列中
5.     if number in sequence:
6.         if upper is None:
7.             upper=len(sequence)-1
8.         if lower==upper:
9.             return upper
10.         else:
11.             #定義中間數,不能
12.             middle=(lower+upper)//2
13.             #判斷在哪一邊
14.             if number > sequence[middle]:
15.                 return search(sequence,number,middle+1,upper)
17.                 return search(sequence,number,lower,middle)
19.         return '沒有這個數字'
20. seq=[34,67,8,123,4,100,95]
21. seq.sort()
22. print seq
23. print('數字位于%s' % search(seq,34))
24. print('數字位于%s' % search(seq,55))
25. print('數字位于%s' % search(seq,95))

1. [4, 8, 34, 67, 95, 100, 123]
2. 數字位于2
3. 數字位于沒有這個數字
4. 數字位于4