Day-10 - 函数的应用（2018-10-11）

作者: 雨雨雨90 | 来源:发表于2018-10-11 17:04 被阅读0次

一、匿名函数

1.普通函数：
def 函数名(参数列表):
函数体
2.匿名函数：
函数名 = lambda 参数列表: 返回值
说明：
函数名 -> 变量名
lambda -> 关键字
参数列表 -> 参数名1, 参数名2……
返回值 -> 相当于只有一个return语句的函数体

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

函数体（返回值）是一条语句，并且这条语句是有结果的（赋值语句是没有结果的，在匿名函数体中会报错）

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

sum1 = lambda num1, num2: num1 + num2

print(sum1(1, 2))  # 3

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

练习：求1+2+3+……+n的和

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

print(sum2(100))  # 5050

练习：读程序

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

print(funcs[0](2))
print(funcs[1](2))
# 注意：此处函数只有在调用的时候才会执行

二、变量的作用域

1.变量的作用域

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

2.全局变量

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

# a 是全局变量
a = 10

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

在函数中也可以使用全局变量，但是不能修改（修改要用global说明）

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


func1()  # 10

不要同时在函数中使用相同变量名全局和局部变量

a = 10
def func1():
    # 函数认为a是局部变量，但是在没有命名的时候就使用了a
    print(a)  # UnboundLocalError: local variable 'a' referenced before assignment
    a = 20
    print(a)


func1()  # 10

3.局部变量

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

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

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

4.global关键字

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

不使用global时,不能在函数中修改全局变量name：

name = 'abc'

def func2():
    name = 'aaa'
    print(name)

func2()  # aaa
print(name)  # abc

当使用global时可以在函数中修改变量全局变量name：

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

func3()
print(name)  # aaa

在函数中用global说明变量，函数结束后，仍然可以对变量进行操作


def func4():
    # 在函数中说明全局变量age
    global age
    age = 18

func4()
print(age)  # 18

5.nonlocal关键字

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

func3嵌套func4，不使用nonlocal时，func4只能修改func4函数域内的abc变量

def func3():
    abc = 100

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

    func4()
    print('f3:',abc)

func3()
# f4: 200
# f3: 100

当使用nonlocal时，func4可以修改函数func3中的abc变量

def func3():
    abc = 100

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

    func4()
    print('f3:',abc)

func3()
# f4: 200
# f3: 200
# print(abc)  # NameError: name 'abc' is not defined

三、函数作为变量

声明函数就是声明一个类型是function的变量，函数名实质就是变量名
函数名 ---> 一个函数（存储的是函数对应的地址）
函数名() ---> 调用函数，拿到的是函数的返回值


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

print(type(func1))  # <class 'function'>

print(type(lambda x: x*2))  # <class 'function'>

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

普通变量可以给其他变量赋值：

a = 10
b = a
print(b*10)

list1 = [1, 2]
list2 = list1
list2.append(100)
print(list2)

函数也可以给其他变量赋值

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

# 声明一个变量func11,类型是function
def func11():
    print('我是函数')
# 用一个函数给变量a赋值，a也是一个函数
a =  func11
a()  # 我是函数
# 将函数func11的返回值给b，b的值是None
b =  func11()  # 我是函数
print(b)  # None

2.函数作为列表的元素

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

list2 = [1, func22, func22()]  # 我又是函数
print(list2)  # [1, <function func22 at 0x00000000027C4AE8>, 10]

# list2[1]取到一个函数，通过后面加()调用函数
print(list2[1]())
# 我又是函数 (执行函数的过程的打印，不是上面print语句的操作）
# 10

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

3.将函数作为参数

普通变量可以作为参数:

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

func1(a)

函数也可以作为参数：

def func11(n):
    n()

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

func11(func12)  # hello world

应用：sort的使用

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

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

list2 = [
    {'name': '张三', 'age': 20, 'score': 88},
    {'name': '李四', 'age': 28, 'score': 100},
    {'name': '王五', 'age': 18, 'score': 89},
]

# list2.sort()
# print(list2)  # TypeError: '<' not supported between instances of 'dict' and 'dict'

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

list2.sort(key=get_age)
print(list2)  # [{'name': '王五', 'age': 18, 'score': 89}, {'name': '张三', 'age': 20, 'score': 88}, {'name': '李四', 'age': 28, 'score': 100}]

练习：对列表的中的元素（元组）的第二个元素排序

list3 = [
    ('a', 20),
    (10, 3),
    ('b', 90),
]


# def get_second(item):
#     return item[1]

# list3.sort(key=get_second,reverse=True)
# print(list3)  # [('b', 90), ('a', 20), (10, 3)]


list3.sort(key=lambda item: item[1],reverse=True)


print(list3)  # [('b', 90), ('a', 20), (10, 3)]

4.将函数作为返回值

例：根据运算符号，返回对应的功能

def operation(operator: str):
    if operator == '+':
        def add(*args, **kwargs):
            """
            求和
            :param args: 多个数字，整型
            :param kwargs: 多个数字，整型
            :return: 和
            """
            sum1 = 0
            for item in args:
                sum1 += item
            for key in kwargs:
                sum1 += kwargs[key]
            return sum1
        return add
    elif operator == '*':
        def multiply(*args, **kwargs):
            """
            求乘积
            :param args: 多个数字，整型
            :param kwargs: 多个数字，整型
            :return: 乘积
            """
            sum1 = 1
            for item in args:
                sum1 *= item
            for key in kwargs:
                sum1 *= kwargs[key]
            return sum1
        return multiply

re = operation('+')(90,99)
print(re)  # 189

f2 = operation('*')  # f2是multiply,是有两个不定长参数，功能是求乘积的函数
re = f2(10, 20, a=2, b=3)
print(re)  # 1200
# 函数写在函数里面不能直接调用
# add(10, 20) # NameError: name 'add' is not defined

函数作为参数 --> 闭包
函数作为返回 --> 装饰器

四、函数的调用

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

求多个数的和以及平均值

def yxy_sum(*nums):
    sum1 = sum(nums)
    average = sum1/len(nums)
    return sum1, average  # 同时返回和、平均值


a, b = yxy_sum(2, 45, 67, 90, 0)
print(a, b)  # 204 40.8

# num = yxy_sum(2, 45, 67, 90, 0)
# print(num[0], num[1])  # 204 40.8

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

每次调用函数的时候，系统都会在内存中（栈）开辟空间来存储函数执行过程中产生数据（函数中声明的变量）
当函数调用完成后，这块内存会自动销毁。
（栈区间的内存系统自己释放，堆区间的内存由代码释放）

注意此例：

a = 10
b = 20


def func1(a, b):
# 函数在赋值的时候，在栈区间开辟地址空间，存入全局变量对应地址空间所存储的值，所以局部变量a,b和全局变量a,b不是一个地址
    a, b = b, a


print(a, b)  # 10, 20

五、递归函数

1.什么是递归函数

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

循环能做的事情递归都可以做，但是实际上循环能解决的问题绝对不选递归（因为递归在递归到临界值之前，会产生n个函数，每个函数都会压栈，浪费内存和CPU资源）

下面是递归产生的死循环：

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

# func1()  # RecursionError: maximum recursion depth exceeded while calling a Python object

2.怎么写递归函数

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

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

def yxy_sum(n):
    # 1.找临界值
    if n == 1:
        return 1
    # 2.找关系
    """
    yxy_sum(n) = 1+2+3+……+n
    yxy_sum(n-1) = 1+2+3+……+n-1
    yxy_sum(n) = yxy_sum(n-1) + n
    """
    # 3.用f(n-1)实现f(n)的功能
    return yxy_sum(n-1) + n


print(yxy_sum(100))  # 5050

解读：
用n=5举例
yxy_sum(5) n=5 5!=1 return yxy_sum(4)+5
yxy_sum(4) n=4 4!=1 return yxy_sum(3)+4
yxy_sum(3) n=3 3!=1 return yxy_sum(2)+3
yxy_sum(2) n=2 2!=1 return yxy_sum(1)+2
yxy_sum(1) n=1 1==1 return 1
然后反向开始返回值

用递归实现以下功能

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

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

    """
    f(n)和f(n-1)的关系：
    先打印'*'*n
    再打印f(n-1)
    """
    print('*'*n)
    print_star(n-1)


print_star(7)

n = 3
*
**
***

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


def print_star2(n):
    if n == 1:
        print('*')
        return
    """
        f(n)和f(n-1)的关系：
        先打印f(n-1)
        再打印'*'*n
        """
    print_star2(n-1)
    print("*"*n)


print_star2(8)

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

网友评论

本文标题：Day-10 - 函数的应用（2018-10-11）

本文链接：https://www.haomeiwen.com/subject/bblbaftx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

Day-10 - 函数的应用（2018-10-11）

一、匿名函数

二、变量的作用域

1.变量的作用域

2.全局变量

3.局部变量

4.global关键字

5.nonlocal关键字

三、函数作为变量

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

2.函数作为列表的元素

3.将函数作为参数

4.将函数作为返回值

四、函数的调用

五、递归函数

1.什么是递归函数

2.怎么写递归函数

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Day-10 - 函数的应用 （2018-10-11）

一、匿名函数

二、变量的作用域

1.变量的作用域

2.全局变量

3.局部变量

4.global关键字

5.nonlocal关键字

三、函数作为变量

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

2.函数作为列表的元素

3.将函数作为参数

4.将函数作为返回值

四、函数的调用

五、递归函数

1.什么是递归函数

2.怎么写递归函数

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Day-10 - 函数的应用（2018-10-11）