知识回顾

1.函数的声明

def 函数名(参数1：类型， 参数2：类型):
    函数说明文档
    函数体

补充：参数列表中，可以通过‘参数名：类型名’指定参数的类型，也可以通过设置默认值来说明参数的类型
说明类型的好处：a.传什么类型的值一目了然
b.实现函数体的时候，可以有相关提示

声明函数的时候不会执行函数

2.函数的调用

函数名(实参列表)

调用过程：
第一步：回到函数声明的位置
第二步：用实参给形参赋值 --> 传参(保证每个参数都要有值)
第三步：执行函数体
第四步：确定返回值 --> 将函数调用表达式设置为返回值
第五步：回到函数调用的位置，接着往后执行

3.函数的参数

位置参数
关键字参数

参数的默认值 ——> 有默认值的参数要放在没有默认值的参数后面

不定长参数

4.返回值

python中所有函数都有返回值。
如果遇到return，函数的返回值就是return后面的值；
没有遇到return就是None

返回值就是函数调用表达式的值

调用函数的目的：a.执行函数体 b.获取返回值

return的作用:a.返回返回值 b.结束函数(函数中遇到return就结束)



def func2(a=0, b=0):
    print(a + b)


def func1(a, b) -> int:
    """
    求两个数的和
    :param a: 数字，整型
    :param b: 数字，整型
    :return: 和
    """
    return a + b


func1(1, 2)
func2(1, 2)


def func3(a, b) -> list:
    return [a, b]


re = func3(10, 20)
re.append(30)
print(re)

补充：不定长参数（面试题）
*参数名：将位置参数作为元组的元素。参数就是一个元组
**参数名：将关键字参数，一参数名为key，实参为值组合成键值对，作为字典的元素。参数是一个字典

注意：经常将*args和**kwargs组合在一起使用，但是使用的时候*要在**前面

*args, **kwargs 之间的区别



def func4(*arg):
    print(arg)


func4(1, 2, 3, 4)


def func5(**args):
    print(args)


func5(a=1, b=2, c=3, d=4)


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


func6(12, 34)
func6(a=12, b=23)
func6(10, 20, c=30, d=40)

匿名函数

1.普通函数：

def 函数名(参数列表)：
    函数体

2.匿名函数：

函数名 = lambda 参数列表：返回值

说明：
函数名 --> 变量名
lambda --> 关键字
参数列表 --> 参数名1，参数名2...
返回值 --> 相当于只有一个return语句的函数体

匿名函数的调用和普通函数一样：函数名（实参列表）,也支持位置参数、关键字参数、参数设置默认值、不定长参数

写一个匿名函数，功能是求两个数的和

sum1 = lambda num1, num2: num1 + num2

print(sum1(1, 2))

练习：求1+2+...+n的和

sum2 = lambda n: sum(range(n + 1))

print(sum2(100))

练习：读程序

funcs = []
for item in range(1, 5):
    funcs.append(lambda x: x * item)
    print(funcs)

print(funcs[0](2))
print(funcs[1](2))

变量的作用域

1.变量的作用域

变量的作用域指的是变量能够使用的范围

2.全局变量

声明在函数和类的外面的变量都是全局变量。作用域是从声明开始，到整个py文件结束

3.局部变量：

声明在函数和类中的变量都是局部变量。作用域是从声明开始到整个函数结束

4.global关键字

在函数中说明一个变量是全局变量
注意：只能在函数中使用

name = 'abc'


def func2():
    global age
    age = 18
    global name  #说明当前函数中使用的name是全局变量name
    name = 'aaa'
    print(name)


func2()
print(name)
print(age)

5.nonlocal关键字

想要在局部的局部中修改局部变量



def func3():
    abc = 100

    def func4():
        nonlocal abc
        abc = 100
        print(abc)
    func4()
    print(abc)


func3()

函数作为变量

声明函数就是声明一个类型是function的变量，函数名实质就是变量名



def func1():
    print('__')


print(type(func1))

1.变量可以给其他变量赋值

func1 = lambda x: print(x)
func2 = func1
func2(2)

声明一个变量function，类型是function

def func3():
    print('111')

用一个函数给变量a赋值，a也是一个函数

a = func3
a()
print(a)

将函数func11的返回值给b，b的值也是None

b = func3()
print(b)

2.函数作为列表的元素

a = 10
list1 = [1, a]
print(list1, list1[1] + 100)


def func22():
    print('打印1111111')
    return 10


list2 = [1, func22, func22()]
print(list2)

# list2[1]取到一个函数，通过后面加()调用函数
print(list2[1]())

# list2[2]取到的是整数10
print(list2[2] + 100)

3.将函数作为参数

a = 10


def func1(n):
    print(n)


func1(a)


def func11(n):
    n = func12
    n()


def func12():
    print("hello world")


func11(func22)

应用

列表.sort(key = None, reverse = False)
使用sort的时候，可以通过给key赋给一个函数变量，来规定列表中的元素按照什么标准来排序
这的函数变量要求

list1 = [1, 45, 8, 89]
list1.sort()
print(list1)

list2 = [
    {'name': '张三', 'age': 22, 'score': 98},
    {'name': '李四', 'age': 19, 'score': 100},
    {'name': '王五', 'age': 20, 'score': 78}
]


def get_age(item):
    return item['score']


# list2.sort(key=lambda item: item['age'])
list2.sort(key=get_age)
print(list2)

list3 = [
    ('a', 10),
    (20, 2),
    ('b', 30)
]

#
# def second(item):
#     return item[1]
#
#
# list3.sort(key=second, reverse=True)
# print(list3)

list3.sort(key=lambda item: item[1])
print(list3)

4.将函数作为返回值

# 根据运算符号，返回对应的功能
def operation(operator):
    if operator == '+':
        def func1(*args, **kwargs):
            sum1 = 0
            for item in args:
                sum1 += item
            for key in kwargs:
                sum1 += kwargs[key]
            return sum1
        return func1
    elif operator == '*':
        def func2(*args, **kwargs):
            sum1 = 1
            for item in args:
                sum1 *= item
            for key in kwargs:
                sum1 *= kwargs[key]
            return sum1
        return func2


# f1 = operation('+')
# re = f1(10, 20)
print(operation('+')(100, 200))

print(operation('*')(100, 200, a=200))

函数的调用

1.补充：python中的函数可以有多个返回值


# 求多个数的和以及平均值
def my_sum(*nums):
    sum1 = sum(nums)
    average = sum1 / len(nums)
    return sum1, average    #同时返回和、平均值


a, b = my_sum(1, 2, 3, 4, 5)
num = my_sum(1, 2, 3, 4, 5)
print(a, b)
print(num[0], num[1])

2.函数的调用过程是一个压栈的过程

每次调用函数的时候，系统都会在内存中(栈)开辟空间来存储函数执行过程中产生数据(函数中声明的变量)
当函数调用完成后，这块内存会自动销毁。

递归函数

1.什么是递归函数

递归函数：函数中调用函数本身，这样的函数就是递归函数（自己调用自己）

循环能做的事情递归都能做，但是实际上循环能解决的问题绝对不选递归

2.怎么写递归函数

第一步：确定临界值（循环结束的条件），让函数结束
第二步：找关系,假设函数的功能已经实现,找f()和f(n-1)的关系
第三步:根据关系,用f(n-1)实现f(n)的功能


# 写一个函数,实现:1 + 2 + 3 + ... + n
def my_sum(n):
    # 1.找临界值
    if n == 1:
        return 1
    # 2.找关系
    """
    my_sum(n) = 1 + 2 + 3 + ... + n
    my_sum(n-1) = 1 + 2 + 3 + ... + n-1
    my_sum(n) = my_sum(n-1) + n
    """
    # 3.用f(n - 1) 实现f(n)的功能
    return my_sum(n - 1) + n


print(my_sum(5))

用递归实现以下功能

n = 3
***
**
*

n = 4
****
***
**
*

先打印n颗星
f(n - 1)



def print_star(n):
    if n == 1:
        print('*')
        return

    print('*' * n)
    print_star(n - 1)


print_star(5)

总结：递归，能不用就不用

作业

1.写一个函数将一个指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使表自带的逆序函数)

def ni_xu(n):
    count = len(n) - 1
    while count >= 0:
        n.append(n[count])
        del n[count]
        count -= 1
    return n


list1 = [1, 2, 3, 4, 5]
print(ni_xu(list1))

结果

1.JPG

2.写一个函数，提取出字符串中所有奇数位上的字符

def char_jishu(n):
    num = len(n)
    str2 = ''
    for index in range(num):
        if index % 2 == 1:
            str2 += n[index]
    return str2



str1 = 'sd45fg5hjt15uf4kyf5656￥%&*（'
print(str1, '的奇数位：')
print(char_jishu(str1))

结果：

2.JPG

3.写一个匿名函数，判断指定的年是否是闰

year = 2018
leap_year = lambda n: (n % 4 == 0 and n % 100 != 0) or n % 400 == 0
print(year, end=' ')
if leap_year(year):
    print('是闰年')
elif not leap_year(year):
    print('不是闰年')

结果：

3.JPG

4.使用递归打印:
n = 3的时候
@
@@@
@@@@@

n = 4的时候:
@
@@@
@@@@@
@@@@@@@

5.写函数,利用递归获取斐波那契数列中的第 10 个数，并将该值返回给调用者。

def fino_ten(n):
    if n == 1 or n == 2:
        return 1
    return fino_ten(n - 2) + fino_ten(n - 1)


print('斐波那契数列第10个数：', fino_ten(10))

结果：

8.JPG

6.写一个函数，获取列表中的成绩的平均值，和最高分

def ave_max(n):
    sum1 = 0
    aver = 0
    max_num = 0
    for index in range(len(n)):
        sum1 += n[index]
        if index == 0:
            max_num = n[index]
        elif n[index] > max_num:
            max_num = n[index]
    aver = sum1 / len(n)
    return aver, max_num


list1 = [95, 85, 75, 98]
a, b = ave_max(list1)
print('平均分：', a, '最高分：', b)

结果：

4.JPG

7.写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新的列表返回给调用者

def my_func(n):
    list2 = []
    for index in range(len(n)):
        if index % 2:
            list2.append(n[index])
    return list2


list1 = [10, 20, 30, 40, 50, 60, 70]
tuple1 = (20, 10, 40, 50, 80, 60, 70)
print(list1, '奇数位索引：', end='')
print(my_func(list1))
print(tuple1, '奇数位索引：', end='')
print(my_func(tuple1))

结果：
![5.JPG](https://upload-images.jianshu.io/upload_images/14187175-a593f319b7b038f2.JPG?

6.JPG

imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

8.实现属于自己的字典update方法：用一个字典去更新另一个字典的元素(不能使用自带的update方法)
yt_update(字典1，字典2)

def my_update(dict_a, dict_b):
    for key in list(dict_b):
        dict_a[key] = dict_b[key]
    return dict_a


dict1 = {'a': 1, 'b': 2, 'c': 3}
dict2 = {'c': 3, 'a': 5, 'd': 4}
print('用', dict2)
print('去更新：', dict1)
print('新的字典：', my_update(dict1, dict2))

结果：