课时20:内嵌函数和闭包

目录:

函数

  一、global关键字

1. 如何定义函数

  1. 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()
  2. 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数
  3. 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明
  4. 函数内容以冒号起始,并且缩进
  5. return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None
  6. 函数的声明一定要在调用之前

  二、内嵌函数

2. 函数的定义

  • 函数就是我们将一些功能封装起来,减少一部分类似的代码

  三、闭包

例子(如果有一百个类似的需求,那么函数就显得很方便了)

1. 求1-10的和
sum1 = 0
for i in range(11):
    sum1 += i
print("sum1:", sum1)

2. 求1-100的和
sum1 = 0
for i in range(101):
    sum1 += i
print("sum1:", sum1)

3. 用函数的方式编程(n可以随意改变,适合所有类似的需求)
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i
    return sum1

print("sum1:", getSum(n))

  四、课时20课后习题及答案

3. 函数什么时候需要返回值

 

1. 为什么需要返回值

  • 有一些函数需要这个函数处理一些数据后返回数据给你,比如 math.sqrt(n) ,这个函数会返回 n 的二分之一次方,外界需要这个值去操作其它东西

********************

2. 什么时候需要返回值

求和函数需要一个求出来的和,这个就是需要返回值
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i
    return sum1

一、global关键字

4. global关键字

********************

1. 什么是global

  • global是一个关键字,这个关键字可以将函数内部的局部变量变成全局变量
1. 这种情况外部不能访问函数内部的局部变量
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i

print(sum1)     --> 这个sum1是不能被外部访问到的

2. 加上global后就能调用了
def getSum(n):
    global sum1
    sum1 = 0
    for i in range(n):
        sum1 += i

print(sum1)     --> 这个sum1是能被访问到的

全局变量的作用域是整个模块(整个代码段),也就是代码段内所有的函数内部都可以访问到全局变量。但是要注意一点,在函数内部仅仅去访问全局变量就好,不要试图去修改它。

2. 什么时候需要global

  • 个人很不建议使用global关键字,第3点会讲解
这种外部不能访问函数内部的局部变量情况下可以使用global
def getSum(n):
    sum1 = 0
    for i in range(n):
        sum1 += i

print(sum1)     --> 这个sum1是不能被外部访问到的

因为那样的话,Python会使用屏蔽的方式”保护“全局变量:一旦函数内部试图修改全局变量,Python就会在函数内部自动创建一个名字一模一样的局部变量,这样修改的结果只会修改到局部变量,而不会影响到全局变量。看下面的例子:

3. global需要注意的事情

def getSum(n):
    global sum1
    sum1 = 0
    for i in range(n):
        sum1 += i

sum1 = 0    --> 这个是外部的变量:sum1
getSum(n)
print(sum1)     --> 这个sum1是能被访问到的
一旦外部也有sum1变量的时候,外部的变量的值会被覆盖,而且
>>> count=5
>>> def myFun():
    count = 10
    print(count)


>>> myFun()
10
>>> count
5

5. nonlocal关键字

如果觉得有必要在函数中去修改这个全局变量,那么你不妨可以使用global关键字来达到目的!修改程序如下:

1. 为什么需要nonlocal

def outer():
    num1 = 100
    def inner():
        num1 = 200
        print(num1)
    inner()
    print(num1)

结果:
    200
    100

为了解决内嵌函数访问闭包函数的变量推出了nonlocal关键字

>>> count=5
>>> def myFun():
    global count
    count = 10
    print(count)


>>> myFun()
10
>>> count
10

2. 使用方式

def outer():
    num1 = 100
    def inner():
        nonlocal num1
        num1 = 200
        print(num1)
    inner()
    print(num1)

结果:
    200
    200

 

6. 函数的可变参数(可变参数是一个元组传递到函数中)

二、内嵌函数

1. 什么时候需要可变参数

1. 求两个数的和
def getSum(n1, n2):
    return n1 + n2

2. 求三个数的和
def getSum(n1, n2, n3):
    return n1 + n2 + n3

3. 求四个数的和
def getSum(n1, n2, n3, n4):
    return n1 + n2 + n3 + n4

这个时候,我就可以使用可变参数
def getSum(*n1):
    sum1 = 0
    for item in n1:
        sum1 += item
    return sum1

****************

2. 可变参数与普通参数混合后的缺点

  • 一旦你的可变参数与普通参数混合了,那么就会出现问题
这个结果就会报错,按照我们正常思维三个数求和应该等于 6 才对,但是函数分不清你的参数 3 是 n1 的还是 n2 的
def getSum(*n1, n2):
    sum1 = 0
    for item in n1:
        sum1 += item
    return sum1

getSum(1,2,3)   


解决这个问题可以将可变参数放在参数列表最后面来解决
def getSum(n1, *n2):
    sum1 = 0
    for item in n2:
        sum1 += item
    return sum1

 Python函数定义是可以嵌套的,也就是允许在函数的内部创建另外一个函数,这种函数叫做内嵌函数或者内部函数。举个例子:

7. 函数参数的默认值

>>> def fun1():
    print("fun1()正在被调用")
    def fun2():
        print("fun2()正在被调用")
    fun2()


>>> fun1()
fun1()正在被调用
fun2()正在被调用

1. 优缺点

  1. 不容易报错,哪怕你没有写函数的参数

值得注意的是:就是内部函数整个作用域都在外部函数之内。

2. 例子

这个时候就可以不写参数也能调用,因为参数有一个默认值 1,但是不建议不写
def max1(n1 = 1):
    return n1

print(max1())


如果你在参数中传递 2,那么n1的值就会赋值为 2
def max1(n1 = 1):
    return n1

print(max1(2))

另外需要注意的地方:如果在fun1()外部试图调用内部函数fun2(),就会报错:

8. 不同文件之间的函数的调用

>>> fun2()
Traceback (most recent call last):
  File "<pyshell#45>", line 1, in <module>
    fun2()
NameError: name 'fun2' is not defined

1. 为什么需要不同文件之间函数调用

  1. 因为你的程序不可能写在一个文件中,而且有时候你需要和别人合作开发项目,这个时候不同文件夹下的函数相互调用就有必要了

 

2. 调用方式

  1. 导包import 文件夹名.文件夹名.文件名
  2. from 文件夹名.文件夹名.文件名 import 模块

***********

9. 局部变量与全局变量

三、闭包

1. 局部变量与全局变量的概念

  • 局部变量就是只在某一个代码块中变量(for循环中,函数中,while循环中)
  • 全局变量就是在一个文件的任何地方都能访问到的变量

***********

2. 作用域

  • 作用域就是你for中的变量你只能在for中访问,外面访问不到
for item in range(10):
    num1 = 1
print(num1)  --> for语句的外面就访问不到for语句中的num1,
这个for语句的语句块就是num1的作用域

 闭包是函数编程的一个重要的语法结构,函数式编程是一种编程范式,著名的函数式编程语言就是LISP语言。

3. LEGB

  1. L:local 函数内部作用域
  2. E:enclosing 函数内部与函数内部内嵌函数之间
  3. G:global 全局作用域
  4. B:build-in 内置作用域(比如list、tuple)

Python中闭包从表现形式上定义为:如果在一个内部函数内(funY就是这个内部函数),对外部作用域(但不是在全局作用域)的变量进行引用(x就是被引用的变量,x在外部作用域funX里面,但不在全局作用域里),那么内部函数就被认为是闭包。

4. 变量查找顺序

  • 变量查找只能从内部往外部找

本文由金沙官网线上发布于编程,转载请注明出处:课时20:内嵌函数和闭包

您可能还会对下面的文章感兴趣: