首页 > 网络 > 云计算 > 正文
Python快速学习第五天
2016-08-15       个评论      
收藏    我要投稿

第五天:抽象

1、 函数

检测函数是否可调用:callable

>>> import math

>>> y=math.sqrt

>>> callable(y)

True

>>> x=1

>>> callable(x)

False

注意:Python3.0不在支持callable,需要使用表达式hasattr(func,_call_call_)代替

创建函数:def functionname(params):

>>>def fibs(num):

... 'Get fibonaqi sequnce! '

... result=[0,1]

... for i in range(num-2):

...result.append(result[-2]+result[-1])

... return result

...

>>>fibs(10)

[0, 1,1, 2, 3, 5, 8, 13, 21, 34]

用于def后面的'Getfibonaqi sequnce! '添加文档字符串,相当于注释#,使用help()可以查询函数的文档字符串

help(fibs)

Help on function fibs in module __main__:

fibs(num)

Getfibonaqi sequnce!

...skipping...

Help on function fibs in module __main__:

fibs(num)

Getfibonaqi sequnce!

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

>>> def test():

... print 'tanggao'

... return

... print 'tanggao isgood'

...

>>> x=test()

tanggao

>>> print x

None

2、参数对外部变量影响

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

>>> def try_to_change(n):

... n=3

...

>>> t=4

>>> try_to_change(t)#虽然在函数内部重新赋值,但外部不变

>>> t

4

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

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

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

>>> def change(n):

...n[0]='tanggao'

...

>>> names=['hello','world']

>>> change(names)

>>> names

['tanggao', 'world']

>>> #采用普通方法进行模拟

...

>>> names=['hello','world']

>>> n=names

>>> n[0]='tanggao'

>>> names

['tanggao', 'world']

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

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

data = {

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

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

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

}

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

Python代码

1. >>>definit(data):#data作为存储表,初始化

2. data['first']={}

3. data['middle']={}

4. data['last']={}

5.

6. >>>defstore(data,full_name):#存储,将全名存储到表中

7. names=full_name.split()#将名字按空格(即first,middle,last)分开,返回列表,如'MaLiHe'返回['Ma','Li','He']

8. iflen(names)==2:names.insert(1,'')#若无中间名,则插入空来表示中间名['Mr','Zha']返回['Mr','','Zha']

9. labels='first','middle','last'#元组

10. forlabel,nameinzip(labels,names):#元组与序列间也可使用zip

11. people=lookup(data,label,name)

12. ifpeople:

13. people.append(full_name)

14. else:

15. data[label][name]=[full_name]#当键不存在时,自动添加键值对,

16. #但如果输出不存在键对应值,则报错

17.

18. >>>deflookup(data,label,name):#查找,根据label查找是name的中间人

19. returndata[label].get(name)

20.

21.

22. >>>MyNames={}

23. >>>init(MyNames)

24. >>>store(MyNames,'MagnusLieHetland')

25. >>>lookup(MyNames,'middle','Lie')

26. ['MagnusLieHetland']

27. >>>store(MyNames,'RobinHood')

28. >>>store(MyNames,'RobinLocksley')

29. >>>lookup(MyNames,'first','Robin')

30. ['RobinHood','RobinLocksley']

31. >>>store(MyNames,'Mr.Gumby')

32. >>>lookup(MyNames,'middle','')

33. ['RobinHood','RobinLocksley','Mr.Gumby']

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

Python代码

1. >>>definc(x):returnx+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. >>>definc(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. >>>defhello(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. >>>defhello(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. >>>defhello(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(mostrecentcalllast):

14. File"",line1,in

15. hello()

16. TypeError:hello()takesatleast1argument(0given)

17. >>>

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

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

Python代码

1. >>>defprint_params2(title,*params):

2. printtitle

3. printparams

4.

5.

6. >>>print_params2('Param:',1,2,3)

7. Param:

8. (1,2,3)#以元组形式返回

9. >>>print_params2('Param:')#不提供收集元素时,返回空元组

10. Param:

11. ()

12. >>>print_params2('Param:',1)

13. Param:

14. (1,)#只有一个元素时,仍为元组

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

Python代码

1. >>>defprint_params3(x,y,z=3,*pospar,**keypar):

2. printx,y,z

3. printpospar

4. printkeypar

5.

6.

7. >>>print_params3(1,2,3,4,5,6,7,fool=1,bar=2)

8. 123

9. (4,5,6,7)

10. {'fool':1,'bar':2}

11. >>>print_params3(1,2)

12. 123

13. ()

14. {}

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

用于列表

Python代码

1. >>>defadd(x,y):returnx+y

2.

3. >>>params=(1,2)

4. >>>add(*params)

5. 3

用于字典

Python代码

1. >>>defhello(name,greeting):

2. print'%s,%s!'%(greeting,name)

3.

4.

5. >>>params={'name':'SirRobin','greeting':'Welcome'}

6. >>>hello(**params)

7. Welcome,SirRobin!

8.

9.

参数使用实例

Python代码

1. #模拟步长大于0的range()

2. >>>interval(10)

3. start=0stop=10step=1

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

5. >>>definterval(start,stop=None,step=1):

6. 'Imitatesrange()forstep>0'

7. ifstopisNone:#若未给stop指定值

8. start,stop=0,start#多个赋值,0赋值给start,start的值赋值给stop

9. result=[]

10. i=start

11. whilei

12. result.append(i)

13. i+=step

14. returnresult

15.

16. #

17. >>>defstory(**kwds):

18. return'%(job)scalled%(name)s.'%kwds

19.

20. >>>defpower(x,y,*others):

21. ifothers:

22. print'Receivedredundantparameters:',others

23. returnpow(x,y)

24.

25. #使用

26. >>>params={'job':'language','name':'python'}

27. >>>printstory(**params)#调用时分割字典,定义中收集

28. languagecalledpython.

29. >>>delparams['job']

30. >>>printstory(job='test',**params)

31.

32. >>>power(2,3,'test')

33. Receivedredundantparameters: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. >>>defcom(para):printpara+external

2.

3. >>>external='external'

4. >>>com('param')

5. paramexternal

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

Python代码

1. >>>defcom(para):printpara+globals()['para']

2.

3. >>>para='berry'

4. >>>com('test')

5. testberry

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

Python代码

1. >>>x=1

2. >>>defchange_global():

3. globalx

4. x=x+1

5.

6.

7. >>>change_global()

8. >>>x

9. 2

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

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

Python代码

1. >>>defmultiplier(factor):

2. defmultiplyByFactor(number):

3. returnnumber*factor

4. returnmultiplyByFactor#返回一个函数,这时并未调用

5.

6. >>>double=multiplier(2)#double是一个函数

7. >>>double#double是一个函数

8.

9. >>>double(5)#调用multiplyByFactor(number)

10. 10

11. >>>multiplier(2)(5)#效果同上

12. 10

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

阶乘

Python代码

1. >>>deffactorial(n):

2. ifn==1:

3. return1

4. else:

5. returnn*factorial(n-1)

6.

7. >>>factorial(5)

8. 120

Python代码

1. >>>defpower(x,n):

2. ifn==0:

3. return1

4. else:

5. returnx*power(x,n-1)

6.

7.

8. >>>power(2,3)

9. 8

递归实例——二元搜索

前提:排好序

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

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

Python代码

1. >>>defsearch(sequence,number,lower=0,upper=None):

2. ifupperisNone:upper=len(sequence)-1

3. iflower==upper:

4. assertnumber==sequence[upper]

5. returnupper

6. else:

7. middle=(lower+upper)//2

8. ifnumber>sequence[middle]:

9. returnsearch(sequence,number,middle+1,upper)

10. else:

11. returnsearch(sequence,number,lower,middle)

12.

13.

14. >>>seq=[34,67,8,123,4,100,95]

15. >>>seq.sort()

16. >>>seq

17. [4,8,34,67,95,100,123]

18. >>>search(seq,34)

19. 2

总结:

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

Python代码

1. >>>d={'a':1,'b':2}

2. >>>print'%(a)scorrespondsto%(b)s.'%d#注意a有括号,无引号

3. 1correspondsto2.

点击复制链接 与好友分享!回本站首页
相关TAG标签 五天
上一篇:Python快速学习第四天
下一篇:【OVS2.5.0源码分析】vlan&trunk实现原理分析(1)
相关文章
图文推荐
文章
推荐
热门新闻

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训
版权所有: 红黑联盟--致力于做实用的IT技术学习网站