Изучаем Python

Передача информации функции

С небольшими изменениями функция greet_user() сможет не только сказать «Привет!» пользователю, но и поприветствовать его по имени. Для этого следует включить имя username в круглых скобках в определение функции def greet_user(). С добавлением username функция примет любое значение, которое будет заключено в скобки при вызове. Теперь функция ожидает, что при каждом вызове будет передаваться имя пользователя. При вызове greet_user() укажите имя (например, 'jesse') в круглых скобках:

def greet_user(username):

. ."""Выводит простое приветствие."""

. .print("Hello, " + username.title() + "!")

. .

greet_user('jesse')

Команда greet_user('jesse') вызывает функцию greet_user() и передает ей информацию, необходимую для выполнения команды print. Функция получает переданное имя и выводит приветствие для этого имени:

Hello, Jesse!

Точно так же команда greet_user('sarah') вызывает функцию greet_user() и передает ей строку 'sarah', что приводит к выводу сообщения Hello, Sarah! Функцию greet_user() можно вызвать сколько угодно раз и передать ей любое имя на ваше усмотрение — и вы будете получать ожидаемый результат.

Аргументы и параметры

Функция greet_user() определена так, что для работы она должна получить значение переменной username. После того как функция будет вызвана и получит необходимую информацию (имя пользователя), она выведет правильное приветствие.

Переменная username в определении greet_user() — параметр, то есть условные данные, необходимые функции для выполнения ее работы. Значение 'jesse' в greet_user('jesse') — аргумент, то есть конкретная информация, переданная при вызове функции. Вызывая функцию, вы заключаете значение, с которым функция должна работать, в круглые скобки. В данном случае аргумент 'jesse' был передан функции greet_user(), а его значение было сохранено в переменной username.

примечание

Иногда в литературе термины «аргумент» и «параметр» используются как синонимы. Не удивляйтесь, если переменные в определении функции вдруг будут названы аргументами, а значения, переданные при вызове функции, — параметрами.

Упражнения

8-1. Сообщение: напишите функцию display_message() для вывода сообщения по теме, рассматриваемой в этой главе. Вызовите функцию и убедитесь в том, что сообщение выводится правильно.

8-2. Любимая книга: напишите функцию favorite_book(), которая получает один параметр title. Функция должна выводить сообщение вида «One of my favorite books is Alice in Wonderland». Вызовите функцию и убедитесь в том, что название книги правильно передается как аргумент при вызове функции.

Позиционные аргументы

При вызове функции каждому аргументу должен быть поставлен в соответствие параметр в определении функции. Проще всего сделать это на основании порядка перечисления аргументов. Значения, связываемые с аргументами подобным образом, называются позиционными аргументами.

Чтобы понять, как работает эта схема, рассмотрим функцию для вывода информации о домашних животных. Функция сообщает тип животного и его имя:

pets.py

(1) def describe_pet(animal_type, pet_name):

. ."""Выводит информацию о животном."""

. .print("\nI have a " + animal_type + ".")

. .print("My " + animal_type + "'s name is " + pet_name.title() + ".")

. .

(2)describe_pet('hamster', 'harry')

Из определения (1) видно, что функции должен передаваться тип животного (animal_type) и его имя (pet_name). При вызове describe_pet() необходимо передать тип и имя — именно в таком порядке. В этом примере аргумент 'hamster' сохраняется в параметре animal_type, а аргумент 'harry' сохраняется в параметре pet_name (2). В теле функции эти два параметра используются для вывода информации:

I have a hamster.

My hamster's name is Harry.

Именованные аргументы

Именованный аргумент представляет собой пару «имя—значение», передаваемую функции. Имя и значение связываются с аргументом напрямую, так что при передаче аргумента путаница с порядком исключается. Именованные аргументы избавляют от хлопот с порядком аргументов при вызове функции, а также проясняют роль каждого значения в вызове функции.

Перепишем программу pets.py с использованием именованных аргументов при ­вызове describe_pet():

def describe_pet(animal_type, pet_name):

. ."""Выводит информацию о животном."""

. .print("\nI have a " + animal_type + ".")

. .print("My " + animal_type + "'s name is " + pet_name.title() + ".")

. .

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

Функция describe_pet() не изменилась. Однако на этот раз при вызове функции мы явно сообщаем Python, с каким параметром должен быть связан каждый аргумент. При обработке вызова функции Python знает, что аргумент 'hamster' должен быть сохранен в параметре animal_type, а аргумент 'harry' в параметре pet_name.

Порядок следования именованных аргументов в данном случае не важен, потому что Python знает, где должно храниться каждое значение. Следующие два вызова функции эквивалентны:

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

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

примечание

При использовании именованных аргументов будьте внимательны — имена должны точно совпадать с именами параметров из определения функции.

Значения по умолчанию

Для каждого параметра вашей функции можно определить значение по умолчанию. Если при вызове функции передается аргумент, соответствующий данному параметру, Python использует значение аргумента, а если нет — использует значение по умолчанию. Таким образом, если для параметра определено значение по умолчанию, вы можете опустить соответствующий аргумент, который обычно включается в вызов функции. Значения по умолчанию упрощают вызовы функций и проясняют типичные способы использования функций.

Например, если вы заметили, что большинство вызовов describe_pet() используется для описания собак, задайте animal_type значение по умолчанию 'dog'. Теперь в любом вызове describe_pet() для собаки эту информацию можно опустить:

def describe_pet(pet_name, animal_type='dog'):

. ."""Выводит информацию о животном."""

. .print("\nI have a " + animal_type + ".")

. .print("My " + animal_type + "'s name is " + pet_name.title() + ".")

describe_pet(pet_name='willie')

Мы изменили определение describe_pet() и включили для параметра animal_type значение по умолчанию 'dog'. Если теперь функция будет вызвана без указания animal_type, Python знает, что для этого параметра следует использовать значение 'dog':

I have a dog.

My dog's name is Willie.

Обратите внимание: в определении функции пришлось изменить порядок параметров. Так как благодаря значению по умолчанию указывать аргумент с типом животного не обязательно, единственным оставшимся аргументом в вызове функции остается имя домашнего животного. Python интерпретирует его как позиционный аргумент, и если функция вызывается только с именем животного, этот аргумент ставится в соответствие с первым параметром в определении функции. Именно по этой причине имя животного должно быть первым параметром.

В простейшем варианте использования этой функции при вызове передается только имя собаки:

describe_pet('willie')

Вызов функции выводит тот же результат, что и в предыдущем примере. Единственный переданный аргумент 'willie' ставится в соответствие с первым параметром в определении, pet_name. Так как для animal_type аргумент не указан, Python использует значение по умолчанию 'dog'. Для вывода информации о любом другом животном, кроме собаки, используется вызов функции следующего вида:

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

Так как аргумент для параметра animal_type задан явно, Python игнорирует значение параметра по умолчанию.

примечание

Если вы используете значения по умолчанию, все параметры со значением по умолчанию должны следовать после параметров, у которых значений по умолчанию нет. Это необходимо для того, чтобы Python правильно интерпретировал позиционные аргументы.

Эквивалентные вызовы функций

Так как позиционные аргументы, именованные аргументы и значения по умолчанию могут использоваться одновременно, часто существуют несколько эквивалентных способов вызова функций. Возьмем оператор describe_pets() с одним значением по умолчанию:

def describe_pet(pet_name, animal_type='dog'):

При таком определении аргумент для параметра pet_name должен задаваться в любом случае, но это значение может передаваться как в позиционном, так и в именованном формате. Если описываемое животное не является собакой, то аргумент animal_type тоже должен быть включен в вызов, и этот аргумент тоже может быть задан как в позиционном, так и в именованном формате.

Все следующие вызовы являются допустимыми для данной функции:

describe_pet('willie')

describe_pet(pet_name='willie')

describe_pet('harry', 'hamster')

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

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

Все вызовы функции выдадут такой же результат, как и в предыдущих примерах.

примечание

На самом деле не так важно, какой стиль вызова вы используете. Если ваша функция выдает нужный результат, выберите тот стиль, который вам кажется более понятным.

Предотвращение ошибок в аргументах

Не удивляйтесь, если на первых порах вашей работы с функциями будут встречаться ошибки несоответствия аргументов. Такие ошибки происходят в том случае, если вы передали меньше или больше аргументов, чем необходимо функции для выполнения ее работы. Например, вот что произойдет при попытке вызвать describe_pet() без аргументов:

def describe_pet(animal_type, pet_name):

. ."""Выводит информацию о животном."""

. .print("\nI have a " + animal_type + ".")

. .print("My " + animal_type + "'s name is " + pet_name.title() + ".")

describe_pet()

Python понимает, что при вызове функции часть информации отсутствует, и мы видим это в данных трассировки:

Traceback (most recent call last):

(1) File "pets.py", line 6, in

(2) . .describe_pet()

(3)TypeError: describe_pet() missing 2 required positional arguments: 'animal_

type' and 'pet_name'

В точке (1) сообщается местонахождение проблемы, чтобы вы поняли, что с вызовом функции что-то пошло не так. В точке (2) приводится вызов функции, приведший к ошибке. В точке (3) Python сообщает, что при вызове пропущены два аргумента, и сообщает имена этих аргументов. Если бы функция размещалась в отдельном файле, вероятно, вы смогли бы исправить вызов, и вам не пришлось бы открывать этот файл и читать код функции.

Python помогает еще и тем, что он читает код функции и сообщает имена аргументов, которые необходимо передать при вызове. Это еще одна причина для того, чтобы присваивать переменным и функциям содержательные имена. В этом случае сообщения об ошибках Python принесут больше пользы как вам, так и любому другому разработчику, который будет использовать ваш код.

Если при вызове будут переданы лишние аргументы, вы получите похожую трассировку, которая поможет привести вызов функции в соответствие с ее определением.

Упражнения

8-3. Футболка: напишите функцию make_shirt(), которая получает размер футболки и текст, который должен быть напечатан на ней. Функция должна выводить сообщение с размером и текстом. Вызовите функцию с использованием позиционных аргументов. Вызовите функцию во второй раз с использованием именованных аргументов.

8-4. Большие футболки: измените функцию make_shirt(), чтобы футболки по умолчанию имели размер L, и на них выводился текст «I love Python.». Создайте футболку с размером L и текстом по умолчанию, а также футболку любого размера с другим текстом.

8-5. Города: напишите функцию describe_city(), которая получает названия города и страны. Функция должна выводить простое сообщение (например, «Reykjavik is in Iceland»). Задайте параметру страны значение по умолчанию. Вызовите свою функцию для трех разных городов, по крайней мере один из которых не находится в стране по умолчанию.

Возвращение простого значения

Рассмотрим функцию, которая получает имя и фамилию и возвращает аккуратно отформатированное полное имя:

formatted_name.py

(1) def get_formatted_name(first_name, last_name):

. ."""Возвращает аккуратно отформатированное полное имя."""

(2) . .full_name = first_name + ' ' + last_name

(3) . .return full_name.title()

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

print(musician)

Определение get_formatted_name() получает в параметрах имя и фамилию (1) . Функция объединяет эти два имени, добавляет между ними пробел и сохраняет результат в full_name (2). Значение full_name преобразуется в формат с начальной буквой верхнего регистра, а затем возвращается в точку вызова (3).

Вызывая функцию, которая возвращает значение, необходимо предоставить переменную, в которой должно храниться возвращаемое значение. В данном случае возвращаемое значение сохраняется в переменной musician (4). Результат содержит аккуратно отформатированное полное имя, построенное из имени и фамилии:

Jimi Hendrix

Может показаться, что все эти хлопоты излишни — с таким же успехом можно было использовать команду:

print("Jimi Hendrix")

Но если представить, что вы пишете большую программу, в которой многочисленные имена и фамилии должны храниться по отдельности, такие функции, как get_formatted_name(), становятся чрезвычайно полезными. Вы храните имена отдельно от фамилий, а затем вызываете функцию везде, где потребуется вывести полное имя.

Необязательные аргументы

Иногда бывает удобно сделать аргумент необязательным, чтобы разработчик, использующий функцию, мог передать дополнительную информацию только в том случае, если он этого захочет. Чтобы сделать аргумент необязательным, можно воспользоваться значением по умолчанию. Допустим, вы захотели расширить функцию get_formatted_name(), чтобы она также работала и со вторыми именами. Первая попытка могла бы выглядеть так:

def get_formatted_name(first_name, middle_name, last_name):

. ."""Возвращает аккуратно отформатированное полное имя."""

. .full_name = first_name + ' ' + middle_name + ' ' + last_name

. .return full_name.title()

. .

musician = get_formatted_name('john', 'lee', 'hooker')

print(musician)

Функция работает при получении имени, второго имени и фамилии. Она получает все три части имени, а затем строит из них строку. Функция добавляет пробелы там, где это уместно, и преобразует полное имя в формат с капитализацией:

John Lee Hooker

Однако вторые имена нужны не всегда, а в такой записи функция не будет работать, если при вызове ей передаются только имя и фамилия. Чтобы средний аргумент был необязательным, можно присвоить аргументу middle_name пустое значение по умолчанию; этот аргумент игнорируется, если пользователь не передал для него значение. Чтобы функция get_formatted_name() работала без второго имени, следует назначить для параметра middle_name пустую строку значением по умолчанию и переместить его в конец списка параметров:

(1) def get_formatted_name(first_name, last_name, middle_name=''):

. ."""Возвращает аккуратно отформатированное полное имя."""

(2) . .if middle_name:

. . . .full_name = first_name + ' ' + middle_name + ' ' + last_ name

(3) . .else:

. . . .full_name = first_name + ' ' + last_name

. .return full_name.title()

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

print(musician)

(4)musician = get_formatted_name('john', 'hooker', 'lee')

print(musician)

В этом примере имя строится из трех возможных частей. Поскольку имя и фамилия указываются всегда, эти параметры стоят в начале списка в определении функции. Второе имя не обязательно, поэтому оно находится на последнем месте в определении, а его значением по умолчанию является пустая строка (1) .

В теле функции мы сначала проверяем, было ли задано второе имя. Python интерпретирует непустые строки как истинное значение, и, если при вызове задан аргумент второго имени, middle_name дает результат True (2). Если второе имя указано, то из имени, второго имени и фамилии строится полное имя. Затем имя преобразуется с капитализацией символов и возвращается в строку вызова функции, где оно сохраняется в переменной musician и выводится. Если второе имя не указано, то пустая строка не проходит проверку if и выполняет блок else (3). В этом случае полное имя строится только из имени и фамилии, и отформатированное имя возвращается в строку вызова, где оно сохраняется в переменной musician и выводится.

Вызов этой функции с именем и фамилией достаточно тривиален. Но при использовании второго имени придется проследить за тем, чтобы второе имя было последним из передаваемых аргументов. Это необходимо для правильного связывания позиционных аргументов в строке (4).

Обновленная версия этой функции подойдет как для людей, у которых задается только имя и фамилия, так и для людей со вторым именем:

Jimi Hendrix

John Lee Hooker

Необязательные значения позволяют функциям работать в максимально широком спектре сценариев использования без усложнения вызовов.

Возвращение словаря

Функция может вернуть любое значение, нужное вам, в том числе и более сложную структуру данных (например, список или словарь). Так, следующая функция получает части имени и возвращает словарь, представляющий человека:

person.py

def build_person(first_name, last_name):

. ."""Возвращает словарь с информацией о человеке."""

(1) . .person = {'first': first_name, 'last': last_name}

(2) . .return person

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

(3)print(musician)

Функция build_person() получает имя и фамилию и сохраняет полученные значения в словаре в точке (1) . Значение first_name сохраняется с ключом 'first', а значение last_name — с ключом 'last'. Весь словарь с описанием человека возвращается в точке (2). Возвращаемое значение выводится в точке (3) с двумя исходными фрагментами текстовой информации, теперь хранящимися в словаре:

{'first': 'jimi', 'last': 'hendrix'}

Функция получает простую текстовую информацию и помещает ее в более удобную структуру данных, которая позволяет работать с информацией (помимо простого вывода). Строки 'jimi' и 'hendrix' теперь помечены как имя и фамилия. Функцию можно легко расширить так, чтобы она принимала дополнительные значения: — второе имя, возраст, профессию или любую другую информацию о человеке, которую вы хотите сохранить. Например, следующее изменение позволяет также сохранить возраст человека:

def build_person(first_name, last_name, age=''):

. ."""Возвращает словарь с информацией о человеке."""

. .person = {'first': first_name, 'last': last_name}

. .if age:

. . . .person['age'] = age

. .return person

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

print(musician)

В определение функции добавляется новый необязательный параметр age, которому назначается пустое значение по умолчанию. Если вызов функции включает значение этого параметра, то значение сохраняется в словаре. Функция всегда сохраняет имя, но ее также можно модифицировать, чтобы она сохраняла любую необходимую информацию о человеке.

Использование функции в цикле while

Функции могут использоваться со всеми структурами Python, уже известными вам. Например, используем функцию get_formatted_name() в цикле while, чтобы поприветствовать пользователей более официально. Первая версия программы, приветствующей пользователей по имени и фамилии, может выглядеть так:

greeter.py

def get_formatted_name(first_name, last_name):

. ."""Возвращает аккуратно отформатированное полное имя."""

. .full_name = first_name + ' ' + last_name

. .return full_name.title()

# Бесконечный цикл!

while True:

(1) . .print("\nPlease tell me your name:")

. .f_name = input("First name: ")

. .l_name = input("Last name: ")

. .

. .formatted_name = get_formatted_name(f_name, l_name)

. .print("\nHello, " + formatted_name + "!")

В этом примере используется простая версия get_formatted_name(), без вторых имен. В цикле while (1) имя и фамилия пользователя запрашиваются по отдельности.

Но у этого цикла while есть один недостаток: в нем не определено условие завершения. Где следует разместить условие завершения при запросе серии данных? Пользователю нужно предоставить возможность выйти из цикла как можно раньше, так что в приглашении должен содержаться способ завершения. Команда break позволяет немедленно прервать цикл при запросе любого из компонентов:

def get_formatted_name(first_name, last_name):

. ."""Возвращает аккуратно отформатированное полное имя."""

. .full_name = 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("\nHello, " + formatted_name + "!")

В программу добавляется сообщение, которое объясняет пользователю, как завершить ввод данных, и при вводе признака завершения в любом из приглашений цикл прерывается. Теперь программа будет приветствовать пользователя до тех пор, пока вместо имени или фамилии не будет введен символ 'q':

Please tell me your name:

(enter 'q' at any time to quit)

First name: eric

Last name: matthes

Hello, Eric Matthes!

Please tell me your name:

(enter 'q' at any time to quit)

First name: q

Упражнения

8-6. Названия городов: напишите функцию city_country(), которая получает название города и страну. Функция должна возвращать строку в формате “Santiago, Chile”. Вызовите свою функцию по крайней мере для трех пар «город—страна» и выведите возвращенное значение.

8-7. Альбом: напишите функцию make_album(), которая строит словарь с описанием музыкального альбома. Функция должна получать имя исполнителя и название альбома и возвращать словарь, содержащий эти два вида информации. Используйте функцию для создания трех словарей, представляющих разные альбомы. Выведите все возвращаемые значения, чтобы показать, что информация правильно сохраняется во всех трех словарях.

Добавьте в make_album() дополнительный параметр для сохранения количества дорожек в альбоме. Если в строку вызова включено значение количества дорожек, добавьте это значение в словарь альбома. Создайте как минимум один новый вызов функции с передачей количества дорожек в альбоме.

8-8. Пользовательские альбомы: начните с программы из упражнения 8-7. Напишите цикл while, в котором пользователь вводит исполнителя и название альбома. Затем в цикле вызывается функция make_album() для введенных пользователей и выводится созданный словарь. Не забудьте предусмотреть признак завершения в цикле while.

Изменение списка в функции

Если вы передаете список функции, код функции сможет изменить список. Все изменения, внесенные в список в теле функции, закрепляются, что позволяет эффективно работать со списком даже при больших объемах данных.

Допустим, компания печатает на 3D-принтере модели, предоставленные пользователем. Проекты хранятся в списке, а после печати перемещаются в отдельный список. В следующем примере приведена реализация, не использующая функции:

printing_models.py

# Список моделей, которые необходимо напечатать.

unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']

completed_models = []

# Цикл последовательно печатает каждую модель до конца списка.

# После печати каждая модель перемещается в список completed_models.

while unprinted_designs:

. .current_design = unprinted_designs.pop()

. .# Печать модели на 3D-принтере.

. .print("Printing model: " + current_design)

. .completed_models.append(current_design)

. .

# Вывод всех готовых моделей.

print("\nThe following models have been printed:")

for completed_model in completed_models:

. .print(completed_model)

В начале программы создается список моделей и пустой список completed_models, в который каждая модель перемещается после печати. Пока в unprinted_designs остаются модели, цикл while имитирует печать каждой модели: модель удаляется с конца списка, сохраняется в current_design, а пользователь получает сообщение о том, что текущая модель была напечатана. Затем модель перемещается в список напечатанных. После завершения цикла выводится список напечатанных моделей:

Printing model: dodecahedron

Printing model: robot pendant

Printing model: iphone case

The following models have been printed:

dodecahedron

robot pendant

iphone case

Мы можем изменить структуру этого кода: для этого следует написать две функции, каждая из которых решает одну конкретную задачу. Бульшая часть кода останется неизменной; просто программа становится более эффективной. Первая функция занимается печатью, а вторая выводит сводку напечатанных моделей:

(1) def print_models(unprinted_designs, completed_models):

. ."""

. .Имитирует печать моделей, пока список не станет пустым.

. .Каждая модель после печати перемещается в completed_models.

. ."""

. .while unprinted_designs:

. . . .current_design = unprinted_designs.pop()

. .

. . . .# Имитация печати модели на 3D-принтере.

. . . .print("Printing model: " + current_design)

. . . .completed_models.append(current_design)

. . . .

(2)def show_completed_models(completed_models):

. ."""Выводит информацию обо всех напечатанных моделях."""

. .print("\nThe following models have been printed:")

. .for completed_model in completed_models:

. . . .print(completed_model)

. . . .

unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']

completed_models = []

print_models(unprinted_designs, completed_models)

show_completed_models(completed_models)

В точке (1) определяется функция print_models() с двумя параметрами: список моделей для печати и список готовых моделей. Функция имитирует печать каждой модели, последовательно извлекая модели из первого списка и перемещая их во второй список. В точке (1) определяется функция show_completed_models() с одним параметром: списком напечатанных моделей. Функция show_completed_models() получает этот список и выводит имена всех напечатанных моделей.

Программа выводит тот же результат, что и версия без функций, но структура кода значительно улучшилась. Код, выполняющий бульшую часть работы, разнесен по двум разным функциям; это упрощает чтение основной части программы. Теперь любому разработчику будет намного проще просмотреть код программы и понять, что делает программа:

unprinted_designs = ['iphone case', 'robot pendant', 'dodecahedron']

completed_models = []

print_models(unprinted_designs, completed_models)

show_completed_models(completed_models)

Программа создает список моделей для печати и пустой список для готовых моделей. Затем, поскольку обе функции уже определены, остается вызвать их и передать правильные аргументы. Мы вызываем print_models() и передаем два необходимых списка; как и ожидалось, print_models() имитирует печать моделей. Затем вызывается функция show_completed_models(), и ей передается список готовых моделей, чтобы функция могла вывести информацию о напечатанных моделях. Благодаря содержательным именам функций другой разработчик сможет прочитать этот код и понять его даже без комментариев.

Вдобавок эта программа создает меньше проблем с расширением и сопровождением, чем версия без функций. Если позднее потребуется напечатать новую партию моделей, достаточно снова вызвать print_models(). Если окажется, что код печати необходимо модифицировать, изменения достаточно внести в одном месте, и они автоматически распространятся на все вызовы функции. Такой подход намного эффективнее независимой правки кода в нескольких местах программы.

Этот пример также демонстрирует принцип, в соответствии с которым каждая функция должна решать одну конкретную задачу. Первая функция печатает каждую модель, а вторая выводит информацию о готовых моделях. Такой подход предпочтительнее решения обеих задач в функции. Если вы пишете функцию и видите, что она решает слишком много разных задач, попробуйте разделить ее код на две функции.

Помните, что функции всегда можно вызывать из других функций. Эта возможность может пригодиться для разбиения сложных задач на серию составляющих.

Запрет изменения списка в функции

Иногда требуется предотвратить изменение списка в функции. Допустим, у вас имеется список моделей для печати, и вы пишете функцию для перемещения их в список готовых моделей, как в предыдущем примере. Возможно, даже после печати всех моделей исходный список нужно оставить для отчетности. Но, ­поскольку все имена моделей были перенесены из списка unprinted_designs, остался только пустой список; исходная версия списка потеряна. Проблему можно решить передачей функции копии списка вместо оригинала. В этом случае все изменения, вносимые функцией в список, будут распространяться только на копию, а оригинал списка остается неизменным.

Чтобы передать функции копию списка, можно поступить так:

имя_функции(имя_списка[:])

Синтаксис среза [:] создает копию списка для передачи функции. Если удаление элементов из списка unprinted_designs в print_models.py нежелательно, функцию print_models() можно вызвать так:

print_models(unprinted_designs[:], completed_models)

Функция print_models() может выполнить свою работу, потому что она все равно получает имена всех ненапечатаных моделей. Но на этот раз она получает не сам список unprinted_designs, а его копию. Список completed_models заполняется именами напечатанных моделей, как и в предыдущем случае, но исходный список функцией не изменяется.

Несмотря на то что передача копии позволяет сохранить содержимое списка, обычно функциям следует передавать исходный список (если у вас нет веских причин для передачи копии). Работа с существующим списком более эффективна, потому что программе не приходится тратить время и память на создание отдельной копии (лишние затраты особенно заметны при работе с большими списками).

Упражнения

8-9. Фокусники: создайте список с именами фокусников. Передайте список функции show_magicians(), которая выводит имя каждого фокусника в списке.

8-10. Великие фокусники: начните с копии вашей программы из упражнения 8-9. Напишите функцию make_great(), которая изменяет список фокусников, добавляя к имени каждого фокусника приставку «Great». Вызовите функцию show_magicians() и убедитесь в том, что список был успешно изменен.

8-11. Фокусники без изменений: начните с программы из упражнения 8-10. Вызовите функцию make_great() и передайте ей копию списка имен фокусников. Поскольку исходный список остался неизменным, верните новый список и сохраните его в отдельном списке. Вызовите функцию show_magicians() с каждым списком, чтобы показать, что в одном списке остались исходные имена, а в другом к имени каждого фокусника добавилась приставка «Great».

Передача произвольного набора аргументов

В некоторых ситуациях вы не знаете заранее, сколько аргументов должно быть передано функции. К счастью, Python позволяет функции получить произвольное количество аргументов из вызывающей команды.

Для примера рассмотрим функцию для создания пиццы. Функция должна получить набор дополнений к пицце, но вы не знаете заранее, сколько дополнений закажет клиент. Функция в следующем примере получает один параметр *toppings, но этот параметр объединяет все аргументы, заданные в командной строке:

pizza.py

def make_pizza(*toppings):

. ."""Вывод списка заказанных дополнений."""

. .print(toppings)

. . . .

make_pizza('pepperoni')

make_pizza('mushrooms', 'green peppers', 'extra cheese')

Звездочка в имени параметра *toppings приказывает Python создать пустой кортеж с именем toppings и упаковать в него все полученные значения. Результат команды print в теле функции показывает, что Python успешно справляется и с вызовом функции с одним значением, и с вызовом с тремя значениями. Разные вызовы обрабатываются похожим образом. Обратите внимание: Python упаковывает аргументы в кортеж даже в том случае, если функция получает всего одно значение:

('pepperoni',)

('mushrooms', 'green peppers', 'extra cheese')

Теперь команду print можно заменить циклом, который перебирает список ­дополнений и выводит описание заказанной пиццы:

def make_pizza(*toppings):

. ."""Выводит описание пиццы."""

. .print("\nMaking a pizza with the following toppings:")

. .for topping in toppings:

. . . .print("- " + topping)

. . . .

make_pizza('pepperoni')

make_pizza('mushrooms', 'green peppers', 'extra cheese')

Функция реагирует соответственно независимо от того, сколько значений она получила — одно или три:

Making a pizza with the following toppings:

- pepperoni

Making a pizza with the following toppings:

- mushrooms

- green peppers

- extra cheese

Этот синтаксис работает независимо от количества аргументов, переданных ­функции.

Позиционные аргументы с произвольными наборами аргументов

Если вы хотите, чтобы функция могла вызываться с разными количествами аргументов, параметр для получения произвольного количества аргументов должен стоять на последнем месте в определении функции. Python сначала подбирает соответствия для позиционных и именованных аргументов, а потом объединяет все остальные аргументы в последнем параметре.

Например, если функция должна получать размер пиццы, этот параметр должен стоять в списке до параметра *toppings:

def make_pizza(size, *toppings):

. ."""Выводит описание пиццы."""

. .print("\nMaking a " + str(size) +

. . . . "-inch pizza with the following toppings:")

. .for topping in toppings:

. . . .print("- " + topping)

. . . .

make_pizza(16, 'pepperoni')

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

В определении функции Python сохраняет первое полученное значение в параметре size. Все остальные значения, следующие за ним, сохраняются в кортеже toppings. В вызовах функций на первом месте располагается аргумент для параметра size, а за ним следует сколько угодно дополнений.

В итоге для каждой пиццы указывается размер и количество дополнений, и каждый фрагмент информации выводится в положенном месте: сначала размер, а потом дополнения:

Making a 16-inch pizza with the following toppings:

- pepperoni

Making a 12-inch pizza with the following toppings:

- mushrooms

- green peppers

- extra cheese

Использование произвольного набора именованных аргументов

Иногда программа должна получать произвольное количество аргументов, но вы не знаете заранее, какая информация будет передаваться функции. В таких случаях можно написать функцию, получающую столько пар «ключ—значение», сколько указано в команде вызова. Один из возможных примеров — построение пользовательских профилей: вы знаете, что вы получите информацию о пользователе, но не знаете заранее, какую именно. Функция build_profile() в следующем примере всегда получает имя и фамилию, но также может получать произвольное количество именованных аргументов:

user_profile.py

def build_profile(first, last, **user_info):

. ."""Строит словарь с информацией о пользователе."""

. .profile = {}

(1) . .profile['first_name'] = first

. .profile['last_name'] = last

(2) . .for key, value in user_info.items():

. . . .profile[key] = value

. .return profile

user_profile = build_profile('albert', 'einstein',

. . . . . . . . . . . . . . location='princeton',

. . . . . . . . . . . . . . field='physics')

print(user_profile)

Определение build_profile() ожидает получить имя и фамилию пользователя, а также позволяет передать любое количество пар «имя—значение». Две звездочки перед параметром **user_info заставляют Python создать пустой словарь с именем user_info и упаковать в него все полученные пары «имя—значение». Внутри функции вы можете обращаться к парам «имя–значение» из user_info точно так же, как в любом словаре.

В теле build_profile() создается пустой словарь с именем profile для хранения профиля пользователя. В точке (1) в словарь добавляется имя и фамилия, потому что эти два значения всегда передаются пользователем. В точке (2) функция перебирает дополнительные пары «ключ—значение» в словаре user_info и добавляет каждую пару в словарь profile. Наконец, словарь profile возвращается в точку вызова функции.

Вызовем функцию build_profile() и передадим ей имя 'albert', фамилию 'einstein', и еще две пары «ключ—значение» location='princeton' и field='physics'. Программа сохраняет возвращенный словарь в user_profile и выводит его содержимое:

{'first_name': 'albert', 'last_name': 'einstein',

'location': 'princeton', 'field': 'physics'}

Возвращаемый словарь содержит имя и фамилию пользователя, а в данном случае еще и местонахождение и область исследований. Функция будет работать, сколько бы дополнительных пар «ключ—значение» ни было передано при вызове функции.

При написании функций допускаются самые разнообразные варианты смешения позиционных, именованных и произвольных значений. Полезно знать о существовании всех этих типов аргументов, потому что они часто будут встречаться вам при чтении чужого кода. Только с опытом вы научитесь правильно использовать разные типы аргументов и поймете, когда следует применять каждый тип; а пока просто используйте самый простой способ, который позволит решить задачу. С течением времени вы научитесь выбирать наиболее эффективный вариант для каждой конкретной ситуации.

Упражнения

8-12. Сэндвичи: напишите функцию, которая получает список компонентов сэндвича. Функция должна иметь один параметр для любого количества значений, переданных при вызове функции, и выводить описание заказанного сэндвича. Вызовите функцию три раза с разными количествами аргументов.

8-13. Профиль: начните с копии программы user_profile.py. Создайте собственный профиль вызовом build_profile(), укажите имя, фамилию и три другие пары «ключ—значение» для вашего описания.

8-14. Автомобили: напишите функцию для сохранения информации об автомобиле в словаре. Функция всегда должна возвращать производителя и название модели, но при этом она может получать произвольное количество именованных аргументов. Вызовите функцию с передачей обязательной информации и еще двух пар «имя—значение» (например, цвет и комплектация). Ваша функция должна работать для вызовов следующего вида:

car = make_car(‘subaru’, ‘outback’, color=’blue’, tow_package=True)

Выведите возвращаемый словарь и убедитесь в том, что вся информация была сохранена правильно.

Импортирование всего модуля

Чтобы заняться импортированием функций, сначала необходимо создать модуль. Модуль представляет собой файл с расширением .py, содержащий код, который вы хотите импортировать в свою программу. Давайте создадим модуль с функцией make_pizza(). Для этого из файла pizza.py следует удалить все, кроме функции make_pizza():

pizza.py

def make_pizza(size, *toppings):

. ."""Выводит описание пиццы."""

. .print("\nMaking a " + str(size) +

. . . . "-inch pizza with the following toppings:")

. .for topping in toppings:

. . . .print("- " + topping)

Теперь создайте отдельный файл с именем making_pizzas.py в одном каталоге с pizza.py. Файл импортирует только что созданный модуль, а затем дважды вызывает make_pizza():

making_pizzas.py

import pizza

(1) pizza.make_pizza(16, 'pepperoni')

pizza.make_pizza(12, 'mushrooms', 'green peppers', 'extra cheese')

В процессе обработки этого файла строка import pizza приказывает Python открыть файл pizza.py и скопировать все функции из него в программу. Вы не видите, как происходит копирование, потому что Python копирует код незаметно для пользователя во время выполнения программы. Вам необходимо знать одно: любая функция, определенная в pizza.py, будет доступна в making_pizzas.py.

Чтобы вызвать функцию из импортированного модуля, укажите имя модуля (pizza), точку и имя функции (make_pizza()), как показано в строке (1) . Код выдает тот же результат, что и исходная программа, в которой модуль не импортировался:

Making a 16-inch pizza with the following toppings:

- pepperoni

Making a 12-inch pizza with the following toppings:

- mushrooms

- green peppers

- extra cheese

Первый способ импортирования, при котором записывается команда import с именем модуля, открывает доступ программе ко всем функциям из модуля:

имя_модуля.имя_функции()

Импортирование конкретных функций

Также возможно импортировать конкретную функцию из модуля. Общий синтаксис выглядит так:

from имя_модуля import имя_функции

Вы можете импортировать любое количество функций из модуля, разделив их имена запятыми:

from имя_модуля import функция_0, функция_1, функция_2

Если ограничиться импортированием только той функции, которую вы намереваетесь использовать, пример making_pizzas.py будет выглядеть так:

from pizza import make_pizza

make_pizza(16, 'pepperoni')

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

При таком синтаксисе использовать точечную запись при вызове функции не обязательно. Так как функция make_pizza() явно импортируется в команде import, при использовании ее можно вызывать прямо по имени.

Назначение псевдонима для функции

Если имя импортируемой функции может конфликтовать с именем существующей функции или функция имеет слишком длинное имя, его можно заменить коротким уникальным псевдонимом (alias) — альтернативным именем для функции. Псевдоним назначается функции при импортировании.

В следующем примере функции make_pizza() назначается псевдоним mp(), для чего при импортировании используется конструкция make_pizza as mp. Ключевое слово as переименовывает функцию, используя указанный псевдоним:

from pizza import make_pizza as mp

mp(16, 'pepperoni')

mp(12, 'mushrooms', 'green peppers', 'extra cheese')

Команда import в этом примере назначает функции make_pizza() псевдоним mp() для этой программы. Каждый раз, когда потребуется вызвать make_pizza(), достаточно включить вызов mp() — Python выполнит код make_pizza() без конфликтов с другой функцией make_pizza(), которую вы могли включить в этот файл программы.

Общий синтаксис назначения псевдонима выглядит так:

from имя_модуля import имя_функции as псевдоним

Назначение псевдонима для модуля

Псевдоним также можно назначить для всего модуля. Назначение короткого имени для модуля — скажем, p для pizza — позволит вам быстрее вызывать функции модуля. Вызов p.make_pizza() получается более компактным, чем pizza.make_pizza():

import pizza as p

p.make_pizza(16, 'pepperoni')

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

Модулю pizza в команде import назначается псевдоним p, но все функции модуля сохраняют свои исходные имена. Вызов функций в записи p.make_pizza() не только компактнее pizza.make_pizza(); он также отвлекает внимание от ­имени модуля и помогает сосредоточиться на содержательных именах функций. Эти имена функций, четко показывающие, что делает каждая функция, важнее для удобочитаемости вашего кода, чем использование полного имени модуля.

Общий синтаксис выглядит так:

import имя_модуля as псевдоним

Импортирование всех функций модуля

Также можно приказать Python импортировать каждую функцию в модуле; для этого используется оператор *:

from pizza import *

make_pizza(16, 'pepperoni')

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

Звездочка в команде import приказывает Python скопировать каждую функцию из модуля pizza в файл программы. После импортирования всех функций вы сможете вызывать каждую функцию по имени без точечной записи. Тем не менее лучше не использовать этот способ с большими модулями, написанными другими разработчиками; если модуль содержит функцию, имя которой совпадает с существующим именем из вашего проекта, возможны неожиданные результаты. Python обнаруживает несколько функций или переменных с одинаковыми именами, и вместо импортирования всех функций по отдельности происходит замена этих функций.

В таких ситуациях лучше всего импортировать только нужную функцию или функции или же импортировать весь модуль с последующим применением точечной записи. При этом создается чистый код, легко читаемый и понятный. Я включил этот раздел только для того, чтобы вы понимали команды import вроде следующей, когда вы встретите их в чужом коде:

from имя_модуля import *