python 장식 기 에 대해 알 아 보 겠 습 니 다.

1.역할 영역
python 에서 역할 영역 은 두 가지 로 나 뉘 는데 그것 이 바로 전역 역할 영역 과 국부 역할 영역 이다.
전역 역할 영역 은 파일 단계 에 정 의 된 변수,함수 이름 입 니 다.부분 작용 도 메 인 은 함수 내 부 를 정의 합 니 다.
역할 영역 에 대해 저 는 두 가 지 를 이해 해 야 합 니 다.a.전역 에서 국부 적 으로 정 의 된 변수 b 에 접근 할 수 없 지만 전역 적 으로 정 의 된 변 수 를 수정 할 수 없습니다.(물론 수정 할 수 있 는 방법 이 있 습 니 다)
다음은 다음 실례 를 살 펴 보 겠 습 니 다.

x = 1
def funx():
  x = 10
  print(x) #    10

funx()
print(x) #    1

부분 적 으로 변수 x 를 정의 하지 않 으 면 함수 내 부 는 안에서 밖으로 x 를 찾 습 니 다.찾 지 못 하면 오류 가 발생 합 니 다.

x = 1
def funx():
  print(x) #    1

funx()
print(x) #    1

x = 1
def funx():
  def func1():
    print(x) #    1
  func1()

funx()
print(x) #    1

따라서 역할 영역 에 관 한 문 제 는 두 가지 만 기억 하면 됩 니 다.전역 변 수 는 파일 의 어느 곳 에서 든 인용 할 수 있 지만 수정 은 전역 에서 만 작 동 할 수 있 습 니 다.부분 적 으로 필요 한 변 수 를 찾 지 못 하면 밖으로 찾 고 찾 지 못 하면 잘못 보고 합 니 다.
2.고급 함수
함수 명 은 사실 메모리 공간의 주 소 를 가리 키 는 것 임 을 알 고 있 습 니 다.주소 인 이상 우 리 는 이러한 특성 을 이용 할 수 있 습 니 다.
a 함수 이름 은 값 으로 할 수 있 습 니 다.

def delete(ps):
  import os
  filename = ps[-1]
  delelemetns = ps[1]
  with open(filename, encoding='utf-8') as f_read,\
    open('tmp.txt', 'w', encoding='utf-8') as f_write:
    for line in iter(f_read.readline, ''):
      if line != '
': #      
        if delelemetns in line:
          line = line.replace(delelemetns,'')
        f_write.write(line)
  os.remove(filename)
  os.rename('tmp.txt',filename)

def add(ps):
  filename = ps[-1]
  addelemetns = ps[1]
  with open(filename, 'a', encoding='utf-8') as fp:
    fp.write("
", addelemetns)

def modify(ps):
  import os
  filename = ps[-1]
  modify_elemetns = ps[1]
  with open(filename, encoding='utf-8') as f_read, \
      open('tmp.txt', 'w', encoding='utf-8') as f_write:
    for line in iter(f_read.readline, ''):
      if line != '
': #      
        if modify_elemetns in line:
          line = line.replace(modify_elemetns, '')
        f_write.write(line)
  os.remove(filename)
  os.rename('tmp.txt', filename)


def search(cmd):
  filename = cmd[-1]
  pattern = cmd[1]
  with open(filename, 'r', encoding="utf-8") as f:
    for line in f:
      if pattern in line:
        print(line, end="")
    else:
      print("    ")

dic_func ={'delete': delete, 'add': add, 'modify': modify, 'search': search}

while True:
  inp = input("          :").strip()
  if not inp:
    continue
  cmd_1 = inp.split()
  cmd = cmd_1[0]
  if cmd in dic_func:
    dic_func[cmd](cmd_1)
  else:
    print("Error")

b.함수 이름 은 반환 값 으로 할 수 있 습 니 다.

def outer():
  def inner():
    pass
  return inner

s = outer()
print(s)

######     #######
<function outer.<locals>.inner at 0x000000D22D8AB8C8>

c.함수 명 은 매개 변수 로 사용 할 수 있 습 니 다.

def index():
  print("index func")

def outer(index):
  s = index
  s()
  
outer(index)

######    #########

index func

그래서 위의 두 가지 조건 중 하 나 를 만족 시 키 면 모두 고급 함수 라 고 할 수 있다.
3.폐쇄 함수
패 킷 함 수 는 두 가지 조건 을 만족 시 켜 야 합 니 다.1.함수 내부 정의 함수 2.전역 역할 영역 이 아 닌 외부 역할 영역 에 대한 참조 포함
다음은 패 킷 함 수 를 실례 를 통 해 설명 한다.
실례 1:다음은 함수 내부 에서 만 함 수 를 정 의 했 을 뿐 패키지 함 수 는 아 닙 니 다.

def outer():
  def inner():
    print("inner func excuted")
  inner() #     inner()  
  print("outer func excuted")
outer() #     outer  

####     ##########
inner func excuted
outer func excuted

실례 2:다음은 함수 내부 에서 함 수 를 정 의 했 고 외부 변수 x 를 인 용 했 습 니 다.이것 은 패키지 함수 입 니까?아니다

x = 1
def outer():
  def inner():
    print("x=%s" %x) #       inner       
    print("inner func excuted")
  inner() #   inner  
  print("outer func excuted")

outer()
#####    ########
x=1
inner func excuted
outer func excuted

뒤 돌아 보 니 폐쇄 함수 에 대한 정 의 는 둘 다 만족 하지 않 습 니까?똑똑 한 당신 은 두 번 째 조 에 만족 하지 않 는 다 는 것 을 알 게 될 것 입 니 다.네,여기 있 는 변수 x 는 외부 에서 도 메 인 에 작용 하 는 변수 가 아니 라 전체 변수 에 속 합 니 다.다음 예 를 살 펴 보 자.

def outer():
  x = 1
  def inner():
    print("x=%s" %x)
    print("inner func excuted")
  inner()
  print("outer func excuted")

outer()

#####    #########
x=1
inner func excuted
outer func excuted

분명히 위의 실례 는 폐쇄 함수 의 조건 을 만족시킨다.지금 너 는 폐쇄 함수 로 서 상술 한 두 가지 조건 을 만족 시 켜 야 한 다 는 것 을 잘 알 아야 한다.그러나 일반적인 상황 에서 우 리 는 패 킷 함수 에 값 을 되 돌려 줍 니 다.여 기 는 왜 그런 지 말 하지 않 습 니 다.다음 내용 에서 이 반환 값 의 용 도 를 볼 수 있 습 니 다.

def outer():
  x = 1
  def inner():
    print("x=%s" %x)
    print("inner func excuted")
  print("outer func excuted")
  return inner #        
  
outer()

이제 폐쇄 함 수 를 추상 적 으로 정의 합 시다.그것 은 함수 와 그 와 관련 된 인용 환경 을 조합 하여 만 든 실체 이다.깊 은 제약 을 실현 할 때 인용 환경 을 표시 할 수 있 는 것 을 만 들 고 관련 서브루틴 과 묶 어서 닫 아야 합 니 다.위의 인 스 턴 스 에서 우 리 는 패 킷 함수 가 자신의 함수 와 외부 변 수 를 포함 해 야 패 킷 함수 라 고 할 수 있다 는 것 을 알 수 있다.외부 변수 와 연결 되 어 있 지 않 으 면@함수 가 패 킷 함수 라 고 할 수 없습니다.
그렇다면 하나의 패 킷 함수 에 몇 개의 외부 인용 변수 가 있 는 지 어떻게 압 니까?아래 코드 좀 보 세 요.

def outer():
  x = 1
  y = 2

  def inner():
    print("x= %s" %x)
    print("y= %s" %y)

  print(inner.__closure__)
  return inner

outer()

######    #######
(<cell at 0x000000DF9EA965B8: int object at 0x000000006FC2B440>, <cell at 0x000000DF9EA965E8: int object at 0x000000006FC2B460>)

그 결과 inner 내부 에서 두 개의 외부 부분 변 수 를 인용 한 것 으로 나 타 났 다.비 부분 변 수 를 참조 하면 여기 서 출력 하 는 것 은 None 입 니 다.
폐쇄 함수 의 특징:
1.자체 작용 영역 2.지연 계산
그렇다면 폐쇄 함 수 는 어떤 작용 을 합 니까?폐쇄 함수 가 정 의 될 때 외부 환경 에 연결 되 어 있다 는 것 을 잘 알 고 있 습 니 다.@하나의 전체 만 이 패 킷 함수 라 고 할 수 있 습 니 다.그러면 우 리 는 이 바 인 딩 특성 을 이용 하여 특정한 특수 한 기능 을 완성 할 수 있 습 니 다.
인 스 턴 스 3:들 어 오 는 URL 에 따라 페이지 원본 을 다운로드 합 니 다.

from urllib.request import urlopen

def index(url)
  def get()
    return urlopen(url).read()
  return get

python = index("http://www.python.org") #     get     
print(python()) #   get  《            
baidu = index("http://www.baidu.com")
print(baidu())

어떤 사람 은 이것 이 폐쇄 함수 의 조건 을 만족 시 키 지 못 한다 고 말 할 수 있다.전역 적 이지 않 은 외부 변 수 를 인용 하지 않 았 습 니 다.사실은 그렇지 않 습 니 다.자,우리 가 전에 말 했 듯 이 함수 내부 의 변 수 는 모두 함수 에 속 합 니 다.그러면 저 는 index(url)에 있 습 니 다.이 url 도 함수 내부 에 속 합 니 다.단지 우리 가 한 걸음 생략 했 을 뿐 입 니 다.그래서 위의 함수 도 폐쇄 함수 입 니 다.
4.장식 기
이상 의 기초 가 있 으 면 장식 기 에 대해 잘 이해 할 수 있 습 니 다.
장식 기:외부 함수 가 장식 함수 명 으로 들 어 오고 내부 함수 가 장식 함수 명 을 되 돌려 줍 니 다.
특징:1.피 장식 함수 호출 방식 을 수정 하지 않 음 2.피 장식 함수 의 소스 코드 를 수정 하지 않 음
무참 장식 기
다음 과 같은 실례 가 있 습 니 다.우 리 는 코드 가 실행 되 는 시간 을 계산 해 야 합 니 다.

import time, random

def index():
  time.sleep(random.randrange(1, 5))
  print("welcome to index page")

장식 기의 특징 에 따라 우 리 는 index()를 어떠한 수정 도 할 수 없고 호출 방식 도 바 꿀 수 없다.이때 우 리 는 장식 기 를 사용 하여 상기 기능 을 완성 할 수 있다.

import time, random

def outer(func): #  index      func
  def inner():
    start_time = time.time()
    func()  # fun = index  func     index     
    end_time = time.time()
    print("     %s"%(end_time - start_time))
  return inner #   inner   

def index():
  time.sleep(random.randrange(1, 5))
  print("welcome to index page")

index = outer(index) #       inner   ，      index

index()

그러나 일부 경우,장 식 된 함 수 는 파 라 메 터 를 전달 해 야 하고,일부 함 수 는 파 라 메 터 를 필요 로 하지 않 습 니 다.그러면 이러한 변 화 된 매개 변수 함 수 를 어떻게 처리 합 니까?다음은 매개 변수 장식 기의 사용 상황 을 살 펴 보 자.
b.인삼 장식 기

def outer(func): #  index      func
  def inner(*args, **kwargs):
    start_time = time.time()
    func(*args, **kwargs)  # fun = index  func     index     
    end_time = time.time()
    print("     %s"%(end_time - start_time))
  return inner #   inner   

다음은 다른 상황 의 실례 를 말씀 드 리 겠 습 니 다.
　  인 테 리 어 된 함수 에 반환 값 이 있 으 면

def timmer(func):
  def wrapper(*args,**kwargs):
    start_time = time.time()
    res=func(*args,**kwargs) #res   home      
    stop_time=time.time()
    print('run time is %s' %(stop_time-start_time))
    return res 
  return wrapper

def home(name):
  time.sleep(random.randrange(1,3))
  print('welecome to %s HOME page' %name)
  return 123123123123123123123123123123123123123123

여기에 우리 가 장식 한 함 수 를 실행 하려 면 다음 과 같은 호출 방식 이 어야 합 니 다.
　　home = timmer(home)  # 등식 오른쪽 에 있 는 것 은 wrapper 의 메모리 주 소 를 되 돌려 주 고 홈 에 값 을 부여 합 니 다.여기 있 는 홈 은 원래 의 함수 가 아니 라 장 식 된 함수 입 니 다.홈=timmer(home)와 같은 표기 법 은 python 이 우리 에 게 편리 한 방식 인 문법 사탕@을 제공 합 니 다.앞으로 우 리 는 장식 되 어 있 는 함수 전에@timmer 를 써 야 합 니 다.그 효 과 는 홈=timmer(home)와 같 습 니 다.
만약 한 함수 가 여러 개의 장식 기 에 장식 된다 면,실행 순 서 는 어떻게 됩 니까?

import time
import random

def timmer(func):
  def wrapper():
    start_time = time.time()
    func()
    stop_time=time.time()
    print('run time is %s' %(stop_time-start_time))
  return wrapper
def auth(func):
  def deco():
    name=input('name: ')
    password=input('password: ')
    if name == 'egon' and password == '123':
      print('login successful')
      func() #wrapper()
    else:
      print('login err')
  return deco

@auth  # index = auth(timmer(index))         
@timmer # index = timmer(index)
def index():
 
  time.sleep(3)
  print('welecome to index page')

index()

실험 결과 여러 개의 장식 기 가 하나의 함 수 를 장식 하고 그 집행 순 서 는 아래 에서 위로 향 하 는 것 으로 나 타 났 다.
장식 기 에 관 해 서 는 고급 용법 도 있 고 관심 이 있 으 면 스스로 연구 할 수 있다.