一、函数的作用

（1）主要是解决同样的功能需要重复多次执行时，不需要重复写同一代码，当功能发生改变时，不用修改很多地方
（2）函数：就是对实现某一特定功能的代码块的封装
（3）作用：1.封装(将功能绑定在一个函数中，想要使用这个功能的时候，直接调用函数)

二、函数的定义

1.怎么申明函数：

格式：
def 函数名（参数列表）：
    '''函数说明'''
    函数体

（1）def ：是python中声明函数的关键字
（2）函数名：标识符，PEP8，见名知意（看到函数名，知道函数的功能）
（3）函数说明：对函数的功能和参数以及返回值进行说明
（4）()：是固定格式
（5）参数列表：(形参列表)参数名1，参数名2，参数名3
（6）参数的功能是用来接收从函数外部传到函数内部的数据
（7）函数体：实现函数功能的代码块，可能会包含一个return语句

2.初学者声明函数的步骤：

(1)确定函数的功能
(2)根据功能确定函数名
(3)确定参数：
<1>确定需不需要参数
<2>确定需要几个参数
<3>(看实现函数的功能需不需要从外面传数据到函数里面)
(4)实现函数的功能
(5)确定返回值

注意：
1.函数只有在调用的时候才会执行
2.函数调用的时候一定要保证每个形参都有值
3.一个函数可以调用多次

3.函数的调用

格式：
函数名(实参列表)

（1）函数名：调用的函数一定是已经是声明过的，想要使用什么功能就调用对应的函数
（2）实参列表：实参是用来给形参赋值的
（3）函数的调用一定要写在函数的声明后面

4.函数的调用过程

(1)用实参给形参赋值
(2)执行函数体
(3)函数体执行完成后，回到函数调用的位置

例：写一个函数，计算两个数的和

def my_sum(num1,num2):
   '''求两个数的和
   num1=2   #提供第一个数，int
   num2=1   #提供第二个数，int
   :return   #对返回值进行说明
   '''
   print(num1+num2)

```函数的调用一定要写在函数的声明后面```

my_sum(1,2)      #结果：3

练习：声明一个函数，功能是打印*********

# 调用这个函数
def print11(i):
    '''打印*'''
    print(i*10)
print11('*')

三、函数的参数

函数参数的作用：从函数的外面给函数传值

1.位置参数

传参的时候，实参按顺序给形参赋值

def func1(a,b,c):
   print(a,b,c)
func1(10,20,30)   #10 20 30

2.关键字参数

格式：
函数名（参数=值）

例：
def func1(a,b,c):
    print(a,b,c)
func1(b=20,a=10,c=30)   #10 20 30
func1(10,c=20,b=4)   #10 4 20

def func11(a,b='11',c='22',d='33'):
    print(a,b,c,d)
func11(10,d='20')   #10 11 22 20

说明：位置参数和关键字参数可以混着来,只要保证每个参数都有值就行

3.参数的默认值

（1）在python中函数声明的时候，参数可以设置默认值的,有默认值的参数，必须放在参数列表的最后
（2）调用参数有默认值的函数时，有默认值的参数可以传参也可以不传参

def  func2(a,b,c=100):
    print(a,b,c)
func2(10,20,30)     #10 20 30
func2(1,2)      #1  2 100

4.参数个数不定

（1）参数个数不确定的时候，就在声明函数的时候，形参的前面加一个*，将形参变成元祖
（2）然后调用函数之时，这个参数会将对应的实参作为元祖的元素保存起来

练习：写一个函数，求多个数的和

def my_sum(*numbers):
    print(numbers)  #(1, 2, 3, 4, 5, 6, 7)

    sum1=0   #注意：sum=0要写在函数里面
    for item in numbers:
        sum1+=item
    print(sum1)   #28
my_sum(1,2,3,4,5,6,7)

注意:
1.参数个数不定，可以是形参中的一部分是不定的
2.个数不确定的参数，要放到参数的最后

def func1(char,*num):
    print(char,num)    #a (1, 2, 3, 4)
func1('a',1,2,3,4)

注意：参数个数不定，也可以不传参，对应的参数的值就是一个空的元祖

四、函数的返回值（重点）

1.函数的返回值：

（1）就是函数返回给调用者的值
（2）就是return关键字后面的表达式的值
（3）就是函数调用表达式的值

python中每个函数都是有返回值，返回值就是return后面的值，如果函数中没有return,那么函数的返回值就是None

2.函数的调用：

（1）遇到函数调用，先回到函数调用的位置
（2）用实参给形参赋值（传参）
（3）执行函数体
（4）执行完函数体，将返回值返回给函数调用表达式
（5）回到函数调用的位置

函数的函数体只有在调用后才会执行

3.return关键字

（1）将return后面的值，返回给函数调用表达式
（2）结束函数

4.函数调用表达式：

python中每个函数调用表达式都是有值的

def func1():
    print('aa')   #结果：aa

a=func1()     #函数调用表达式
print(a,func1())   #结果：None None

def my_sum(x,y):
    return x+y
print(my_sum(10,20))  #30

练习：写一个函数，判断指定的年龄是否属于成年(返回结果)

def is_adult(age):
    if age>=18:
        return True
    else:
        return False
if is_adult(10):
    print('成年')
else:
    print('未成年')

5.函数的结束：

（1）函数体执行完成
（2）遇到return

def func2():
    print('123')
    return 10
    print('321')
print(func2())
'''
结果：
123
10
'''

练习：写一个函数，功能是求1+2+3+...+N，和不能大于10000

def my_sum():
    sum=0
    num=1
    while True:
        if sum+num>=10000:
            return sum,num-1   #python中函数可以有多个返回值，在return后面返回多个值，每个值用逗号隔开，返回一个元祖
        sum+=num
        num+=1

print(my_sum())
'''
结果：
(9870, 140)

五、作用域

1.什么是作用域？

作用域：变量可以使用的范围，就是这个变量的作用域（函数、类可以影响变量的作用域）

（1）全局变量：从声明开始，到文件结束都可以使用
（2）局部变量：在函数（类）中声明的变量是局部变量，作用域（作用范围）是从声明开始到函数（类）结束

2.全局变量

a=10 #这是个全局变量
print(a)

def func1():
    print(a)

for x in range(10):
    b = 100    # 这个变量是全局
    print(b)
    print(a)

print('===', b)

def func2():
    print(b)
func2()

3.局部变量

def func1():
    aaa=10
    print(aaa) #局部变量，作用域是函数内部
func1()
# print(aaa)  #局部变量aaa，函数外部使用会报错  (NameError)

4.global和nonlocal

（1）global：就是在函数中声明一个全局变量

格式：
global 变量名
变量名=值

abc='abc'  #全局变量
bcd='bcd'
def func4():
    abc='aaa'  ```局部变量，如果全局变量和局部变量的变量名相同，在函数中使用的是局部变量**(就近原则)**```
    print(abc)

    global bcd   #说明bcd是一个全部变量
    bcd=200
    print(bcd)

func4()
print(abc)
print(bcd)
'''
结果：
aaa
200
abc
200
'''

练习；申明一个变量，统计一个函数调用的次数

count=0
def my_func():
    global count
    count+=1
    print('===')
    print(count)
my_func()
my_func()

print('0----')
a = 10
my_func()
print(count)

（2）nonlocal:是在函数中声明函数的时候，才需要使用

def func11():
    a11=1
    print('相对外部',a11)

   ```在python中，函数里面还可以声明函数```

    def func12():
        nonlocal a11
        a11=100
        print('内部',a11)
        print('内部函数')

    func12()
    print('外部:', a_11)

func11()

六、匿名函数

（1）匿名函数：本质还是函数，以另外一种简单的方式来声明

（2）匿名函数的声明：

函数名=lambda 参数列表：返回值
--->结果就是一个函数变量
lambda：声明匿名函数的关键字

例：写一个函数，计算两个数的和

def my_sum1(x,y):
    return x+y
print(my_sum1(10,20))  #结果：30


# 匿名函数
my_sum2=lambda x,y:x+y
print(my_sum2(10,20))  #结果：30

题：求以下代码的结果

funcs=[]
for i in range(5):
    funcs.append(lambda x:x*i)      #先循环，调用的时候在赋值给i
print(funcs[2](2))     #调用funcs函数，给x传的参数是2，得出列表中的第二个元素
print(funcs[4](2))  

结果：
8
8

分析：
i=(0,1,2,3,4)
i = 0
[lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i,lambda x:x*i]

七、函数作为变量

声明一个函数就是声明一个变量，
（1）函数名可以当成变量来使用，可以打印，可以赋值，可以查看类型，
（2）可以作为函数的参数，
（3）可以作为函数的返回值

（1）函数名func1，可以当成变量使用

def func1(a):
    print(a)
    return 10

print(func1,type(func1))
'''
结果：
<function func1 at 0x0067B858> <class 'function'>
'''

（2）将函数func1赋给变量a,这个时候a就是一个函数

a = func1
b = func1(10) + 100
a('aaa')

（3）将函数func1作为列表的元素

functions = [func1, func1(10)]
functions[0]('abc')

（4）将函数作为参数

def my_sum(*numbers):
    """ numbers = (10, 20)  """
    sum1 = 0
    for item in numbers:
        sum1 += item
    return sum1

def my_mul(*numbers):
    sum1 = 1
    for item in numbers:
        sum1 *= item
    return sum1


def operation(method, *numbers):
    """
    method = my_sum
    numbers = (10,20)

    return my_sum((10, 20, 30))
    """
    a = ('1', 100, 'c')
    print(*a)
    print(*numbers)
    return method(*numbers)

# 求10和20的和
print('+++++')
result = operation(my_sum, 10, 20)
# 求10*20
result2 = operation(my_mul, 10, 20)
# 判断10是否大于20
reslut3 = operation(lambda x,y:x<y, 10, 20)
# 找出两个数中的最大值
result4 = operation(lambda x,y:x if x>y else y,10, 20)

python中三目运算符(?:)

值1 if 表达式 else 值2
---> 判断表达式是否为True,为True整个表达式的结果是'值1'，否则是'值2'

a = 10 if 10 > 20 else 20
print(result, result2, reslut3, result4)

（5）函数作为函数的返回值
例：写一个函数有一个参数要求，传入一个运算符号（+ 、 - 、 * 、< 、 >),返回符号对应的功能

• ---> 求和功能

• ---> 求差功能

def get_mathod(char):
    if char=='+':
       return lambda x,y:x+y
    elif char=='-':
        def func(x,y):
            return x-y
        return func
    elif char=='>':
        def func(x,y):
            return x>y
        return func
    elif char=='<':
        return lambda x,y:x<y
    else:
        def func(x,y):
            return None
        return func

print(get_mathod('+')(10,20))
print(get_mathod('-')(10,20))
print(get_mathod('*')(10,20))
'''
30
-10
None
'''

八、递归函数

对递归的要求：能不用就不用
因为：函数调用的过程就是压栈的过程（每调用一次函数，系统都要为其分配内存空间，用来储存函数声明变量和参数等，这个内存在函数调用结束后会自动销毁）

1.什么是递归

递归函数：在函数的函数体中调用函数本身
递归函数：理论上循环能做的事，递归都可以

这个函数就是递归函数
def func1():
    print('===')
    func1()

2.怎么写一个递归函数？

（1）找临界值（目的是跳出循环--->return）
（2）找关系：假设当前函数对应的功能已经实现，找到f(n)和f(n-1)的关系
（3）通过使用f(n-1)与前面找到的关系去实现f(n)的功能

练习：写一个递归函数，实现 1+2+3+...+n

普通函数:
def my_sum(n):
    sum1=0
    for x in range(1,n+1):
        sum1+=x
    return sum1
print(10)

递归函数:
def my_sum2(n):
    # 1.找临界值
    if n==1:
        return 1
    # 2.找关系：my_sum2(n)和my_sum2(n-1)的关系：

    # 3.使用my_sum2(n-1)去实现my_sum2(n)的功能
    return my_sum2(n-1)+n

print(my_sum2(10))   #结果：55
'''
过程：
my_sum2(5)
my_sum2(5) n = 5   return 1+2+3+4+5
my_sum2(4) n = 4   return 1+2+3+4
my_sum2(3) n = 3   return 1+2+3
my_sum2(2) n = 2   return 1+2
my_sum2(1) n = 1   return 1
'''

练习：用递归求2*4*6*...*n(n是偶数)

def my_sum3(n):
    if n%2!=0:
        print('参数有误')
        return None
    if n==2:
        return 2
    return my_sum3(n-2)*n

print(my_sum3(4))   #8

练习：用递归函数实现以下功能
n=3
@@@
@@
@

n=4
@@@@
@@@
@@
@

def pic(n):
    if n==1:
        print('@')
        return
    print('@'*n)
    return pic(n-1)

print(pic(4))

练习：用递归函数打印
n=3
@
@@
@@@

n=4
@
@@
@@@
@@@@

def pic(n):
    if n==1:
        print('@')
        return

    pic(n-1)
    print('@'*n)
print(pic(5))

梳理重点

1、函数的返回值（重点）（调用过程）
return后面的值，如果没有return就是NONE
函数调用的表达式

2.return:关键字
返回值
结束

3.函数的调用过程（完整的）：--->（重点）
（1）先回到函数声明的地方
（2）用实参给形参赋值（传参）
（3）执行函数体
（4）执行完函数体，就将返回值返回给函数调用者（函数调用表达式）

（5）回到函数调用的位置，可以继续往下执行

4.匿名函数（实质还是函数）
函数名=lambda 参数列表：返回值
函数名（实参)

5.作用域
全局变量（重点）：
局部变量
global
nonlocal

6.函数作为变量（可以把函数名作为变量名，只是函数变量存的值比较特殊，是函数的地址）

7.递归
三个步骤：1.找临界值2.找关系3.通过关系实现用f(n-1)实现f(n)的功能

image.png