封装—定义（def的四种使用，Lamda函数，参数解包）

四种定义方式：

def f0():
    print("good")
f0()--------------------------------->good

def f1(x,y=2):
    print(x,y)
f1("good")-------------------------->good 2
f1("good",3)------------------------>good 3     #两种不同的调用方式
f1(y=4,x="xiaobin")----------------->xioabin 4

def f2(x,y=2,*z):
    print(x,y)
    for i in z:
        print(i)
f2("xiaobin",5)-------------------->xiaobin 5
f2("name","xu",3,4,5,"xiao")------->name xu
----------------------------------->3
----------------------------------->4
----------------------------------->5
----------------------------------->xiao

def f3(*z,**k):                  # *z要出现在**k的前面
    print(z)
    for i in k:
        print(i,k[i])
    print(k)
f3("aas",123,43,
    a='1',
    b='2',
    c="123")-------------------->('aas', 123, 43)     # *z储存的是一个元组
-------------------------------->a 1
-------------------------------->b 2
-------------------------------->c 123
-------------------------------->{'a': '1', 'b': '2', 'c': '123'}    # **k储存的是一个字典

注意:

默认值是在 定义过程 中在函数定义处计算的，所以

i = 5
def f(arg=i):
    print(arg)
    
i = 6
f()--------------------->5



默认值只会执行一次。这条规则在默认值为可变对象（**列表、字典以及大多数类实例**）时很重要。
比如，下面的函数会存储在后续调用中传递给它的参数:

def f(a, L=[]):
    L.append(a)
    return L

print(f(1))-------------->[1]
print(f(2))-------------->[1,2]
print(f(3))-------------->[1,2,3]

参数解包：

当参数已经在列表或元组中但需要为需要单独位置参数的函数调用解包时，会发生相反的情况。
例如，内置的 range() 函数需要单独的 start 和 stop 参数。如果它们没有直接给出，
可使用 * 运算符编写函数调用以从列表或元组中解包参数:

参数直接给出：
 list(range(3, 6))---------------------->[3, 4, 5]
 参数未转接给出：
args = [3, 6]
list(range(*args))---------------------->[3, 4, 5]


以同样的方式，字典可以使用 ** 运算符来提供关键字参数:

def parrot(voltage, state='a stiff', action='voom'):
    print("-- This parrot wouldn't", action, end=' ')
    print("if you put", voltage, "volts through it.", end=' ')
    print("E's", state, "!")

d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
parrot(**d)----->This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

Lambda 表达式:

可以用 lambda 关键字来创建一个小的匿名函数。这个函数返回两个参数的和： lambda a, b: a+b 。Lambda函数可以在需要函数对象的任何地方使用。它们在语法上限于单个表达式。从语义上来说，它们只是正常函数定义的语法糖。与嵌套函数定义一样，lambda函数可以引用包含范围的变量:

def make_incrementor(n):
     print ( lambda x: x + n )

f = make_incrementor(42)
f(0)----------------->42
f(1)----------------->43


上面的例子使用一个lambda表达式来返回一个函数。
另一个用法是传递一个小函数作为参数:
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs.sort(key=lambda pair: pair[1])               # sort() 用列表内元素的排序
pairs------>[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]