函数定义与使用

- 通过关键字def定义函数

- def name（args...）:

- tdo somethoing

- 返回值-return

- return只能再函数体内使用，支持返回所有的数据类型

- 有返回值的函数可以直接赋值给一个变量

- return就代表函数的结束，后续的语句不会再执行

- return是对函数执行结果的返回，也支持赋值语句

- 不确定参数=可变参数传递

- def add(*args,**kwargs):

- ......

- *args代表：将无参数的值合并成元组

- **kwargs：将有参数与默认值的赋值语句合并成字典

- 列子：add（1，3，4，name='mark',age=22）

- 1,3,4对应*args，后面的对应**kwargs

- 顺序发生变化，一定要使用赋值语句的形式进行传参

- def add(a,b=2,*args,**kwargs)-必传参数，默认参数，可变元组参数，可变字典参数

def add(a,b,c=2):
    print(a+b+c)

add(1,2)
add(1,2,3)
add(a=2,c=3,b=1)

def test_args(*args,**kwargs):
    print(args,type(args))
    print(kwargs,type(kwargs))

test_args(3,5,8,name='likk',age=90,top =186)

def test_super(*args,**kwargs):
    if len(args)>=1:
        print(args[0])
    if 'name' in kwargs:
        print(kwargs['name'])
    else:
        print('没有对应的参数')
    # print(args,len(args))
    # print(kwargs,len(kwargs))


test_super(8,90,7,age=78,name='Nill',clas='B')
a = (3,5,9)
b = {'name':'python','age':65}
test_super(a,b)  # b作为一个变量，添加到了args中
test_super(*a,**b)  # 分别指定，正确接收

def add(a,b=1,*args):
    print(a,b,args)

s = (3,4,5)
add(1,2,*s)
add(4,3,*s)
# add(a=4,b=3,*s)#会报错

def add(*args,a,b=2):
    print(a,b,args)

add(a=4,b=3,*s)

def add(a,b=2,**kwargs):
    print(a,b,kwargs)

k = {'name':'Mark','age':89}
add(2,3,**k)
add(b=6,a=3,**k)

输出：

5
6
6
(3, 5, 8) <class 'tuple'>
{'name': 'likk', 'age': 90, 'top': 186} <class 'dict'>
8
Nill
(3, 5, 9)
没有对应的参数
3
python
1 2 (3, 4, 5)
4 3 (3, 4, 5)
4 3 (3, 4, 5)
2 3 {'name': 'Mark', 'age': 89}
3 6 {'name': 'Mark', 'age': 89}

- 参数定义类型的方法

- def person(name:str,age:)int=33):

- 传参的时候不会对参数类型进行验证，只有真正在业务使用时，不符合业务规则，才会报错

def add(a:int,b:int=3):
    print(a+b)

add(2,5)
add('hello','Nill')#正常打印

def test(a:int,b:int=1,*args:int,**kwargs:str):
    print(a,b,args,kwargs)

test(3,4,5,'8','nill',name='mark')

输出：

7
helloNill
3 4 (5, '8', 'nill') {'name': 'mark'}

- 全局变量与局部变量

- 在python最上层的代码块的变量

- 全局变量可以在函数内被读取使用

global关键字，可以将全局变量在函数体内进行修改（工作中不建议修改全局变量）

name='Mark'
age = 32
def test():
    print(name)

def test1():
    name='Nill'
    print('函数体内',name)

test1()
print('函数外',name)

def test2():
    age=33
    print(age)

test2()

def test3(a):
    a=90

test3(name)
print(name)

def test4():
    global name
    global age
    name=10
    age = 19


print(name)
test4()
print(name)
print(age)

dd = {'n':10,'m':24}

def test5():
    dd['c'] = 34
    dd.pop('n')

test5()
print(dd)

输出：

函数体内 Nill
函数外 Mark
33
Mark
Mark
10
19
{'m': 24, 'c': 34}

递归函数

- 一个函数不停的将自己反复执行

- 使用递归时，一定要给予退出的方案，否则会导致内存溢出，电脑死机，避免滥用递归

count = 0

def test():
    global count
    count += 1

    if count !=5:
        print('count条件不满足，要重新执行,当前count是%s'% count)
        return test()
    else:
        print('count is %s'% count)

test()

输出：

count条件不满足，要重新执行,当前count是1
count条件不满足，要重新执行,当前count是2
count条件不满足，要重新执行,当前count是3
count条件不满足，要重新执行,当前count是4
count is 5

### 匿名函数-lambda

- 定义一个轻量化的函数（简单业务），即用即删除，很适合需要完成一项功能，但此功能只在此一处使用

- f = lambda:value 无参数

- f()

- f = lambda x,y:x*y 有参数

- f(1,2)

f = lambda:3
result = f()
print(result)

f = lambda:print(7)
f()

f1 = lambda x,y=4:x*3+y*1
print(f1(3))

f2 = lambda x,y=4:x*3>y*1
print(f2(3))

us = [{'book':'python'},{'food':'milk'},{'name':'mark'}]
users = [{'name':'python'},{'name':'milk'},{'name':'mark'}]
users.sort(key=lambda x:x['name'])
print(users)

输出：

3
7
13
True
[{'name': 'mark'}, {'name': 'milk'}, {'name': 'python'}]