Python Cookbook学习笔记ch7_01

第七章主讲函数相关，这里更好看

7.1 可接受任意数量的参数的函数

• 问题：如何构造一个可以接受任意多参数的函数

• 方案：使用* 参数或者**

• 接收任意多的位置参数

def avg(first, *rest):
    return (first + sum(rest)) / (1 + len(rest))

avg(1,2)

1.5

avg(1,2,3,4,4)

2.8

• 接收任意多的关键字参数，以** 开头

import html
def make_element(name, value, **attrs):
    keyvals = [' %s = "%s"' % item for item in attrs.items()]
    attr_str = ''.join(keyvals)
    element = '<{name} {attrs}> {value}</{name}>'.format(name=name,attrs=attr_str,value=html.escape(value))
    return element

make_element('item','Albatross',size='large',quantity=6)

'<item  size = "large" quantity = "6"> Albatross</item>'

make_element('p','<spam>')

'<p > &lt;spam&gt;</p>'

• 如果想要某个函数同时可以接收任意多位置参数和关键字参数，可以同时使用* 和 **

def anyargs(*args, **kwargs):
    print(args, kwargs)

anyargs(1,2,3,key1=10,key2=20)

(1, 2, 3) {'key1': 10, 'key2': 20}

• 一个 * 参数只能出现在函数定义中最后一个位置参数后面，而 * 参数只能出现在最后一个参数。在 参数后面仍然可以定义其它参数.
• 下述方式就是所谓的强制关键字参数

def fa(x, *args, y):
    print('x = {0}, args = {1}, y = {2}'.format(x,args,y) )

fa(1,2,3,4,y=10)

x = 1, args = (2, 3, 4), y = 10

def fb(x, *args, y, **keargs):
    pass

7.2只接受关键字参数的函数

• 问题：希望函数的某些参数强制使用关键字参数
• 方案：将强制关键字参数放到某个 * 参数或者 单个 * 后面

def recv(maxsize, *, block):
    print('maxsize is %d, block = %s'%(maxsize,block))

recv(10,block='WD')

maxsize is 10, block = WD

• 还可以在接收任意多位置参数时指定关键字参数

def mininum(* args,clip=None):
    m = min(args)
    if clip is not None:
        m = clip if clip < m else m
    return m

mininum(13,7,12,3,4)

3

mininum(13,7,3,4,clip=4)

3

7.3给函数参数增加元信息

• 问题：如何使其它人在使用你自己编写的程序时，清楚的直到该函数的功能
• 方案：使用函数注解
• 注意：可以使用任意类型的对象给函数添加注解（数字，字符串，对象实例），但是使用类和字符串更好

def add(x:int, y:int) -> int:
    return x+y

help(add)

Help on function add in module __main__:

add(x:int, y:int) -> int

• 函数注解只存在于函数的__annotation__属性中

add.__annotations__

{'x': int, 'y': int, 'return': int}

7.4返回多个值的函数

• 问题：构造一个可以返回多个值的函数
• 方案：直接return 一个元祖即可

def myfunc():
    return 1, 2, 3

myfunc()

(1, 2, 3)

a,b,c = myfunc()
a

1

• 之所以 看上去 可以返回多个值，实际上还是返回一个值，因为元祖既可以使用圆括号（）创建，也可以使用逗号分隔创建

t = 1,2,3
t

(1, 2, 3)

type(t)

tuple

t = (1,2,3)

t

(1, 2, 3)

type(t)

tuple

7.5定义有默认参数的函数

• 问题：定义一个函数，有一个或者镀铬参数是可选的有默认值的
• 方案：直接在函数定义中给参数指定一个默认值即可，并且放到参数列表的最后

def f(a,b=10):
    Max = a if a>b else b
    return Max

f(3)

10

f(3,19)

19

• 如果默认参数是一个可以修改的容器（列表，字典，集合），可以使用None作为默认参数

def spam(a,b=None):
    if b == None:
        b = []
    pass

• 如果并不想提供一个默认值，仅仅想测试一下某个默认参数是否传递进来，可以使用如下方法：

_no_value = object()
def spam(a,b=_no_value):
    if b is _no_value:
        print('No b value suppied')
    else:
        print('b is supplied')
spam(1)

No b value suppied

spam(1,2)

b is supplied

spam(1,None)

b is supplied

• 默认参数的值只在函数定义的时候赋值一次

x = 100
def ff(a,b=x):
    print(a,b)

ff(10)

10 100

ff(10,200)

10 200

x = 23
ff(10)

10 100

• 另外，默认值应该是不可变对象，None,True,False,数字，字符串等

def f(a,b=[]):
    pass
# 是错误的

7.6 定义匿名或者内联函数

• 问题：你想为 sort() 操作创建一个很短的回调函数，但又不想用 def 去写一个单行函数，而是希望通过某个快捷方式以内联方式来创建这个函数
• 方案：lambda表达式

add = lambda x,y:x+y
add(2,3)

5

add('hello',' world')

'hello world'

names = ['David Beazley', 'Brian Jones','Raymond Hettinger', 'Ned Batchelder']
sorted(names,key=lambda name:name.split()[-1].lower())

['Ned Batchelder', 'David Beazley', 'Raymond Hettinger', 'Brian Jones']