내 파이썬 학습 과정 -Day10 고급 기능을 기록

함수 매개 변수 Ⅱ

• 세번째 파라미터 : 동적 파라미터

  또한 두 개의 파라미터들로 분할 이동해도 동적 위치 파라미터 수신 * 인수를, 키워드 수신 동적 파라미터 ** kwargs로를

  • * 인수 ** ** 동적 위치 파라미터를 수신

    def msg(*args):
        print('你的信息为:', args)
    
    msg('name', 111, False, [1, 3, 4, 5])
    
    # 运行结果:你的信息为: ('name', 111, False, [1, 3, 4, 5])

    위의 매개 변수의 의미를 설명 : 모든 인수 우선, 보통이다 매개 변수 인수를하지만, 전면 인수에 하나를 추가하면, 그때는 특별한 의미가 있습니다 곱셈 기호뿐만 아니라, 파이썬을, 그는 마법이있다 가. 이 매개 변수를 설정 한 후 인수가 튜플에 배치 위치를 수신 매개 변수 모든 참가자를 형성하고, 여기에 마법 효과를 재생하는 튜플 인수 매개 변수를 지정할 수 있도록 인수가 * 추가 되지 인수, a는 단지 결과를 얻을 수 있습니다,하지만 우리는 사양은 인수의 사용 규칙을 제공 PEP8.

    • 운동 : 수신 int 데이터 유형, 함수의 변수 번호를 기능과 숫자 반환을 모두 계산합니다.

    # 传入函数中数量不定的int型数据，函数计算所有数的和并返回。
    def cont(*args):
        n = 0
        for i in args:
            n += i
        return n
    
    cont = cont(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    print(cont)
    
    # 运行结果: 55

  • : 동적 키워드 인수받을 ****** kwargs로를

    인수 각도 위치 매개 변수와 이가지 키워드 매개 변수가 이제 파이썬 모든 위치 매개 변수 다음 확실히 모든 키워드 인수를 사용할 수있는 매개 변수가 받아 들일 수 * 인수가, 다음이되는 것을 kwargs로이 공감은 마법이다 사용, kwargs로 규칙은 매개 변수로 사용. 예시 : ** kwargs로는, 모든 주요 매개 변수를 허용 한 후 '사전'kwargs로이 매개 변수에 할당로 변환.

    def func(**kwargs):
        print(kwargs)
    
    func(name='Dylan', age=18, sex='男')
    
    # 运行结果:{'name': 'Dylan', 'age': 18, 'sex': '男'}

  • 문구의 전체 동적 매개 변수

    def fun(*args, **kwargs):
        print(args)
        print(kwargs)
    
    fun('周一', '周二', '周三', '周四', name='Dylan', age=18, sex='男')
    
    # 运行结果:
    # ('周一', '周二', '周三', '周四')
    # {'name': 'Dylan', 'age': 18, 'sex': '男'}

    매개 변수가 설정되어있는 경우, 동적 매개 변수, 그는 대응의 문제를 해결하기 위해 모두에게 더 많은 매개 변수의 경우 다음 인수에 대해 크게 확장의 기능을 향상 할 위치 매개 변수와 키워드 인수를받을 수 있습니다 .

• *** 사용의 마법 **

  • 중합에 기능 및 휴식.

    • 집합

      때 난 그냥라는 매개 변수를 정의하면 어떤 함수 정의 : 인수는,이 매개 변수는 하나 개의 인수를 받아 들일 수 :

      def msg(args):
          print('你的信息为:', args)
      
      msg('name')
      
      # 运行结果:你的信息为: name

      접두어 인 번호 * 인수 후 인수의 복수를 받고, 튜플을 반환 할 수있는 경우 (** kwargs로를 같은 이유로 반환 사전 키워드로 변환 매개 변수의 복수입니다)
      그래서 :
      때 함수 정의 ' ' 중합의 역할을한다.

    • 밟아 다진

      s = 'Dylan'
      li = [1, 2, 3, 4]
      tu = ('Name = Dylan', 'age = 18', 'sex = 男')
      
      def func(*args):
          print(args)
      
      func(*s, *li, *tu)
      
      # 运行结果:('D', 'y', 'l', 'a', 'n', 1, 2, 3, 4, 'Name = Dylan', 'age = 18', 'sex = 男')

      함수가 실행될 때, 인수 I (가능한 반복 방식) 여기서 변수 * 또는 ** 파라미터의 위치와 같은 구성 요소로 분해 된 이들 인자에 상당하고 전달 또는 인수 앞에는이며 kwargs로.
      그래서 : 함수, * 또는 ** 놀이의 실행에 역할을 나뉩니다.

      dic1 = {'name': 'Dylan', 'age': 18, 'sex': '男'}
      dic2 = {'0': 11, '1': 22, '2': 33}
      
      def func(**kwargs):
          print(kwargs)
      
      func(**dic1, **dic2) #
      
      # 运行结果:{'name': 'Dylan', 'age': 18, 'sex': '男', '0': 11, '1': 22, '2': 33}

  • 함수는 나머지 외부 요소를 처리 할 수있다.

    이러한 첨가는 중합 외부 기능도 유연하게 사용할 수 있고, 함수에 세분화 될 수있다 :

    # 之前讲过的分别赋值
    a,b = (1,2)
    print(a, b) # 1 2
    # 其实还可以这么用：
    a,*b = (1, 2, 3, 4,)
    print(a, b) # 1 [2, 3, 4]
    *rest,a,b = range(5)
    print(rest, a, b) # [0, 1, 2] 3 4
    print([1, 2, *[3, 4, 5]]) # [1, 2, 3, 4, 5]

    하나는 말을 많이하지를 이해할 수있다.

• 매개 변수 순서

  위치 매개 변수, 기본 매개 변수 : 위치 매개 변수 즉, 전면에 있어야합니다.
  그런 다음 동적 매개 변수를 어디에 넣어하는 인수, ** kwargs로를 *?
  동적 매개 변수 인수, 확실히 위치 매개 변수의 앞에, 내 인수의 특정 인수의 위치 매개 변수를 수신하지 않도록 :

  # 这样位置参数a,b 始终接收不到实参了,因为 *args全部接收完了
  def func(*args, a, b, sex='男'):
      print(args)
      print(a, b)
  
  func(1, 2, 3, 4, 5)
  
  # 运行结果:程序报错了

  그런 다음 동적 매개 변수를 인수 뒤에있는 위치에 있어야합니다, 그는 그 뒤에 매개 변수를 기본값으로 할 수 있습니까?

  # 这样也不行，我的实参的第三个参数始终都会将sex覆盖掉，这样失去了默认参数的意义。
  def func(a, b, sex='男', *args, ):
      print(args)  # (4, 5)
      print(sex)  # 3
      print(a, b)  # 1 2
  
  func(1, 2, 3, 4, 5)

  * 인수는 중간 위치 매개 변수의 기본 매개 변수에 있어야합니다 : 위치 매개 변수 * 인수, 기본 매개 변수 .

  # 直接报错：因为**kwargs是接受所有的关键字参数，如果你想改变默认参数sex，你永远也改变不了，因为它会先被**kwargs接受。
  def func(a,b,*args,**kwargs,sex='男',):
      print(args) # (4, 5)
      print(sex) # 3
      print(a,b) # 1 2
      print(kwargs)
  
  func(1, 2, 3, 4, 5, age=80, sex='666')

  따라서,이 컷 - 오프 : 순서에 대한 모든 형식 매개 변수 :
  위치 매개 변수, 인수, 기본 매개 변수, * kwargs로.

• 매개 변수의 네 번째 매개 변수는 : 키워드는 매개 변수

  키워드 인수는, 자신의 위치가 *의 인수 후 배치해야 python3x 갱신 새로운 기능입니다 앞 kwargs로 (있는 경우 는 이전과 주문 후 기본 매개 변수와 함께 중요하지 않습니다, 기본 위치 매개 변수입니다 kwargs로), 그것은 단지 키를 받아 단어는 매개 변수를 전달 :

  def func(a,b,*args,sex= '男',c,**kwargs,):
      print(a,b)
      print(sex)
      print(args)
      print(c)
      print(kwargs)
  
  func(1,2,3,4,5,6,7,sex='女',name='Alex',age=80,c='666')
  
  """
  输出结果:
  1 2
  女
  (3, 4, 5, 6, 7)
  666
  {'name': 'Alex', 'age': 80}
  """

  주요 매개 변수는 그가 단지 키워드 인자에 의해 매개 변수를 전달할 수 있음을 알 수 이름에서만 정의, 사실, 당신은 오류에 통과하지 못한, 통과해야 기본 매개 변수 및 매개 변수의 기본 값으로 설정할 수 없습니다.

  그래서 결국 순서 매개 변수 각도의 모든 형식 매개 변수는 다음과 같습니다
  ** 위치 매개 변수, 인수, 기본 매개 변수, 키워드 매개 변수 만 * kwargs로. **

네임 스페이스 및 범위

• 네임 스페이스

  파이썬 시작을 실행 한 결과, 메모리의 공간을 열 것이다 그것이 변수를 발견 할 때마다, 이름과 기록 된 값이지만 사이 가변 관계 넣어 함수 정의, 인터프리터에 직면했을 때 그냥 함수 이름을 넣어하면 기능은 변수와 함수의 내부 논리로, 인터프리터가에 대해 우려하지 않는, 존재하는 것을 나타내는, 메모리에 읽습니다. 함수가 함수가 호출 더 때만 아무것도에로드 시작 단지입니다 그리고 방문 시간은 인터프리터가 함수 내에서 선언 된 변수에 따라 내부 변수 공간을 엽니 다. 함수 완료와 함께, 공간의 함수로 내부 변수의 기능은 완성 된 비운됩니다 점령했다.

  파이썬 코드 만남은 그것이 변수를 만날 때마다 메모리 공간, 오픈 후 파이썬 인터프리터의 구현의 시작 부분에서 수행하는 방법입니다 기능을 실행하면, 변수 이름과 값을 넣어 우리는 첫번째 리콜 내부 변수와 논리 함수 인터프리터 상관되지 않는 한 해당 레코드 관계하지만, 함수 정의에 직면했을 때, 단지 상징적 인터프리터 메모리와 같은 함수의 이름을 읽어는,이 기능의 존재를 인식하고 있었다.

  메모리에 함수 호출을 수행 할 때, 파이썬 인터프리터는 다음이 내부에,이 시간을 저장하는 메모리 기능을 열 것 등은, 전용 변수가 작동 것에 대해이 우려되고, 변수의 기능이 저장되는 새로운 열었다 내부 변수의 함수는 함수를 사용하고, 마무리 의지 기능이 메모리의 모든 내용이 삭제 될 수있다.

  우리는이 '관계 저장소에게 이름과 값'의 이름을 공간을했습니다 : 네임 스페이스를 .

  "변수 이름과 값 사이의 관계의"공간을 실행 처음에 코드라는 저장 만들려면 글로벌 네임 스페이스를 ;

  실행 기능에 열어 임시 공간에서 호출되는 로컬 네임 스페이스 라고도 임시 공간 .

  지금 우리가 알고있는, 평 파일, 저장된 값과 글로벌 네임 스페이스라는 공간의 변수 사이의 관계, 그리고 함수가 실행될 때, 임시 메모리 변수의 값의 기능 사이의 관계의 임시 저장을위한 공간을 열 것입니다, 이 임시 이름 공간, 또는 로컬 이름 공간이라고합니다.

  사실, 파이썬이라는 공간이 내장 된 네임 스페이스 에 저장 특별한 변수 내장 된 네임 스페이스하는 일부 기능 내장, 그래서 :: 입력, 인쇄, 목록 제기되는 등입니다

  요약 :

  • 글로벌 네임 스페이스 -> 문서에서 직접 우리를 평, 변수는 외부 전역 네임 스페이스에 속하는 기능을 선언

  • 현지 네임 스페이스 -> 함수에 선언 된 변수는 로컬 네임 스페이스에 보관됩니다

  • 내장 네임 스페이스 -> 저장 파이썬 인터프리터는 이름,리스트, 튜플, str을 우리에게 제공, 이들은 내장 된 네임 스페이스를 int로

    # 内置名称空间：python源码给你提供的一些内置的函数，print input
    # print(666)
    # python分为三个空间：
        # 内置名称空间（builtins.py）
        # 全局名称空间（当前py文件）
        # 局部名称空间（函数，函数执行时才开辟）

• 로드 순서

  소위로드 순서, 즉, 세 개의 공간 즉, 메모리에서 만든 세 공간의 순서, 당신은 그들이 그것을 만들 동시에 할 수 있다고 생각, 순서대로 메모리에로드? 확실히, 그 다음 누가 그것을 게시해야합니까? 그것은 따라서 우리는 스트로크 : 파이썬 인터프리터를 시작한 후, 심지어 어떤 변수 나 함수를 생성하지 않고, 거기에 일부 기능은 복근 (-1), 최대 (1,3로 직접적 사용할 수있을 것입니다 ) , 등등 및 파이썬 인터프리터를 시작합니다 그것이 우리의 사용을 위해 메모리에 수입되었을 때 처음 내장 된 네임 스페이스를로드 한 다음 초기화 변수가 발생하면이 시간에, 라인으로 선을 상단에서 파일을 실행하기 시작해야하므로, 그것은 글로벌 이름 공간을 생성합니다 함수는 임시 공간 변수의 개수의 로딩 기능을 열어 실행 메모리 등이 충족되면 이러한 대응 관계에 저장하고.
  세 개의 공간에 대한로드 순서 그래서 :
  내장 된 네임 스페이스 (시작 실행 프로그램로드) -> 글로벌 네임 스페이스 (프로그램 실행 : 위에서 아래 로딩에) -> 로컬 네임 스페이스 (프로그램 실행 : 때 호출 부하) .

  # 加载顺序：
  # 内置名称空间 ---> 全局名称空间  ----> 局部名称空间（函数执行时）
  def func():
      pass
  func()
  a = 5
  print(666)

• 주문 금액

  순서 값은 가변 먼저 참조를 시작하는 공간에 대한 참조이다. 변수 (전용 기준 가변속 층에서 변경 될 수없는 주) 기준이되는 공간의 시작 :이 중요한 포인트가있다. 우리는 각각 설명 :

  # 如果你在全局名称空间引用一个变量，先从全局名称空间引用，全局名称空间如果没有，才会向内置名称空间引用。
  input = 666
  print(input) # 666
  
  # 如果你在局部名称空间引用一个变量，先从局部名称空间引用，局部名称空间如果没有，才会向全局名称空间引用，全局名称空间在没有，就会向内置名称空间引用。
  input = 666
  print(input) # 666
  input = 666
  def func():
      input = 111
      print(input) # 111
  func()

  다음의 예는 비교적 명확하다

  # 取值顺序（就近原则） 单向不可逆
  # LEGB原则
  input = 'Dylan'
  
  def func():
      input = 'xiaoyu'
      print(input)    # xiaoyu
  
  func()
  
  # （从局部找时）局部名称空间  ---> 全局名称空间  --->  内置名称名称空间
  
  input = 'Dylan'
  def func():
      print(input)    # Dylan
  
  func()
  print(input)    # Dylan
  

  따라서, 적재 공간 순서의 순서의 값이 반전되어, 큰 기준 범위에서 작은 근방의 원리 및 범위를 만족시킬 정도의 값이 점진적으로 층층이.

• 범위

  범위 전역 및 로컬 범위 내로 볼의 범위의 발효에 따른 범위 인

  • 글로벌 범위 : (⾏ 실행에 의해 위에서 아래로 추적) 내장 네임 스페이스와 전체 파일 글로벌 네임 스페이스 어디서나 사용할 수 있습니다 포함되어 있습니다.

  • 로컬 범위 : 함수 내에서 사용될 수있다.

  도메인 네임 스페이스를위한 사용 :

  1. 전역 범위 : 글로벌 네임 스페이스 + 내장 네임 스페이스

  2. 로컬 도메인으로 : 지역 공간

• 내장 기능 전역 (), 지역 주민 ()

  두 개의 내장 함수 그러나, 그들은 직접 범위의 범위를 이해하는 데 도움이, 내용 범위를 반영 할 수있는 말을 여기 바로 이곳에있다.

  • 전역는 ()의 대응 관계를 사전 형태 전역 모든 변수를 반환.

  • ()는 주민 : 변수의 형태로 현재의 범위의 대응 관계를 사전에 돌려.

  여기에, 하나는 현재 범위는, 우리는 코드 검증을 사용하여 명확하게 할 필요가 글로벌 범위입니다 :

  # 在全局作用域下打印，则他们获取的都是全局作用域的所有的内容。
  a = 2
  b = 3
  print(globals())
  print(locals())
  '''
  {'__name__': '__main__', '__doc__': None, '__package__': None,
  '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001806E50C0B8>, 
  '__spec__': None, '__annotations__': {},
  '__builtins__': <module 'builtins' (built-in)>, 
  '__file__': 'D:/lnh.python/py project/teaching_show/day09~day15/function.py',
  '__cached__': None, 'a': 2, 'b': 3}
  '''
  
  # 在局部作用域中打印。
  a = 2
  b = 3
  def foo():
      c = 3
      print(globals()) # 和上面一样，还是全局作用域的内容
      print(locals()) # {'c': 3}
  foo()

고차 함수 (중첩 함수)

사실, 우리는 우리가 중첩 된 목록을 이야기하기 전에, 중첩 된 목록이있는 목록의 목록, 그래서 정의, 기능에 의해 ...... 그 목록이 나열 할 수있다, 중첩 된 용어에 낯선 사람을 본 적이 둥지는 기능, 기능입니다.

아무 기능이없는 경우 긴 대회로 함수 이름 + ()가 호출 될 함수가 호출되지 않는, 즉도 이해 이해 : 함수의 요점을 이해 중첩을 재생합니다. 그럼 우리가 예를 연습 :

# 例1：
def func1():
    print('in func1')   # 1
    print(3)    # 2
def func2():
    print('in func2')   # 4
    print(4)    # 5
func1()
print(1)    # 3
func2()
print(2)    # 6

# 例2：
def func1():
    print('in func1')   # 3
    print(3)    # 4
def func2():
    print('in func2')   # 2
    func1()
    print(4)    # 5
print(1)    # 1
func2()
print(2)    # 6
# 例3：
def fun2(): 
    print(2)    # 2
    def fun3(): 
        print(6)    # 4
    print(4)    # 3
    fun3() 
    print(8)    # 5
print(3)    # 1
fun2()
print(5)    # 6