Python 함수의 고급 사용 요약

이 글에서는 함수 명명 및 범위, 함수 중첩 및 범위 체인, 함수 이름 등 고급 함수의 사용 방법을 주로 소개하는 python에 대한 관련 지식을 제공하기를 바랍니다. 모두에게 도움이 될 것입니다.

추천 학습: python 동영상 튜토리얼

1. 함수 네임스페이스 및 범위

1. 함수 네임스페이스

• 네임스페이스란 무엇인가요?

코드 문자열이 있으면 출력을 관찰하세요.

def f():
    a = 1
    return a

print(a)

输出结果：
Traceback (most recent call last):
  File "E:/python代码/11/文件一.py", line 4, in <module>
    print(a)
NameError: name 'a' is not defined</module>

오류가 보고됩니다! 오류는 "이름 'a'가 정의되지 않았습니다"입니다. 변수 a가 정의되지 않았습니다. . . 왜? 나는 a=1을 명확하게 정의했습니다!

그런 다음 Python 코드가 실행 중 함수를 만났을 때 무엇을 하는지 이해해야 합니다.

먼저 Python 인터프리터에서 실행을 시작한 후 변수를 만날 때마다 메모리에 공간이 열립니다. 변수 이름과 값 사이의 대응. 그러나 함수 정의를 만나면 인터프리터는 함수 이름을 메모리로 기호적으로만 읽어서 이 함수의 존재를 알고 있음을 나타냅니다. 함수 내부의 변수와 논리에 대해서는 전혀 신경 쓰지 않습니다. 함수 호출이 실행되면 파이썬 인터프리터는 함수의 내용을 저장하기 위해 또 다른 메모리를 할당합니다. 이때 함수의 변수에 주의를 기울이고 함수의 변수는 새로 열린 곳에 저장됩니다. 메모리. 함수에 포함된 변수는 함수 내부에서만 사용할 수 있으며, 함수 실행이 완료되면 이 메모리에 있던 내용은 모두 지워집니다.

"이름과 값의 관계를 저장하는" 공간에 이름을 붙였습니다. 네임스페이스라고 합니다.

코드가 처음에 "변수 이름과 값의 관계"를 저장하기 위해 만든 공간을 global이라고 합니다. 네임스페이스, 함수의 내부 동작 중에 열리는 임시 공간을 로컬 네임스페이스

• 함수 네임스페이스의 세 가지 범주

함수 네임스페이스는 총 세 가지 범주로 나뉩니다

1、内置命名空间 —— python解释器
    # 就是python解释器一启动就可以使用的名字存储在内置命名空间中
    # 内置的名字在启动解释器的时候被加载进内存里
2、全局命名空间 —— 我们写的代码但不是函数中的代码
    # 是在程序从上到下被执行的过程中依次加载进内存的
    # 放置了我们设置的所有变量名和函数名
3、局部命名空间 —— 函数
    # 就是函数内部定义的名字
    # 当调用函数的时候 才会产生这个名称空间 随着函数执行的结束 这个命名空间就又消失了

#在局部:可以使用全局、内置命名空间中的名字
#在全局:可以使用内置命名空间中的名字，但是不能用局部中使用
#在内置:不能使用局部和全局的名字的

내장된 명명 공간: 내장된 네임스페이스는 Python 인터프리터가 제공하는 이름(함수)을 저장합니다. 이를 정의할 필요는 없습니다. 예를 들어 인터프리터를 열어서 직접 사용할 수 있습니다. : input, print, str, set...

• 세 개의 네임스페이스 간의 로드 및 값 순서

로드 순서: 내장 네임스페이스(프로그램 실행 전에 로드됨> 전역 네임스페이스( 프로그램 실행 중: 위에서 아래로 로드됨)> 로컬 네임스페이스(프로그램 실행 시: 호출될 때만 로드됨)

로컬로 호출할 때: 로컬 네임스페이스 > 내장 네임스페이스

전역적으로: 전역 네임스페이스 > 내장 네임스페이스

예:

a = 10
def f():
    a = 1
    print(a)
f()
print(a)

输出结果：
1
10

2. 함수의 범위

는 유효 범위에 따라 전역 범위와 로컬 범위로 나눌 수 있습니다.

전역 범위: 내장 네임스페이스 및 전역 범위를 포함합니다. 네임스페이스는 전체 파일의 어느 곳에서나 참조할 수 있으며 전역적으로 유효합니다.

로컬 범위: 로컬 네임스페이스는 로컬 범위 내에서만 적용될 수 있습니다.

globals():

• 이 함수는 현재 위치

  의 모든 전역 변수를 사전 유형으로 반환합니다.

  def func():
      a = 1
      print(locals())
      print(globals())
      print('========================分割线==========================')
  func()
  print(locals())
  print(globals())

  출력 결과:

.

• global关键字

1、global是Python中的全局变量关键字。
2、变量分为局部变量与全局变量，局部变量又可称之为内部变量。
3、由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。
4、全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。
5、global关键字的作用是可以使得一个局部变量为全局变量

例子：

在my函数中，在 x 前面加 global，my函数将 x 赋为8，此时全局变量中的 x 值改变。需要注意的是 global 需要在函数内部声明，若在函数外声明，则函数依然无法操作 x 。

x = 4
 
def my():
    global x
    x = 8
    print("x = ", x)
 
print("x = ", x)
my()
print("x = ", x)
 
 
输出结果是：
x = 4
x = 8
x = 8

---

二、函数的嵌套和作用域链

• 函数的嵌套调用

def max2(x,y):
    m  = x if x>y else y
    return m

def max4(a,b,c,d):
    res1 = max2(a,b)
    res2 = max2(res1,c)
    res3 = max2(res2,d)
    return res3

ret = max4(1,2,4,3)
print(ret)

输出结果：
4

• 函数的嵌套定义

def f1():
    print("in f1")
    def f2():
        print("in f2")

    f2()
f1()

输出结果：
in f1
in f2

def f1():
    def f2():
        def f3():
            print("in f3")

        print("in f2")
        f3()

    print("in f1")
    f2()


f1()

输出结果：
in f1
in f2
in f3

• 函数的作用域链

a = 1
def outer():
    a = 5
    def inner():
        a = 2
        def inner2():
            nonlocal a
            a += 1
            print('inner2',a)
        inner2()
        print('##a##:',a)
    inner()
    print('**a**:',a)

outer()

print('全局:',a)

输出结果：
inner2 3
##a##: 3
**a**: 5
全局: 1

• nonlocal关键字

#nonlocal 只能用于局部变量，找上层中离当前函数最近一层的局部变量且外部必须有这个变量
#声明了nonlocal的内部函数的变量修改会影响到离当前函数最近一层的局部变量
#对全局无效，在内部函数声明nonlocal变量之前不能再出现同名变量
#对局部也只是对最近一层有影响

def f1():
    a = 1
    def f2():
        nonlocal a
        a = 2
    f2()
    print('a in f1 : ',a)

f1()

输出结果：
a in f1 :  2

• global关键字

# 对于不可变数据类型 在局部可是查看全局作用域中的变量
# 但是不能直接修改
# 如果想要修改，需要在程序的一开始添加global声明
# 如果在一个局部（函数）内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效

---

三、函数名的本质

1. 函数名就是内存地址

2. 函数名可以被赋值

3. 函数名可以作为容器类型的元素

4. 函数名可以作为函数的返回值

5. 函数名可以作为函数的参数

def func():
    print(123)
func()
print(func)
# 函数名就是内存地址
# 函数名可以被赋值
func2 = func
func2()

#函数名可以作为容器类型的元素
l = [func,func2]
for i in l:
    i()
def func():
    print(123)

def wahaha(f):
    f()
    return f            #函数名可以作为函数的返回值
qqxing = wahaha(func)   #函数名可以作为函数的参数
qqxing()

输出结果：
123
<function>
123
123
123
123
123</function>

• 思考 

如果我自己定义了一个input函数（作用：调用该函数就打印'在下周周ovo'），会不会与内置的input函数有冲突呢？

def input(a):
    print('在下周周ovo')

那么接下来的代码怎么运行呢？

def input(a):
    print('在下周周ovo')

def func():
    input('请输入')
    print(input)

func()

答案：

---

四、闭包

• 闭包函数的概念

内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数
#函数内部定义的函数称为内部函数

由于有了作用域的关系，我们就不能拿到函数内部的变量和函数了。如果我们就是想拿怎么办呢？返回呀！

如果函数内的变量我们要想在函数外部用，可以直接返回这个变量，那么如果我们想在函数外部调用函数内部的函数呢？那就直接将函数名字作为返回值就好

def outer():
    a = 1
    def inner():
        print(a)    #内部函数调用了外部变量a
    return inner

inn = outer()
inn()

输出结果：
1

• 闭包函数的判断方法

判断闭包函数的方法__closure__

当运行后，如果有cell的话，就表示是闭包函数。如果没有就不是。

#输出的__closure__有cell元素 ：是闭包函数
def func():
    name = 'eva'
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f = func()
f()

#输出的__closure__为None ：不是闭包函数
name = 'egon'
def func2():
    def inner():
        print(name)
    print(inner.__closure__)
    return inner

f2 = func2()
f2()

输出结果：
(<cell>,)
eva
None
egon</cell>

• 闭包嵌套

顾名思义是两个或以上的闭包函数嵌套在一起

def wrapper():
    money = 10
    def func():
        name = 'zhou'    
        def inner():
            print(name,money)    #引用了func()函数中name变量引用了wrapper()函数中money变量
        return inner
    return func

f = wrapper()
i = f()
i()

输出结果：
zhuo 10

---

小结

#func(一个函数名)  --->>对应函数的内存地址
#函数名（）---函数调用
#函数的内存地址----（）函数的调用
# 作用域两种
# 全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域  ——globals()
# 局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——#locals()globals() : 永远打印全局的名字
#locals()  : 输出什么 根据locals所在位置
#在代码中要尽量少定义全局变量，多使用返回值和接收返回值
#函数的嵌套：
        嵌套调用
        嵌套定义：定义在内部的函数无法直接在全局被调用
#函数名的本质：
        就是一个变量，保存了函数所在的内存地址
#闭包：
        内部函数包含对外部作用域而非全剧作用域名字的引用，该内部函数称为闭包函数

推荐学习：python视频教程

위 내용은 Python 함수의 고급 사용 요약의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!