유창 한 Python 제5 장, 1 등 함수 노트 (미 완성, 1 장 부터 볼 준비).

8866 단어
Python 의 또 다른 이름 은 1 등 대상 이 라 고 합 니 다. 다음 조건 을 만족 시 키 는 프로그램 실체 입 니 다.
1 、 실행 중 생 성
2. 변수 나 데이터 구조 에 할당 할 수 있 는 요소
3. 매개 변수 로 함수 에 전달 할 수 있 습 니 다.
4. 함수 로 서 의 반환 결과
그래서 Python 에 서 는 정수, 문자열, 사전 과 함수 가 모두 1 등 대상 입 니 다.
5.1 함 수 를 대상 으로 한다.
함 수 를 대상 으로 간단 한 를 통 해doc__함수 설명 을 출력 할 수 있 습 니 다.
In [55]: def demo(a,b): 
    ...:     '''  a,b''' 
    ...:     return a,b 
    ...:                                                                                                                

In [56]: demo.__doc__                                                                                                   
Out[56]: '  a,b'

In [57]:  

 고급 함 수 를 통 해 함 수 를 전달 하 다.
def fact(n):
    '''returns n!'''
    return 1 if n < 2 else n * fact(n - 1)

print(list(map(fact, range(10))))

 
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]

 fact 는 전달 되 는 함수 입 니 다.
5.2 고급 함수
함 수 를 매개 변수 로 받 아들 이거 나 함 수 를 결과 로 되 돌려 주 는 함 수 는 고급 함수 (hight - order function) 입 니 다.
map, filter, reduce, sorted 를 포함 하여 모두 고급 이 며, sorted 의 key 는 함 수 를 받 을 수 있 습 니 다.
이 정의 에 따 르 면 우리 의 패 킷 함수, 장식 기 함수, 모두 고급 함수 라 고 할 수 있 습 니 다.
 
map, filter, reduce 의 현대 교체 품
map 와 filter 는 목록 생 성 식 으로 사용 되 기 때문에 기본적으로 사용 해 야 할 부분 이 많 습 니 다. 목록 생 성 식 으로 사용 할 수 있 습 니 다.
 
def fact(n):
    '''returns n!'''
    return 1 if n < 2 else n * fact(n - 1)

'''
       ,                   。
  ,map,filter,reduce,sorted(  key     )
'''

print(fact(10))

print(list(map(fact, range(10))))   # map      fact

print([fact(i) for i in range(10)])   #        ,           fact,          。

print(list(map(fact, filter(lambda n : n % 2, range(10)))))   #  map              filter   ,    2  

# filter      :         。
def condition(n):
    if n % 2 != 0:
        return n
print(list(map(fact, filter(condition, range(10)))))

print([fact(i) for i in range(10) if i % 2])     #                ,       ,      。
#      if i % 2    ! % 2   0,        。              ,     ,         。
print([fact(i) for i in range(10) if i % 2 !=0])   #     ,       。

 
 
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/   /    .py
3628800
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]
[1, 6, 120, 5040, 362880]
[1, 6, 120, 5040, 362880]
[1, 6, 120, 5040, 362880]

Process finished with exit code 0

 reduce 는 현재 매우 적 게 사용 되 고 있 으 며, 일반적으로 구 화 위 에 쓰 인 다.
from functools import reduce
from operator import add

def s_add(x, y):
    return x + y

print(reduce(add, range(100)))
print(reduce(s_add, range(100)))
print(sum(range(100)))

 
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/   /t5.2.py
4950
4950
4950

Process finished with exit code 0

 귀 약 함수 all, any 는 아주 좋 은 함수 입 니 다.
all(iterable)  안에 있 는 교체 가능 대상 은 모두 진실 으로 돌아간다.(약간 and 같 아 요.)
any (iterable) 하 나 는 진짜 로 돌아간다.(약간 or)
a1 = '1232434'
a2 = [1, 2, 3, 0]
a3 = {'name': 'sidian', 'age': None}
a4 = (None, 9, 8)

print(a1, all(a1), any(a1))
print(a2, all(a2), any(a2))
print(a3, all(a3), any(a3))
print(a4, all(a4), any(a4))

 
1232434 True True
[1, 2, 3, 0] False True
{'name': 'sidian', 'age': None} True True
(None, 9, 8) False True

 
5.3 익명 함수
lambda 는 Python 표현 식 에서 익명 함 수 를 만 듭 니 다.그러나 Python 의 간단 한 문법 은 lambda 함수 의 정의 문 제 를 순수 표현 식 만 사용 할 수 있 도록 제한 합 니 다.다시 말 하면 lambda 함수 의 정의 체 에 값 을 부여 할 수 없고 while 와 try 등 Python 문 구 를 사용 할 수 없습니다.
lambda (init: return), lambda 함 수 는 분 호 를 통 해 분리 되 고 앞 에는 입력 매개 변수 이 며 뒤 에는 반환 매개 변수 입 니 다.
lambda 문법 은 문법 사탕 으로 def 와 같이 호출 가능 한 함수 대상 을 만 듭 니 다.
 
5.4 호출 가능 대상
호출 가능 한 대상 은 () 의 대상 (안에 call 방법 이 있 음) 으로 호출 가능 한 대상 인지, Python 데이터 모델 에는 7 가지 호출 가능 한 대상 이 있 습 니 다.
1. 사용자 정의 함수
예 를 들 어 def 나 lambda 를 사용 하여 만 든 대상 입 니 다.
2. 내장 함수
C 언어 로 표 시 된 함 수 를 사용 합 니 다. 예 를 들 어 len 이나 time. strftime.
3. 내장 방법
C 언어 를 사용 하여 실현 하 는 방법, 예 를 들 어 dict. get
4. 방법
클래스 의 실체 에서 정 의 된 함수
5 류
실례 화 류 의 사용 에 있어 서 먼저 호출 된 것 은 이다call__,그리고 호출new__창설 대상, 마지막init__대상 을 초기 화 합 니 다.
6. 클래스 의 인 스 턴 스
클래스 에서 정의call__,그러면 실례 는 호출 대상 이 될 수 있다.
7. 생 성기
생 성기 함 수 를 호출 하면 생 성기 대상 을 되 돌 릴 수 있 습 니 다.
 
5.5 사용자 가 정의 하 는 호출 가능 한 형식 입 니 다.
클래스 를 통 해 정의 함수call__
import random

class BingCage:

    def __init__(self, items):
        self._items = list(items)     #        
        random.shuffle(self._items)

    def pick(self):
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('pick from empty BingoCage')

    def __call__(self, *args, **kwargs):     #      call  ,      
        return self.pick()

bingo = BingCage('abc')
for i in range(5):
    try:
        print(bingo.pick())
    except LookupError as e:
        print(e)

 
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/   /t_5.5.py
b
c
a
pick from empty BingoCage
pick from empty BingoCage

Process finished with exit code 0

 
5.6 함수 내성
함수 에는 많은 속성 이 있 습 니 다. 우 리 는 dir 를 통 해 봅 니 다.
dir(lambda x : x[2])                                                                                           
Out[57]: 
['__annotations__',
 '__call__',
 '__class__',
 '__closure__',
 '__code__',
 '__defaults__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__get__',
 '__getattribute__',
 '__globals__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__kwdefaults__',
 '__le__',
 '__lt__',
 '__module__',
 '__name__',
 '__ne__',
 '__new__',
 '__qualname__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__']

 먼저 하 나 를 말씀 드 리 겠 습 니 다. 함수 대상 은 가 있 습 니 다.dict__속성, 그래서. 또는 setattr 를 통 해 속성 대 가 를 할 수 있 습 니 다. 이것 은 저 는 예전 에 정말 몰 랐 습 니 다.(그러나 함수 대상 에 대해 속성 대 가 를 하 는 경 우 는 드물다)
def demo(): 
    ...:     ... 
    ...:                                                                                                                

In [63]: demo.abc = 'abc'                                                                                               

In [64]: demo.__dict__                                                                                                  
Out[64]: {'abc': 'abc'}

In [65]: setattr(demo,'name','sidian')                                                                                  

In [66]: demo.name                                                                                                      
Out[66]: 'sidian'

In [67]: demo.__dict__                                                                                                  
Out[67]: {'abc': 'abc', 'name': 'sidian'}

In [68]:                                                                                                                

 다음은 함수 만 있 지만 대상 에 없 는 속성 을 보 여 줍 니 다. 클래스 와 비교 해 보 겠 습 니 다.
class C:
    ...

def func():
    ...

c = C()

print(set(dir(C)) - set(dir(func)))
print(set(dir(func)) - set(dir(C)))
print(set(dir(c)) - set(dir(func)))
print(set(dir(func)) - set(dir(c)))

 
/usr/local/bin/python3.7 /Users/shijianzhong/study/Fluent_Python/   /t_5.6.py
{'__weakref__'}
{'__annotations__', '__get__', '__globals__', '__call__', '__name__', '__qualname__', '__code__', '__kwdefaults__', '__defaults__', '__closure__'}
{'__weakref__'}
{'__annotations__', '__get__', '__globals__', '__call__', '__name__', '__qualname__', '__code__', '__kwdefaults__', '__defaults__', '__closure__'}
Hello sidian

Process finished with exit code 0

 그 중에서 알 수 있 듯 이 대상 이나 유추 함수 가 하나의 속성weakref__,내 가 몇 가지 자 료 를 조사해 보 니 쓰레기 회수 와 관련 된 것 같 아서 구체 적 인 자 료 는 매우 적다.
https://stackoverflow.com/questions/36787603/what-exactly-is-weakref-in-python이 링크 에는 영어 의 답안 이 좀 있다.
그러나 함수 가 대상 보다 많은 속성 을 가지 고 있 습 니 다.

좋은 웹페이지 즐겨찾기