Functions / 함수

  • Use a function when you need to do the same thing many times.
    같은 일을 여러 번 해야 할 때 함수를 사용하십시오.
  • A function is a block of code that only runs when it is called.
    함수는 호출될 때만 실행되는 코드 블록입니다.
  • You can also store functions in a separate file called a module.
    함수를 모듈이라는 별도의 파일에 저장할 수도 있습니다.

8.1 Defining a Function / 함수 정의하기

  • Use def to define a function.
    함수를 정의하려면 def를 사용하십시오.
  • The parentheses hold the arguments, or information, that the function needs to do its job.
    괄호에는 함수가 작업을 수행하는 데 필요한 인수 또는 정보가 포함됩니다.
  • Call the function by using its name followed by parentheses.
    괄호 뒤에 이름을 사용하여 함수를 호출합니다.
# 8.1_functions.py
def greet_user():
    """Display a simple greeting."""
    print("Hello!")

greet_user()
  • Use a docstring (""") in the first line of a function to describe what the function does.
    함수가 무엇을 하는지 설명하려면 함수의 첫 번째 줄에 docstring(""")을 사용하십시오.
  • You can give information to a function by using an argument inside the parentheses.
    괄호 안에 인수를 사용하여 함수에 정보를 제공할 수 있습니다.
# 8.1_functions.py
def greet_user(username):
    """Display a simple greeting."""
    print(f"Hello, {username.title()}!")

greet_user('jesse')
  • In the above, username is a parameter, and 'jesse' is an argument.
    위의 username은 매개변수이고 'jesse'는 인수입니다.
  • You can use as many parameters as you need.
    필요한 만큼 매개변수를 사용할 수 있습니다.

8.2 Function Parameters and Arguments / 함수 매개변수 및 인수

# 8.2_functions_args.py
def describe_pet(animal_type, pet_name):
    """Display information about a pet."""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet('hamster', 'harry')
describe_pet('dog', 'willie')
  • Positional arguments, like those above, must be in the same order as the parameters.
    위와 같은 위치 인수는 매개변수와 동일한 순서여야 합니다.
  • Keyword arguments are name-value pairs that don’t depend on correct order.
    키워드 인수는 올바른 순서에 의존하지 않는 이름-값 쌍입니다.
  • Keyword arguments are useful to avoid confusion.
    키워드 인수는 혼란을 피하기 위해 유용합니다.
# 8.2_functions_args.py
def describe_pet(animal_type, pet_name):
    """Display information about a pet."""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='willie', animal_type='dog')

Default Values / 기본값

  • You can use default values for parameters.
    매개변수에 기본값을 사용할 수 있습니다.
  • When you use default values, any parameter with a default value must be listed after all parameters that don’t have default values.
    기본값을 사용할 때 기본값이 있는 매개변수는 기본값이 없는 모든 매개변수 뒤에 나열되어야 합니다.
# 8.2_functions_args.py
def describe_pet(pet_name, animal_type='dog'):
    """Display information about a pet."""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet(pet_name='willie')
describe_pet('willie')
describe_pet(pet_name='harry', animal_type='hamster')
describe_pet('harry', 'hamster')
  • Don’t be surprised if you encounter errors about unmatched arguments.
    일치하지 않는 인수에 대한 오류가 발생하면 놀랍지 마십시오.
  • Python is helpful and tells you exactly what you need to fix.
    Python은 도움이 되어 정확히 수정해야 할 내용을 알려줍니다.

8.3 Return Values / 반환 값

  • A function can return a value or a set of values.
    함수는 값을 반환하거나 일련의 값을 반환할 수 있습니다.
  • Remember to provide a variable where the returned value can be stored.
    반환된 값을 저장할 변수를 제공하는 것을 잊지 마십시오.
# 8.3_functions_return.py
def get_formatted_name(first_name, last_name):
    """Return a full name, neatly formatted."""
    full_name = f"{first_name} {last_name}"
    return full_name.title()

musician = get_formatted_name('jimi', 'hendrix')
print(musician)

Optional Arguments / 선택적 인수

  • Sometimes, you may add an optional argument to a function.
    때로는 함수에 선택적 인수를 추가할 수 있습니다.
  • You can use an empty string as a default value.
    빈 문자열을 기본값으로 사용할 수 있습니다.
# 8.3_functions_return.py
def get_formatted_name(first_name, last_name, middle_name=''):
    """Return a full name, neatly formatted."""
    if middle_name:
        full_name = f"{first_name} {middle_name} {last_name}"
    else:
        full_name = f"{first_name} {last_name}"
    return full_name.title()

musician = get_formatted_name('jimi', 'hendrix')
print(musician)

musician = get_formatted_name('john', 'hooker', 'lee')
print(musician)
  • You can return any kind of value you need, including more complicated data structures like lists and dictionaries.
    리스트와 사전과 같은 더 복잡한 데이터 구조를 포함하여 필요한 모든 종류의 값을 반환할 수 있습니다.
  • You can also use None as a default value.
    None을 기본값으로 사용할 수도 있습니다.
# 8.3_functions_return.py
def build_person(first_name, last_name, age=None):
    """Return a dictionary of information about a person."""
    person = {'first': first_name, 'last': last_name}
    if age:
        person['age'] = age
    return person

musician = build_person('jimi', 'hendrix', 27)
print(musician)

musician = build_person('janis', 'joplin')
print(musician)

Using a while loop / while 루프 사용하기

  • You can use a while loop to let the user enter as much input as they want.
    사용자가 원하는 만큼 입력할 수 있도록 while 루프를 사용할 수 있습니다.
  • But don’t forget to provide a way to exit the loop!
    하지만 루프를 종료할 수 있는 방법을 제공하는 것을 잊지 마십시오!
# 8.4_functions_while.py
def get_formatted_name(first_name, last_name):
    """Return a full name, neatly formatted."""
    full_name = f"{first_name} {last_name}"
    return full_name.title()

while True:
    print("\nPlease tell me your name:")
    print("(enter 'q' at any time to quit)")

    f_name = input("First name: ")
    if f_name == 'q':
        break

    l_name = input("Last name: ")
    if l_name == 'q':
        break

    formatted_name = get_formatted_name(f_name, l_name)
    print(f"\nHello, {formatted_name}!")

8.4 Passing a List / 리스트 전달하기

  • If you pass a list to a function, the function can modify the list.
    함수에 리스트를 전달하면 함수가 리스트를 수정할 수 있습니다.
  • Any changes made to the list inside the function’s body are permanent.
    함수 본문에서 리스트를 수정하면 변경 사항이 영구적으로 유지됩니다.
# 8.5_functions_lists.py
def print_models(unprinted_designs, completed_models):
    """
    Simulate printing each design, until none are left.
    Move each design to completed_models after printing.
    """
    while unprinted_designs:
        current_design = unprinted_designs.pop()

        # Simulate creating a 3D print from the design.
        print(f"Printing model: {current_design}")
        completed_models.append(current_design)

def show_completed_models(completed_models):
    """Show all the models that were printed."""
    print("\nThe following models have been printed:")
    for completed_model in completed_models:
        print(completed_model)

unprinted_designs = ['phone case', 'robot pendant', 'dodecahedron']
completed_models = []

print_models(unprinted_designs, completed_models)
show_completed_models(completed_models)
  • As shown above, every function should have one specific job.
    위에서 보듯이 모든 함수는 하나의 특정 작업을 수행해야 합니다.
  • But sometimes, you need to work with a copy of a list instead of the original.
    하지만 때로는 원본 대신 리스트의 사본을 사용해야 합니다.
  • This will leave the original list unchanged.
    이렇게 하면 원래 리스트가 변경되지 않습니다.
# 8.5_functions_lists.py
print_models(unprinted_designs[:], completed_models)

8.5 Arbitrary Numbers of Arguments / 임의의 수의 인수

  • When you don’t know how many arguments a function needs, add * before the parameter name.
    함수가 몇 개의 인수가 필요한지 모를 때는 매개변수 이름 앞에 *를 추가하십시오.
  • Python packs the arguments into a tuple.
    Python은 인수를 튜플에 패킹합니다.
# 8.6_arbitrary_args.py
def make_pizza(*toppings):
    """Print the list of toppings that have been requested."""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')
  • You often will see *args used to collect arbitrary positional arguments.
    종종 임의의 위치 인수를 수집하기 위해 *args를 사용합니다.

Mixing Positional and Arbitrary Arguments / 위치 인수와 임의의 인수 혼합하기

  • If you want a function to accept several different kinds of arguments, the parameter that accepts an arbitrary number of arguments must be placed last in the function definition.
    함수가 여러 가지 종류의 인수를 받도록 하려면 임의의 수의 인수를 받는 매개변수를 함수 정의의 마지막에 두어야 합니다.
# 8.6_arbitrary_args.py
def make_pizza(size, *toppings):
    """Summarize the pizza we are about to make."""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Arbitrary Keyword Arguments / 임의의 키워드 인수

  • When you don’t know the number of arguments, AND you don’t know the kind of information you’ll be collecting, use an arbitrary keyword argument.
    인수의 수를 모르고 수집할 정보의 종류를 모를 때는 임의의 키워드 인수를 사용하십시오.
  • Use ** before the parameter name.
    매개변수 이름 앞에 **를 사용하십시오.
# 8.6_arbitrary_args.py
def build_profile(first, last, **user_info):
    """Build a dictionary containing everything we know about a user."""
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info

user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                             field='physics')

print(user_profile)
  • You’ll often see **kwargs used to collect non-specific keyword arguments.
    종종 **kwargs를 사용하여 특정하지 않은 키워드 인수를 수집합니다.

8.6 Storing Your Functions in Modules / 모듈에 함수 저장하기

  • You can store your functions in a separate file called a module.
    함수를 모듈이라는 별도의 파일에 저장할 수 있습니다.
  • These can be imported into your main program file.
    이들은 메인 프로그램 파일에 가져올 수 있습니다.
# pizza.py
def make_pizza(size, *toppings):
    """Summarize the pizza we are about to make."""
    print(f"\nMaking a {size}-inch pizza with the following toppings:")
    for topping in toppings:
        print(f"- {topping}")

# 8.7_making_pizzas.py
import pizza

pizza.make_pizza(16, 'pepperoni')
pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')
  • import copies the entire module into your program.
    import는 모듈 전체를 프로그램에 복사합니다.
  • Then use the Dot Notation to access the functions you need.
    그런 다음 필요한 함수에 점 표기법을 사용합니다.

Importing Specific Functions / 특정 함수 가져오기

  • You can import specific functions from a module.
    모듈에서 특정 함수를 가져올 수 있습니다.
  • This allows you to use the function name directly without using the Dot Notation.
    이렇게 하면 점 표기법을 사용하지 않고 함수 이름을 직접 사용할 수 있습니다.
# 8.7_making_pizzas.py
from pizza import make_pizza

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Using an Alias / 별칭 사용하기

  • You can use an alias to rename a function.
    함수의 이름을 바꾸려면 별칭을 사용할 수 있습니다.
  • This is useful when you have two functions with the same name.
    같은 이름을 가진 두 개의 함수가 있는 경우 유용합니다.
# 8.7_making_pizzas.py
from pizza import make_pizza as mp

mp(16, 'pepperoni')
mp(12, 'mushrooms', 'green peppers', 'extra cheese')
  • You can also use an alias for a module name.
    모듈 이름에도 별칭을 사용할 수 있습니다.
# 8.7_making_pizzas.py
import pizza as p

p.make_pizza(16, 'pepperoni')
p.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

Import ALL Functions / 모든 함수 가져오기

  • Use the asterisk (*) to import all functions from a module.
    별표(*)를 사용하여 모듈에서 모든 함수를 가져옵니다.
  • However, this is not recommended because it can be confusing and cause name conflicts.
    그러나 혼란을 줄 수 있고 이름 충돌을 일으킬 수 있으므로 권장하지 않습니다.
# 8.7_making_pizzas.py
from pizza import *

make_pizza(16, 'pepperoni')
make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

8.7 Styling Functions / 함수 스타일링

  • Keep the following PEP8 styling guidelines in mind when writing functions.
    함수를 작성할 때 다음 PEP8 스타일 가이드를 염두에 두십시오.
  1. Functions should have descriptive names, and these names should use lowercase letters and underscores.
    함수는 설명적인 이름을 가져야 하며 이러한 이름은 소문자와 밑줄을 사용해야 합니다.
  2. Every function should have a comment that explains concisely what the function does.
    모든 함수에는 함수가 무엇을 하는지 간결하게 설명하는 주석이 있어야 합니다.
  3. If you specify a default value for a parameter, no spaces should be used on either side of the equal sign.
    매개변수에 기본값을 지정하는 경우 등호 양쪽에 공백을 사용하지 않아야 합니다.
  4. If a set of parameters causes a function’s definition to be longer than 79 characters, press Enter after the opening parenthesis on the definition line, then TAB twice to indent it beyond the normal indentation level.
    매개변수 집합이 함수 정의를 79자보다 길게 만드는 경우 정의 줄의 여는 괄호 다음에 Enter를 누르고, TAB을 두 번 눌러 일반 들여쓰기 수준을 넘어서 들여쓰기합니다.
  5. If your program or module has more than one function, separate each by two blank lines.
    프로그램이나 모듈에 함수가 하나 이상 있는 경우 각 함수를 두 개의 빈 줄로 구분합니다.
  6. All import statements should be written at the beginning of a file.
    모든 import 문은 파일의 시작 부분에 작성해야 합니다.