一、匿名函数

1.普通函数

def 函数名(参数列表):

函数体

---

2.匿名函数

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

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

匿名函数的调用和普通函数一样：函数名(实参列表)。

代码

sum1 = lambda num1=10, num2=3: num1 + num2
print(sum1(10, 20))
print(sum1(num1=100, num2=200))
print(sum1())

sum11 = lambda *nums: sum(nums)
print(sum11(1,2,3))

# 相当于上面的匿名函数
# def sum1(num1, num2):
#     return num1 + num2

测试结果

1.PNG

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

代码

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

测试结果

2.PNG

练习2：读程序。

代码

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

"""
item:1~4
item = 1：funcs[lambda x: x*item]
item = 2：funcs[lambda x: x*item, lambda x: x*item]
item = 3：funcs[lambda x: x*item, lambda x: x*item, lambda x: x*item]
item = 4：funcs[lambda x: x*item, lambda x: x*item, lambda x: x*item, lambda x: x*item]

item = 4
"""
print(funcs[0](2))
print(funcs[1](2))

测试结果

3.PNG

---

二、变量的作用域

1.变量的作用域

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

2.全局变量

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

代码

# a是全局变量
a = 100

# x和b都是全局变量
for x in range(5):
    b = 10
    print(x)

3.局部变量

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

代码

def func1():
    # 局部变量
    aa = 100
    print(aa)


func1()
#print(aa)  # NameError: name 'aa' is not defined

测试结果

---

4.global关键字

在函数中说明一个变量是全局变量。

注意：只能在函数中使用。

代码

# 全局变量
name = 'abc'


def func2():
    global age
    age = 18

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


func2()
print(name)
print(age)

测试结果

1.PNG

---

5.nonlocal关键字

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

代码

def func3():
    abc = 100

    def func4():
        nonlocal abc
        abc = 200
        print('f4:', abc)
    func4()
    print('f3:', abc)


func3()

测试结果

2.PNG

---

三、函数作为变量

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

代码

def func1():
    print('====')


print(type(func1))

测试结果

1.PNG

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

代码

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


# 声明一个变量func11，类型是function
def func11():
    print('我是函数')


# 用一个函数给变量a赋值，a也是一个函数
a = func11
a()

# 将函数func11的返回值给b，b的值是None
b = func11()
print(b)

测试结果

2.PNG

---

2.函数作为列表的元素

代码

def func22():
    print('我是函数')
    return 10


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


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

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

测试结果

3.PNG

---

3.将函数作为参数

代码

a = 10
def func1(n):
    print(n)

func1(a)


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


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

func11(func12)

测试结果

1.PNG

---

应用：sort的使用

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

代码

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

list2=[
    {'name': '张三','age': 20,'score': 90},
    {'name': '李四','age': 28,'score': 100},
    {'name': '王五','age': 18,'score': 89},
]
# 根据成绩排序
def get_age(item):
    return item['score']

list2.sort(key=get_age)
print(list2)

list2.sort(key=lambda item:item['score'])
print(list2)


# 根据元组中的第二个元素排序
list3 = [
    ('a',20),
    (10,3),
    ('b',90)
]
def second(item):
    return item[1]
list3.sort(key=second,reverse=True)
print(list3)

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

测试结果

2.PNG

---

4.将函数作为返回值

代码

# 根据运算符，返回对应的功能
def operation(operator: str):
    if operator == '+':
        def func1(*args,**kwargs):
            """求和"""
            """
            args = (10,20)
            kwargs = {'a':2,'b':3}
            """
            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 item in kwargs:
                sum1 *= item
            return sum1
        return func2

f1 = operation('+') # f1就是有两个不定长参数，功能是求和的函数
re = f1(10,20,a=2,b=3)
print(re)

print(operation('+')(10,20,a=2,b=3))

print(operation('*')(1,2,3,4))

测试结果

3.PNG

---

四、函数的调用

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

代码

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

a,b= yh_sum(2,45,67,90,0)
print(a,b)

num = yh_sum(2,45,67,90,0)
print(num[0],num[1])

测试结果

1.PNG

---

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

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

---

五、递归函数

1.什么是递归函数

递归函数：函数中调用函数本身，这样的函数就是递归函数(自己调用自己)。
循环能做的事情递归都可以做，但是实际上循环能解决的问题绝对不选递归。

代码

def func1():
    print('===')
    func1()

func1()

---

2.怎么写递归函数

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

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

代码

def yh_sum(n):
    # 1.找临界值
    if n == 1:
        return 1

    # 2.找关系
    """
    yh_sum(n) = 1+2+3+...+ n
    yh_sum(n-1) = 1+2+3+...+ n-1
    yh_sum(n) = 1yh_sum(n-1) + n
    """
    # 3.用f(n-1)实现f(n)的功能
    return yh_sum(n-1) + n

print(yh_sum(5))

测试结果

1.PNG

练习2：用递归实现以下功能。

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)

测试结果

2.PNG

练习3：用递归实现以下功能。

n = 3
*
**
***

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

f(n-1)
再打n颗星

代码

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

print_star(5)

测试结果

3.PNG
总结：递归，能不用就不用！

---

六、作业

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

代码

def negative_sequence(list1: list):
    list2 = []
    for x in range(len(list1)):
        item = list1.pop()
        list2.append(item)
    return list2


print(negative_sequence([1, 2, 3,]))

测试结果

1.PNG

---

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

代码

def choose_odd(str1: str):
    str2 = ''
    for index in range(len(str1)):
        if index & 1:
            str2 += str1[index]
    return str2


print(choose_odd('abcdefgh'))

测试结果

2.PNG

---

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

代码

judge_year = lambda n:(n % 4 == 0 and n % 100 != 0) or (n % 400 == 0)
print(judge_year(2008))

测试结果

3.PNG

---

4.使用递归打印:

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

代码

def print_star(n:int, m=0):
    if n == 0:
        return
    print_star(n-1,m+1)
    print(' ' * m, '@' * (2*n-1))


print_star(5)

测试结果

4.PNG

---

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

代码

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


print(fibonacci_sequence(10))

测试结果

5.PNG

---

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

代码

def get_average_max(list1: list):
    average = sum(list1) / len(list1)
    max1 = max(list1)
    return average,max1


a, b = get_average_max([10,20,30,40,50])
print('average=', a, ' max=', b, sep='')

测试结果

6.PNG

---

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

代码

def odd_element(list1):
    list2 = []
    for index in range(len(list1)):
        if index & 1 == 1:
            list2.append(list1[index])
    return list2


print(odd_element([0, 1, 2, 3, 4, 5]))
print(odd_element(('a', 'b', 'c', 'd', 'e', 'f')))

测试结果

7.PNG

---

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

代码

def lyh_update(dict1, dict2: dict):
    # for key1 in dict1:
    #     dict1[key1] = dict2[key1]
    for key2 in dict2:
        dict1[key2] = dict2[key2]
    return dict1


dict3 = {'a': 1, 'b': 2, 'c': 3}
dict4 = {'b': 4, 'c': 6, 'd': 8}
print(lyh_update(dict3, dict4))

测试结果

8.PNG

---

9.实现属于自己的items方法：将字典转换成列表，字典中的键值对转换成元祖。（不能使用items方法）

代码

def lyh_items(dict1: dict):
    list1 = []
    tuple1 = ()
    for key in dict1:
        tuple1 = key, dict1[key]
        list1.append(tuple1)
    return list1


print(lyh_items({'a': 1, 'b': 2, 'c': 3}))

测试结果

9.PNG

---