Functions
지금까지 Python 코드 예는 모두 작은 조각이었습니다. 이러한 기능은 소규모 작업에 유용하지만 항상 조각을 다시 입력하려는 사람은 없습니다. 우리는 더 큰 코드를 관리할 수 있는 조각으로 정리할 수 있는 방법이 필요합니다.
코드 재사용을 위한 첫 번째 단계는 다른 모든 코드와 별도로 명명된 코드 조각입니다. 함수는 임의의 숫자와 유형의 입력 매개 변수를 사용하고 임의의 숫자와 유형의 출력 결과를 반환할 수 있습니다.
기능을 사용하여 두 가지 작업을 수행할 수 있습니다.
• Defineit • Callit
Python 함수를 정의하려면 함수에 대한 입력 매개 변수를 포함하는 함수 이름인 def를 입력하고 마지막으로 콜론(:)을 입력합니다. 함수 이름은 변수 이름과 동일한 규칙을 가집니다(문자 또는 _로 시작하고 문자, 숫자 또는 _만 포함해야 함).
한 번에 한 단계씩 진행하고 먼저 파라미터가 없는 함수를 정의하고 호출합니다. 가장 간단한 Python 함수는 다음과 같습니다.
>>> def do_nothing(): ... pass
이러한 매개변수가 없는 함수의 경우에도 정의에 괄호와 콜론이 필요합니다. if 문장으로 코드를 들여쓰는 것처럼 다음 줄을 들여써야 합니다. Python은 이 기능이 아무것도 하지 않는다는 것을 보여주기 위해 패스 문이 필요합니다. 이 페이지는 더 이상 표시되지 않더라도 일부러 비워둔 페이지와 같습니다.
이름과 괄호를 입력하기만 하면 이 기능을 호출할 수 있습니다. 광고된 대로 작동하며 제대로 작동하는 것은 없습니다.
>>> do_nothing()
>>>
이제 매개 변수는 없지만 단어 하나를 인쇄하는 다른 함수를 정의하여 호출하겠습니다.
>>> def make_a_sound(): ... print('quack') ...
>>> make_a_sound() quack
make_a_sound() 함수를 호출했을 때, Python은 정의 내에서 코드를 실행했습니다. 이 경우, 한 단어를 인쇄하고 메인 프로그램으로 돌아갑니다.
매개 변수는 없지만 값을 반환하는 함수를 시도해 보겠습니다.
>>> def agree(): ... return True ...
다음과 같은 경우 이 함수를 호출하고 반환된 값을 테스트할 수 있습니다.
>>> if agree():
... print('Splendid!')
... else:
... print('That was unexpected.') ...
Splendid!
당신은 방금 큰 발걸음을 내디뎠어요. if 및 loop과 같은 테스트와 함수의 조합은 이전에 할 수 없었던 것을 가능하게 합니다.
이쯤에서 괄호 사이에 무언가를 넣어야 할 때입니다. echo() 함수를 anything 매개 변수 하나로 정의하겠습니다. 반환 문을 사용하여 호출자에게 다음 사이의 공백을 사용하여 값을 두 번 보냅니다.
>>> def echo(anything):
... return anything + ' ' + anything ...
>>>
이제 'Rumplestiltskin' 문자열로 echo()를 호출하겠습니다.
>>> echo('Rumplestiltskin')
'Rumplestiltskin Rumplestiltskin'
함수를 호출할 때 함수에 전달되는 값을 인수라고 합니다. 인수를 사용하여 함수를 호출하면 해당 인수 값이 함수 내부의 해당 매개 변수에 복사됩니다. 이전 예에서는 echo() 함수를 'Rumplestiltskin' 인수 문자열로 호출했습니다. 이 값은 echo() 내에서 매개 변수에 복사된 다음 호출자에게 (이 경우 공백이 두 배로) 반환되었습니다.
이러한 기능 예는 매우 기초적이었다. 입력 인수를 사용하여 실제로 수행하는 함수를 작성해 보겠습니다. 색상에 대한 코멘트가 있는 이전 코드 조각을 수정하겠습니다. 주석이라고 하고 color라는 입력 문자열 매개변수를 사용하도록 합니다. 문자열 설명을 호출자에게 반환하고 호출자는 문자열로 수행할 작업을 결정합니다.
>>> def commentary(color):
...
...
...
...
...
...
... else:
... return "I've never heard of the color " + color + "." ...
>>>
문자열 인수가 'blue'인 함수 주석()을 호출합니다.
>>> comment = commentary('blue')
이 기능은 다음을 수행합니다.
• 함수의 내부 색상 매개변수에 '파란색' 값을 할당합니다
• if-elife-elife 논리 체인을 통해 실행
• 문자열을 반환합니다.
• 변수 설명에 문자열을 할당합니다. 무엇을 다시 얻을 수 있습니까?
>>> print(comment)
I've never heard of the color blue.
함수는 모든 유형의 입력 인수(0 포함)를 수에 제한 없이 사용할 수 있습니다. 모든 유형의 출력 결과(0 포함)를 원하는 수만큼 반환할 수 있습니다. 함수가 명시적으로 호출되지 않으면 호출자는 없음 결과를 얻습니다.
>>> print(do_nothing()) None
None Is Useful
None은 할 말이 없을 때 자리를 유지하는 특별한 Python 값입니다. 부울 값으로 평가하면 거짓으로 표시되지만 부울 값 False와 동일하지는 않습니다. 예는 다음과 같습니다.
>>> thing = None
>>> if thing:
... print("It's some thing") ... else:
... print("It's no thing") ...
It's no thing
없음과 부울 False 값을 구분하려면 Python의 is 연산자를 사용합니다.
>>> if thing is None:
... print("It's nothing") ... else:
... print("It's something") ...
It's nothing
이것은 미묘한 구별처럼 보이지만 Python에서는 중요합니다. 결측값과 빈 값을 구분하려면 없음을 입력해야 합니다. 0 값 정수 또는 부동 소수, 빈 문자열(''), 목록([]), 튜플( (, )), 사전({}) 및 집합( )은 모두 False이지만 없음과 같지는 않습니다.
해당 인수가 없음인지 여부를 인쇄하는 빠른 함수를 작성하겠습니다.
>>> is_none(None)
It's None
>>> is_none(True)
It's True
>>> is_none(False)
It's False
>>> is_none(0)
It's False
>>> is_none(0.0)
It's False
>>> is_none(())
It's False
>>> is_none([])
It's False
>>> is_none({})
It's False
>>> is_none(set())
It's False
위치 인수
Python은 많은 언어에 비해 매우 유연한 방식으로 함수 인수를 처리합니다. 가장 친숙한 인수 유형은 위치 인수이며, 위치 인수의 값은 순서대로 해당 매개 변수에 복사됩니다.
이 함수는 위치 입력 인수를 사용하여 사전을 만들고 다음을 반환합니다.
>>> def menu(wine, entree, dessert):
... return {'wine': wine, 'entree': entree, 'dessert': dessert} ...
>>> menu('chardonnay', 'chicken', 'cake')
{'dessert': 'cake', 'wine': 'chardonnay', 'entree': 'chicken'}
매우 흔하지만, 위치 논쟁의 단점은 각 위치의 의미를 다시 기억할 필요가 있다는 것입니다. 만약 우리가 잊고 와인과 함께 메뉴()를 첫 번째가 아닌 마지막 논쟁으로 부른다면, 식사는 매우 달라질 것이다.
>>> menu('beef', 'bagel', 'bordeaux')
{'dessert': 'bordeaux', 'wine': 'beef', 'entree': 'bagel'}
키워드 인수
위치 인수의 혼동을 방지하기 위해 함수의 정의와 다른 순서로 인수를 해당 매개 변수의 이름으로 지정할 수 있습니다.
>>> menu(entree='beef', dessert='bagel', wine='bordeaux')
{'dessert': 'bagel', 'wine': 'bordeaux', 'entree': 'beef'}
위치 인수와 키워드 인수를 혼합할 수 있습니다. 와인을 먼저 지정하고, 메뉴와 디저트에 키워드 인수를 사용합니다.
>>> menu('frontenac', dessert='flan', entree='fish')
{'entree': 'fish', 'dessert': 'flan', 'wine': 'frontenac'}
위치 인수와 키워드 인수가 모두 포함된 함수를 호출할 경우 위치 인수가 먼저 와야 합니다.
기본 매개변수 값 지정
매개변수에 대한 기본값을 지정할 수 있습니다. 호출자가 해당 인수를 제공하지 않는 경우 기본값이 사용됩니다. 이 싱겁게 들리는 기능은 실제로 매우 유용할 수 있습니다. 이전 예제를 사용하여:
>>> def menu(wine, entree, dessert='pudding'):
... return {'wine': wine, 'entree': entree, 'dessert': dessert}
이번에는 디저트 인수 없이 메뉴()를 호출해 보십시오.
>>> menu('chardonnay', 'chicken')
{'dessert': 'pudding', 'wine': 'chardonnay', 'entree': 'chicken'}
인수를 제공하면 기본값 대신 사용됩니다.
>>> menu('dunkelfelder', 'duck', 'doughnut')
{'dessert': 'doughnut', 'wine': 'dunkelfelder', 'entree': 'duck'}
기본 인수 값은 함수를 실행할 때가 아니라 함수를 정의할 때 계산됩니다. 새로운 Python 프로그래머의 일반적인 오류는 목록이나 사전과 같은 가변 데이터 유형을 기본 인수로 사용하는 것입니다.
다음 테스트에서 buggy() 함수는 매번 빈 결과 목록과 함께 실행되고 arg 인수를 추가한 다음 단일 항목 목록을 인쇄해야 합니다. 하지만 버그가 있습니다. 처음 호출했을 때만 비어 있습니다. 두 번째로, 결과는 여전히 이전 통화의 항목 하나를 가지고 있습니다.
>>> def buggy(arg, result=[]): ... result.append(arg) ... print(result)
...
>>> buggy('a')
['a']
>>> buggy('b') # expect ['b'] ['a', 'b']
다음과 같이 작성되었더라면 작동했을 것입니다.
>>> def works(arg):
... result = []
... result.append(arg) ... return result
...
>>> works('a')
['a']
>>> works('b')
['b']
수정 사항은 다른 정보를 전달하여 첫 번째 통화를 나타내는 것입니다.
>>> def nonbuggy(arg, result=None): ... if result is None:
... result = []
... result.append(arg)
... print(result) ...
>>> nonbuggy('a') ['a']
>>> nonbuggy('b')
['b']
*를 사용하여 위치 인수 수집
C 또는 C++에서 프로그래밍한 경우 Python 프로그램의 별표(*)가 포인터와 관련이 있다고 가정할 수 있습니다. 아니요, Python은 포인터가 없습니다.
함수 내부에서 매개변수와 함께 사용할 경우 별표는 변수 개수의 위치 인수를 매개변수 값의 튜플로 그룹화합니다. 다음 예에서 args는 print_args() 함수에 전달된 인수에서 비롯된 매개 변수 튜플입니다.
>>> def print_args(*args):
... print('Positional argument tuple:', args) ...
인수를 사용하지 않고 호출하면 *args에서 아무 것도 얻을 수 없습니다.
>>> print_args()
Positional argument tuple: ()
무엇을 주든 인수 튜플로 인쇄됩니다.
>>> print_args(3, 2, 1, 'wait!', 'uh...')
Positional argument tuple: (3, 2, 1, 'wait!', 'uh...')
이는 변수 개수의 인수를 허용하는 print()와 같은 함수를 작성할 때 유용합니다. 함수에 필요한 위치 인수도 있는 경우 *args는 끝에 가서 나머지 항목을 모두 잡습니다.
>>> def print_more(required1, required2, *args): ... print('Need this one:', required1)
- ... print('Need this one too:', required2)
- ... print('All the rest:', args)
...
>>> print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax') Need this one: cap
Need this one too: gloves - All the rest: ('scarf', 'monocle', 'mustache wax')
*를 사용할 때 tuple 매개 변수 args를 호출할 필요는 없지만 Python에서는 일반적인 관용어입니다.
**를 사용하여 키워드 인수 수집
두 개의 별표(**)를 사용하여 키워드 인수를 사전으로 그룹화할 수 있습니다. 여기서 인수 이름은 키이고 값은 해당 사전 값입니다. 다음은 키워드 인수를 인쇄하는 print_kwargs() 함수를 정의하는 예제입니다.
- >>> def print_kwargs(**kwargs):
- ... print('Keyword arguments:', kwargs) ...
이제 키워드 인수를 사용하여 호출해 보십시오.
>>> print_kwargs(wine='merlot', entree='mutton', dessert='macaroon')
Keyword arguments: {'dessert': 'macaroon', 'wine': 'merlot', 'entree': 'mutton'}
함수에 들어 있는 콰르그스는 사전입니다.
위치 매개변수를 *args 및 **kwargs와 혼합할 경우 해당 순서에 따라 발생해야 합니다. args와 마찬가지로 이 키워드 매개 변수를 kwargs라고 할 필요는 없지만 일반적으로 사용됩니다.
문서 문자열
Python의 Zen은 가독성이 중요하다고 말합니다. 함수 본문 시작 부분에 문자열을 포함시켜 설명서를 함수 정의에 첨부할 수 있습니다. 다음은 함수의 docstring입니다.
>>> def echo(anything):
- ... 'echo returns its input argument'
- ... return anything
원하는 경우 다음과 같이 문서 문자열을 상당히 길게 만들고 리치 형식을 추가할 수도 있습니다.
- def print_if_true(thing, check): '''
Prints the first argument if a second argument is true. - The operation is:
1. Check whether the *second* argument is true.
2. If it is, print the *first* argument.
'''
if check: print(thing)
함수의 docstring을 인쇄하려면 Python help() 함수를 호출합니다. 함수의 이름을 전달하여 멋진 형식의 docstring과 함께 인수 목록을 가져옵니다.
>>> help(echo)
Help on function echo in module __main__:
echo(anything)
echo returns its input argument
형식을 사용하지 않고 원시 문서 문자열만 보려면:
>>> print(echo.__doc__)
echo returns its input argument
이상하게 생긴 __doc__은(는) 함수 내에서 변수로서 docstring의 내부 이름입니다. 103페이지의 "이름에서 _ 및 __의 사용"은 이 모든 밑줄 뒤에 숨겨진 이유를 설명합니다.
Functions Are First-Class Citizens
파이썬의 모토를 언급했는데, 모든 것은 객체입니다. 여기에는 숫자, 문자열, 튜플, 목록, 사전 및 함수가 포함됩니다. 함수는 Python의 일급 시민권입니다. 변수를 변수에 할당하고 다른 함수에 인수로 사용하고 함수에서 반환할 수 있습니다. 이를 통해 다른 많은 언어로 수행하기가 어려운 Python에서 몇 가지 작업을 수행할 수 있습니다.
이를 테스트하기 위해 인수 없이 42만 인쇄하는 answer()라는 간단한 함수를 정의하겠습니다.
>>> def answer(): ... print(42)
이 기능을 실행하면 다음과 같은 결과를 얻을 수 있습니다.
>>> answer()
42
이제 run_something이라는 다른 함수를 정의하겠습니다. 실행할 함수인 func라는 인수가 하나 있습니다. 일단 안으로 들어가면, 기능을 호출할 뿐입니다.
>>> def run_something(func): ... func()
run_something()에 대한 답변을 전달하면 다른 thing와 마찬가지로 함수를 데이터로 사용합니다.
>>> run_something(answer)
42
답변()이 아닌 답변을 전달했습니다. Python에서 이 괄호는 이 함수를 호출하는 것을 의미합니다. 괄호 없이 Python은 다른 객체처럼 함수를 처리합니다. 다른 모든 Python과 마찬가지로 Python도 객체이기 때문입니다.
>>> type(run_something) <class 'function'>
인수를 사용하여 함수를 실행해 보겠습니다. arg1과 arg2 두 숫자 인수의 합을 인쇄하는 add_args() 함수를 정의합니다.
>>> def add_args(arg1, arg2): ... print(arg1 + arg2)
add_args()는 무엇입니까?
>>> type(add_args)
<class 'function'>
이 시점에서 run_something_with_args()라는 함수를 정의하자.
인수:
• 기능—실행 기능
• arg1—펑크의 첫 번째 인수
• arg2—함수에 대한 두 번째 인수
>>> def run_something_with_args(func, arg1, arg2): ... func(arg1, arg2)
run_something_with_args()를 호출할 때 호출자가 전달한 함수는 func 매개 변수에 할당되고 arg1과 arg2는 인수 목록에 이어지는 값을 가져옵니다. 그런 다음 괄호가 Python에게 명령했기 때문에 실행 중인 func(arg1, arg2)는 이러한 인수를 사용하여 해당 함수를 실행합니다.
function name add_args와 un_something_with_args() 인수 5와 9를 전달하여 테스트해 봅시다.
>>> run_something_with_args(add_args, 5, 9)
14
run_something_with_args() 함수 내에서 add_args 함수는 func 매개 변수에 할당되었고, 5는 arg1에 할당되었으며, 9는 arg2에 할당되었습니다. 이 작업은 실행되었습니다.
add_args(5, 9)
이를 *args 및 **kwargs 기법과 결합할 수 있습니다.
임의의 수의 위치 인수를 사용하고 합() 함수를 사용하여 합계를 계산한 다음 합계를 반환하는 검정 함수를 정의하겠습니다.
>>> def sum_args(*args): ... return sum(args)
나는 이전에 합계를 언급한 적이 없다. 이 함수는 기본 제공 Python 함수로, int 또는 float 인수의 값 합계를 계산합니다.
함수와 이 함수에 전달하기 위한 임의의 수의 위치 인수를 사용하는 새 함수 run_with_positional_args()를 정의합니다.
>>> def run_with_positional_args(func, *args): ... return func(*args)
자, 어서 불러봐:
>>> run_with_positional_args(sum_args, 1, 2, 3, 4)
10
Inner Functions
다른 함수 내에서 함수를 정의할 수 있습니다.
>>> def outer(a, b):
...
...
...
...
>>>
>>> outer(4, 7)
11
내부 기능은 루프 또는 코드 중복을 방지하기 위해 다른 기능 내에서 복잡한 작업을 두 번 이상 수행할 때 유용합니다. 문자열 예제의 경우 이 내부 함수는 인수에 일부 텍스트를 추가합니다.
