注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

互联网产品经理的窝

梦想社:一个人为了梦想,始终没有停下自己的脚步

 
 
 

日志

 
 

《Python基础教程》学习笔记之[D5]抽象  

2012-05-09 14:49:18|  分类: python |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

第六章  抽象

1. 函数 def functionname(para):

   用于def后面的' '添加文档字符串,相当于注释#

Python代码  收藏代码
  1. >>> def fibs(num):  
  2.     'Get fibonaqi 这里的字符串用来注释,一般说明函数功能'  
  3.     result = [01]  
  4.     for i in range(num - 2):  
  5.         result.append(result[-1] + result[-2])  
  6.     return result  
  7.   
  8. >>> fibs(10)  
  9. [0112358132134]  

 

   使用help()可以查询函数的文档字符串

Python代码  收藏代码
  1. >>> help(fibs)  
  2. Help on function fibs in module __main__:  
  3.   
  4. fibs(num)  
  5.     Get fibonaqi 这里的字符串用来注释,一般说明函数功能  
  6.   
  7. >>>   

 

   return后不加值,只表示函数的结束,而没有返回值,这样可以避免应该返回序列时,意外返回None

Python代码  收藏代码
  1. >>> def test():  
  2.     print "test"  
  3.     return  #无返回值  
  4.     print "hello" #不执行  
  5.   
  6.       
  7. >>> x = test()  
  8. test  

 

2. 参数对外部变量影响

   函数内给参数赋值,不会改变外部变量的值,参数存储在局部作用域中

Python代码  收藏代码
  1. >>> def try_to_change(n):  
  2.     n = 3  
  3.   
  4.       
  5. >>> a = 4  
  6. >>> try_to_change(a)  #虽然在函数内部重新赋值,但外部不变, n和a实际上是完全不同的变量,  
  7. >>> a  
  8. 4  

 

   但是对于可改变的数据结构,如列表,参数的内部赋值会改变外部变量的值

   内部参数与外部变量指向同一个列表,所以会被修改

   若不想改变外部列表,可以传进一个副本

Python代码  收藏代码
  1. >>> def change(n):  
  2.     n[0] = 'test'  
  3.   
  4.       
  5. >>> names = ['Hello''world']  
  6. >>> change(names)  
  7. >>> names  
  8. ['test''world']  
  9. >>>       #采用普通方法进行模拟  
  10. >>> names = ['Hello''world']  
  11. >>> n = names #模拟传参  
  12. >>> n[0] = 'test' #改变列表  
  13. >>> names  
  14. ['test''world']  

 

   完整示例——存储名字,并能用名字、中间名或姓来查找联系人

   若名字为'Magus Lie Hetland'存储格式类似

   data = {

                  'first': { 'Magus': 'Magus Lie Hetland'},

                  'middle': {'Lie': 'Magus Lie Hetland'},

                  'last': {'Hetland': 'Magus Lie Hetland'}

                }

   注意insert(index,value)函数,在列表的索引位置插入值

Python代码  收藏代码
  1. >>> def init(data):  #data作为存储表,初始化  
  2.     data['first'] = {}  
  3.     data['middle'] = {}  
  4.     data['last'] = {}  
  5.   
  6. >>> def store(data, full_name): #存储,将全名存储到表中  
  7.     names = full_name.split()  #将名字按空格(即first,middle,last)分开,返回列表,如'Ma Li He'返回['Ma', 'Li', 'He']  
  8.     if len(names) == 2: names.insert(1'')#若无中间名,则插入空来表示中间名['Mr', 'Zha']返回['Mr', '', 'Zha']  
  9.     labels = 'first''middle''last'  #元组  
  10.     for label, name in zip(labels, names):  #元组与序列间也可使用zip  
  11.         people = lookup(data, label, name)  
  12.         if people:  
  13.             people.append(full_name)  
  14.         else:  
  15.             data[label][name] = [full_name] #当键不存在时,自动添加键值对,  
  16.                                                                          #但如果输出不存在键对应值,则报错  
  17.   
  18. >>> def lookup(data, label, name): #查找,根据label查找是name的中间人  
  19.     return data[label].get(name)  
  20.   
  21.               
  22. >>> MyNames = {}  
  23. >>> init(MyNames)  
  24. >>> store(MyNames, 'Magnus Lie Hetland')  
  25. >>> lookup(MyNames, 'middle''Lie')  
  26. ['Magnus Lie Hetland']  
  27. >>> store(MyNames, 'Robin Hood')  
  28. >>> store(MyNames, 'Robin Locksley')  
  29. >>> lookup(MyNames, 'first''Robin')  
  30. ['Robin Hood''Robin Locksley']  
  31. >>> store(MyNames, 'Mr. Gumby')  
  32. >>> lookup(MyNames, 'middle''')  
  33. ['Robin Hood''Robin Locksley''Mr. Gumby']  

 

   例2. 不可变的数字和可改变的参数

Python代码  收藏代码
  1. >>> def inc(x): return x + 1  
  2.   
  3. >>> foo = 10  
  4. >>> inc(foo)  
  5. 11  
  6. >>> foo #外部变量未发生变化  
  7. 10  
  8. >>> foo = inc(foo) #将foo重新赋值  
  9. >>> foo  
  10. 11  

 

   使用列表外部变量foo改变了

Python代码  收藏代码
  1. >>> def inc(x): x[0] = x[0] + 1  
  2.   
  3. >>> foo = [10]  
  4. >>> inc(foo)  
  5. >>> foo  
  6. [11]  

 

3. 关键字参数和默认值

   位置:是指根据参数的对应位置传参,如def a(a,b,c):,调用a(1,2,3),1传给a,2传给b,3传给c,这样参数位置容易记混。

   关键字参数,适用于大规模程序,清晰

Python代码  收藏代码
  1. >>> def hello(name, greeting):  
  2.     print '%s, %s!' %(greeting, name)  
  3.   
  4.       
  5. >>> hello('sun''Hello')  #位置参数  
  6. Hello, sun!  
  7. >>> hello(name = 'Sun', greeting = 'Hello')  #关键字参数  
  8. Hello, Sun!  
  9. >>> hello(greeting = 'Hello', name = 'Sun'#关键字参数,不必关心位置  
  10. Hello, Sun!  

 

   默认值

Python代码  收藏代码
  1. >>> def hello(name = 'world', greeting = 'Hello'):  
  2.     print '%s, %s!' %(greeting, name)  
  3.   
  4.       
  5. >>> hello()  
  6. Hello, world!  
  7. >>> hello('Sun')  
  8. Hello, Sun!  
  9. >>> hello(greeting = 'Hi')  
  10. Hi, world!  

 

   位置参数与关键字参数混用,将位置参数放在前面。尽量避免这么用,容易引起混乱。

Python代码  收藏代码
  1. >>> def hello(name, greeting = 'Hello', punc = '!'):  
  2.     print '%s, %s%s' %(greeting, name, punc)  
  3.   
  4.       
  5. >>> hello('Sun')  
  6. Hello, Sun!  
  7. >>> hello('Sun''Hi')  
  8. Hi, Sun!  
  9. >>> hello('Sun', punc = '..')  
  10. Hello, Sun..  
  11. >>> hello()   #因为name是必须要有,若有默认值,则可没有  
  12.   
  13. Traceback (most recent call last):  
  14.   File "<pyshell#385>", line 1in <module>  
  15.     hello()  
  16. TypeError: hello() takes at least 1 argument (0 given)  
  17. >>>   

 

4. 收集参数——在定义时使用*或**,用来收集参数,允许使用不定数量的参数

   *:收集其余的位置参数并作为元组 返回

Python代码  收藏代码
  1. >>> def print_params2(title, *params):  
  2.     print title  
  3.     print params  
  4.   
  5.       
  6. >>> print_params2('Param:'123)  
  7. Param:  
  8. (123)  #以元组形式返回  
  9. >>> print_params2('Param:'#不提供收集元素时,返回空元组  
  10. Param:  
  11. ()  
  12. >>> print_params2('Param:'1)   
  13. Param:  
  14. (1,) #只有一个元素时,仍为元组  

 

   **:收集其余的关键字参数并作为字典 返回,可与其他混用

Python代码  收藏代码
  1. >>> def print_params3(x, y, z = 3, *pospar, **keypar):  
  2.     print x, y, z  
  3.     print pospar  
  4.     print keypar  
  5.   
  6.       
  7. >>> print_params3(1,2,3,4,5,6,7, fool = 1, bar = 2)  
  8. 1 2 3  
  9. (4567)  
  10. {'fool'1'bar'2}  
  11. >>> print_params3(1,2)  
  12. 1 2 3  
  13. ()  
  14. {}  

 

5. 收集参数的翻转过程——在调用时使用*或**,将参数分配到定义的参数中,用于字典或列表分割时

   用于列表

Python代码  收藏代码
  1. >>> def add(x,y): return x + y  
  2.   
  3. >>> params = (1,2)  
  4. >>> add(*params)  
  5. 3  

 

   用于字典

Python代码  收藏代码
  1. >>> def hello(name, greeting):  
  2.     print '%s, %s!' %(greeting, name)  
  3.   
  4.       
  5. >>> params = {'name''Sir Robin''greeting''Welcome'}  
  6. >>> hello(**params)  
  7. Welcome, Sir Robin!  
  8.   
  9.    

 

   参数使用实例

Python代码  收藏代码
  1. #模拟步长大于0的range()  
  2. >>> interval(10)  
  3. start = 0 stop = 10 step =  1  
  4. [0123456789]  
  5. >>> def interval(start, stop=None, step=1):  
  6.     'Imitates range() for step > 0'  
  7.     if stop is None#若未给stop指定值  
  8.         start, stop = 0, start #多个赋值,0赋值给start,start的值赋值给stop  
  9.     result = []  
  10.     i = start  
  11.     while i < stop:  
  12.         result.append(i)  
  13.         i += step  
  14.     return result  
  15.   
  16. #  
  17. >>> def story(**kwds):  
  18.     return '%(job)s called %(name)s.' %kwds  
  19.   
  20. >>> def power(x, y ,*others):  
  21.     if others:  
  22.         print 'Received redundant parameters:',others  
  23.     return pow(x,y)  
  24.   
  25. #使用  
  26. >>> params = {'job':'language','name':'python'}  
  27. >>> print story(**params) #调用时分割字典,定义中收集  
  28. language called python.  
  29. >>> del params['job']  
  30. >>> print story(job='test', **params)  
  31.   
  32. >>> power(2,3,'test')  
  33. Received redundant parameters: test  
  34.   
  35. >>> params = (5,) * 2 #即(5,5)  
  36. >>> power(*params) #先分割,在赋给x,y  
  37. 3125  

 

6.作用域

   x = 1, 将名字x引用到值1上,类似字典

   内建函数vars()返回这个字典

Python代码  收藏代码
  1. >>> x = 1  
  2. >>> scope = vars()  
  3. >>> scope['x']  
  4. 1  
  5. >>> scope['x'] += 1 #一般情况下,vars()返回的字典不能修改  
  6. >>> x  
  7. 2  

 

   局部变量,全局变量

   函数内部访问全局变量,慎用!

Python代码  收藏代码
  1. >>> def com(para): print para + external  
  2.   
  3. >>> external = 'external'  
  4. >>> com('param ')  
  5. param external  

 

   若全局变量与局部变量名字相同,会被局部变量覆盖,可使用global()类似vars(),获得全局变量的字典

Python代码  收藏代码
  1. >>> def com(para): print para + globals()['para']  
  2.   
  3. >>> para = 'berry'  
  4. >>> com('test ')  
  5. test berry  

 

   重绑定全局变量,将变量引用到其他新值——函数内部声明全局变量

Python代码  收藏代码
  1. >>> x = 1  
  2. >>> def change_global():  
  3.     global x  
  4.     x = x + 1  
  5.   
  6.       
  7. >>> change_global()  
  8. >>> x  
  9. 2  
 

   嵌套作用域——函数中定义函数,例如闭包

   外部作用域中的变量一般不能被改变,但是用闭包,每次调用外层函数,内部函数都会被重新绑定,也即外部作用域factor每次都有一个新值

Python代码  收藏代码
  1. >>> def multiplier(factor):  
  2.     def multiplyByFactor(number):  
  3.         return number * factor  
  4.     return multiplyByFactor  #返回一个函数,这时并未调用  
  5.   
  6. >>> double = multiplier(2)  #double是一个函数  
  7. >>> double   #double是一个函数  
  8. <function multiplyByFactor at 0x0214C6F0>  
  9. >>> double(5)  #调用multiplyByFactor(number)  
  10. 10  
  11. >>> multiplier(2)(5#效果同上  
  12. 10  
 

   7. 递归——每调用一个函数,都会创建一个新的命名空间,意味着当函数调用自身时,实际上调用的是两个不同的函数

    阶乘

Python代码  收藏代码
  1. >>> def factorial(n):  
  2.     if n == 1:  
  3.         return 1  
  4.     else:  
  5.         return n * factorial(n-1)  
  6.   
  7. >>> factorial(5)  
  8. 120  

    幂

Python代码  收藏代码
  1. >>> def power(x, n):  
  2.     if n == 0:  
  3.         return 1  
  4.     else:  
  5.         return x * power(x, n - 1)  
  6.   
  7.       
  8. >>> power(2,3)  
  9. 8  

 

   递归实例——二元搜索

   前提:排好序

   若上下限相同,则那就是数字所在位置,返回;

   否则,找到两者的中间,查找数字是在左侧还是右侧,继续查找数字所在的那半部分。

Python代码  收藏代码
  1. >>> def search(sequence, number, lower = 0, upper = None):  
  2.     if upper is None: upper = len(sequence) - 1  
  3.     if lower == upper:  
  4.         assert number == sequence[upper]  
  5.         return upper  
  6.     else:  
  7.         middle = (lower + upper) // 2  
  8.         if number > sequence[middle]:  
  9.             return search(sequence, number, middle + 1, upper)  
  10.         else:  
  11.             return search(sequence, number, lower, middle)  
  12.   
  13.           
  14. >>> seq = [34678123410095]  
  15. >>> seq.sort()  
  16. >>> seq  
  17. [48346795100123]  
  18. >>> search(seq, 34)  
  19. 2  
 

总结:

元组输出格式化,直接使用键,而不需要加引号

Python代码  收藏代码
  1. >>> d = {'a':1'b':2}  
  2. >>> print '%(a)s corresponds to %(b)s.' %d #注意a有括号,无引号  
  3. 1 corresponds to 2.  
 
  评论这张
 
阅读(163)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017