Аргументы функций в Python являются фундаментальным аспектом программирования, но работа с отсутствующими или недействительными аргументами может быть сложной задачей. Этот учебник проведет вас через обработку аргументов функций в Python, от понимания основ до реализации надежных стратегий валидации и обработки ошибок. К концу вы сможете писать код на Python, который корректно управляет аргументами функций, что приведет к более надежным и удобным в обслуживании приложениям.
В Python функции — это блоки многократно используемого кода, которые выполняют определенные задачи. Когда вы определяете функцию, вы можете указать параметры, которые функция должна получить. Давайте узнаем, как настроить функции с различными типами аргументов и рассмотрим, как предоставить значения по умолчанию.
Начнем с создания простого файла Python для работы. В WebIDE перейдите в каталог проекта и создайте новый файл с именем function_args.py:
function_args.py в качестве имени файлаТеперь давайте добавим базовую функцию в этот файл:
def greet(name):
"""A simple function that greets a person by name."""
return f"Hello, {name}!"
## Call the function and print the result
result = greet("Alice")
print(result)Сохраните файл (Ctrl+S или File > Save), а затем запустите его в терминале:
python3 function_args.pyВы должны увидеть вывод:
Hello, Alice!В приведенном выше примере name является обязательным аргументом. Если вы попытаетесь вызвать функцию, не предоставив этот аргумент, Python выдаст ошибку.
Давайте изменим наш файл, чтобы продемонстрировать это:
def greet(name):
"""A simple function that greets a person by name."""
return f"Hello, {name}!"
## This will work
result = greet("Alice")
print(result)
## This will raise an error
try:
result = greet()
print(result)
except TypeError as e:
print(f"Error: {e}")Сохраните файл и запустите его:
python3 function_args.pyВывод:
Hello, Alice!
Error: greet() missing 1 required positional argument: 'name'Как видите, Python выдает TypeError, когда мы не предоставляем обязательный аргумент.
Чтобы сделать аргументы необязательными, мы можем предоставить значения по умолчанию. Давайте обновим нашу функцию:
def greet(name="Guest"):
"""A function that greets a person by name, with a default value."""
return f"Hello, {name}!"
## With an argument
result1 = greet("Alice")
print(result1)
## Without an argument - uses the default value
result2 = greet()
print(result2)Сохраните и запустите:
python3 function_args.pyВывод:
Hello, Alice!
Hello, Guest!Теперь функция работает как с аргументом, так и без него.
Давайте расширим нашу функцию, чтобы она обрабатывала несколько аргументов, некоторые из которых имеют значения по умолчанию:
def greet(name="Guest", message="Hello", punctuation="!"):
"""A function with multiple arguments and default values."""
return f"{message}, {name}{punctuation}"
## Using all default values
print(greet())
## Providing only the name
print(greet("Alice"))
## Providing name and message
print(greet("Bob", "Hi"))
## Providing all arguments
print(greet("Charlie", "Welcome", "!!!"))Сохраните и запустите:
python3 function_args.pyВывод:
Hello, Guest!
Hello, Alice!
Hi, Bob!
Welcome, Charlie!!!Вы также можете указывать аргументы по имени, независимо от их порядка:
def greet(name="Guest", message="Hello", punctuation="!"):
"""A function with multiple arguments and default values."""
return f"{message}, {name}{punctuation}"
## Using keyword arguments
print(greet(message="Hey", name="David"))
print(greet(punctuation="...", message="Welcome back", name="Emma"))Сохраните и запустите:
python3 function_args.pyВывод:
Hey, David!
Welcome back, Emma...Это особенно полезно, когда функция имеет много аргументов, и вы хотите указать только некоторые из них.
Теперь вы понимаете, как создавать функции со значениями по умолчанию и как использовать ключевые аргументы. На следующем шаге мы рассмотрим более продвинутые способы обработки отсутствующих или недействительных аргументов функций.
В Python нам иногда нужно создавать гибкие функции, которые могут принимать переменное количество аргументов. Для обработки этих случаев Python предоставляет два специальных синтаксических элемента: *args и **kwargs.
Давайте создадим новый файл для работы с этими концепциями:
flexible_args.py в качестве имени файлаСинтаксис *args позволяет функции принимать любое количество позиционных аргументов, которые собираются в кортеж.
Добавьте следующий код в flexible_args.py:
def sum_numbers(*args):
"""A function that sums up any number of arguments."""
result = 0
for num in args:
result += num
return result
## Test the function with different numbers of arguments
print(f"Sum of 1, 2: {sum_numbers(1, 2)}")
print(f"Sum of 1, 2, 3, 4, 5: {sum_numbers(1, 2, 3, 4, 5)}")
print(f"No arguments: {sum_numbers()}")Сохраните файл и запустите его:
python3 flexible_args.pyВывод:
Sum of 1, 2: 3
Sum of 1, 2, 3, 4, 5: 15
No arguments: 0Это демонстрирует, как *args может обрабатывать любое количество аргументов, включая ни одного. Внутри функции args — это кортеж, содержащий все предоставленные аргументы.
Синтаксис **kwargs позволяет функции принимать любое количество ключевых аргументов, которые собираются в словарь.
Давайте добавим еще одну функцию в наш файл:
def build_profile(**kwargs):
"""A function that builds a user profile from keyword arguments."""
profile = {}
## Add required fields with defaults
profile["name"] = kwargs.get("name", "Anonymous")
profile["age"] = kwargs.get("age", "Not specified")
## Add any additional fields
for key, value in kwargs.items():
if key not in ["name", "age"]:
profile[key] = value
return profile
## Test the function with different keyword arguments
print("Basic profile:", build_profile())
print("Full profile:", build_profile(name="Alice", age=30, occupation="Developer", location="New York"))
print("Custom fields:", build_profile(hobby="Reading", favorite_color="Blue"))Сохраните и запустите:
python3 flexible_args.pyВывод:
Basic profile: {'name': 'Anonymous', 'age': 'Not specified'}
Full profile: {'name': 'Alice', 'age': 30, 'occupation': 'Developer', 'location': 'New York'}
Custom fields: {'name': 'Anonymous', 'age': 'Not specified', 'hobby': 'Reading', 'favorite_color': 'Blue'}Обратите внимание, как kwargs.get("key", default_value) позволяет нам получать значения со значениями по умолчанию, если они не существуют.
Давайте создадим более сложную функцию, которая объединяет все эти типы аргументов:
def format_message(recipient, message="Hello", *args, **kwargs):
"""
A function that formats a message with various customization options.
- recipient: Required - who the message is for
- message: Default greeting
- *args: Additional message parts
- **kwargs: Formatting options
"""
## Start with the basic message
full_message = f"{message}, {recipient}!"
## Add any additional message parts
if args:
full_message += " " + " ".join(args)
## Apply formatting options
if kwargs.get("upper", False):
full_message = full_message.upper()
if kwargs.get("wrap", False):
full_message = f"[{full_message}]"
return full_message
## Test with different combinations
print(format_message("Alice"))
print(format_message("Bob", "Hi"))
print(format_message("Charlie", "Welcome", "Hope", "you", "are", "well"))
print(format_message("David", "Greetings", upper=True))
print(format_message("Emma", wrap=True))
print(format_message("Frank", "Hey", "How's it going?", upper=True, wrap=True))Сохраните и запустите:
python3 flexible_args.pyВывод:
Hello, Alice!
Hi, Bob!
Welcome, Charlie! Hope you are well
GREETINGS, DAVID!
[Hello, Emma!]
[HEY, FRANK! HOW'S IT GOING?]Этот пример демонстрирует, как использовать все типы аргументов функций вместе:
recipient — обязательный позиционный аргументmessage имеет значение по умолчанию, что делает его необязательным*args захватывает любые дополнительные позиционные аргументы**kwargs захватывает любые ключевые аргументыКомбинируя эти подходы, вы можете создавать очень гибкие функции, которые корректно обрабатывают отсутствующие или необязательные аргументы.
При создании функций в Python важно убедиться, что аргументы, переданные вашим функциям, являются допустимыми, прежде чем приступать к основной логике функции. На этом шаге мы изучим несколько методов проверки аргументов функций.
Давайте создадим новый файл для работы с концепциями проверки:
validate_args.py в качестве имени файлаСамый простой способ проверки аргументов — использовать условные операторы. Начнем с некоторых базовых проверок:
def calculate_rectangle_area(length, width):
"""Calculate the area of a rectangle, validating inputs."""
## Validate that inputs are numbers
if not isinstance(length, (int, float)):
raise TypeError("Length must be a number")
if not isinstance(width, (int, float)):
raise TypeError("Width must be a number")
## Validate that inputs are positive
if length <= 0:
raise ValueError("Length must be positive")
if width <= 0:
raise ValueError("Width must be positive")
## Calculate the area
return length * width
## Test with valid inputs
try:
area = calculate_rectangle_area(5, 3)
print(f"Area of rectangle: {area}")
except (TypeError, ValueError) as e:
print(f"Error: {e}")
## Test with invalid types
try:
area = calculate_rectangle_area("5", 3)
print(f"Area of rectangle: {area}")
except (TypeError, ValueError) as e:
print(f"Error: {e}")
## Test with invalid values
try:
area = calculate_rectangle_area(5, -3)
print(f"Area of rectangle: {area}")
except (TypeError, ValueError) as e:
print(f"Error: {e}")Сохраните и запустите:
python3 validate_args.pyВывод:
Area of rectangle: 15
Error: Length must be a number
Error: Width must be positiveЭта функция проверяет как типы, так и значения своих аргументов, прежде чем выполнять какие-либо вычисления. При обнаружении недопустимых аргументов выдаются соответствующие сообщения об ошибках.
Другой способ проверки аргументов — использовать утверждения (assertions). Утверждения — это операторы, которые вызывают AssertionError, если условие не выполняется:
def calculate_discount(price, discount_percent):
"""Calculate the discounted price."""
## Assert that inputs are valid
assert isinstance(price, (int, float)), "Price must be a number"
assert isinstance(discount_percent, (int, float)), "Discount must be a number"
assert price >= 0, "Price cannot be negative"
assert 0 <= discount_percent <= 100, "Discount must be between 0 and 100"
## Calculate the discount
discount_amount = price * (discount_percent / 100)
return price - discount_amount
## Test with valid inputs
try:
discounted_price = calculate_discount(100, 20)
print(f"Discounted price: ${discounted_price}")
except AssertionError as e:
print(f"Error: {e}")
## Test with invalid discount percentage
try:
discounted_price = calculate_discount(100, 120)
print(f"Discounted price: ${discounted_price}")
except AssertionError as e:
print(f"Error: {e}")Сохраните и запустите:
python3 validate_args.pyВывод:
Discounted price: $80.0
Error: Discount must be between 0 and 100Утверждения полезны для разработки и отладки, но их можно отключить в производственном коде, поэтому они не всегда являются лучшим выбором для проверки в реальных приложениях.
Python 3.5+ поддерживает подсказки типов (type hints), которые могут помочь документировать ожидаемые типы аргументов функций и возвращаемых значений. Хотя подсказки типов сами по себе не выполняют проверку во время выполнения, они предоставляют полезную документацию и могут быть проверены внешними инструментами, такими как mypy:
def calculate_average(numbers: list[float]) -> float:
"""Calculate the average of a list of numbers."""
if not numbers:
raise ValueError("Cannot calculate average of empty list")
if not all(isinstance(n, (int, float)) for n in numbers):
raise TypeError("All elements must be numbers")
return sum(numbers) / len(numbers)
## Test with valid input
try:
avg = calculate_average([1, 2, 3, 4, 5])
print(f"Average: {avg}")
except (TypeError, ValueError) as e:
print(f"Error: {e}")
## Test with empty list
try:
avg = calculate_average([])
print(f"Average: {avg}")
except (TypeError, ValueError) as e:
print(f"Error: {e}")
## Test with non-numeric elements
try:
avg = calculate_average([1, 2, "3", 4, 5])
print(f"Average: {avg}")
except (TypeError, ValueError) as e:
print(f"Error: {e}")Сохраните и запустите:
python3 validate_args.pyВывод:
Average: 3.0
Error: Cannot calculate average of empty list
Error: All elements must be numbersОбратите внимание, что подсказки типов (list[float] и -> float) сами по себе не выполняют никакой проверки — нам все равно нужно написать свой собственный код проверки. Они служат документацией и могут быть проверены внешними инструментами.
Теперь давайте применим все эти методы, чтобы создать надежную функцию, которая вычисляет общую стоимость товаров со скидкой:
def calculate_total_cost(items=None, tax_rate=0, discount=0):
"""
Calculate the total cost of items with tax and discount.
Args:
items: List of (item_name, price) tuples
tax_rate: Tax rate percentage (0-100)
discount: Discount percentage (0-100)
Returns:
A dictionary with the total, subtotal, tax amount, and discount amount
"""
## Validate items
if items is None:
items = []
if not isinstance(items, list):
raise TypeError("Items must be a list")
## Validate each item in the list
for i, item in enumerate(items):
if not isinstance(item, tuple) or len(item) != 2:
raise ValueError(f"Item {i} must be a tuple of (name, price)")
name, price = item
if not isinstance(name, str):
raise TypeError(f"Name of item {i} must be a string")
if not isinstance(price, (int, float)):
raise TypeError(f"Price of item {i} must be a number")
if price < 0:
raise ValueError(f"Price of item {i} cannot be negative")
## Validate tax_rate and discount
if not isinstance(tax_rate, (int, float)):
raise TypeError("Tax rate must be a number")
if not isinstance(discount, (int, float)):
raise TypeError("Discount must be a number")
if not (0 <= tax_rate <= 100):
raise ValueError("Tax rate must be between 0 and 100")
if not (0 <= discount <= 100):
raise ValueError("Discount must be between 0 and 100")
## Calculate the total
subtotal = sum(price for _, price in items)
discount_amount = subtotal * (discount / 100)
tax_amount = (subtotal - discount_amount) * (tax_rate / 100)
total = subtotal - discount_amount + tax_amount
return {
"subtotal": subtotal,
"discount_amount": discount_amount,
"tax_amount": tax_amount,
"total": total
}
## Test with valid inputs
shopping_cart = [
("Laptop", 1000),
("Mouse", 25),
("Keyboard", 45)
]
try:
result = calculate_total_cost(shopping_cart, tax_rate=8.5, discount=10)
print("Shopping Cart Total:")
for key, value in result.items():
print(f" {key.replace('_', ' ').title()}: ${value:.2f}")
except (TypeError, ValueError) as e:
print(f"Error: {e}")
## Test with invalid item
try:
invalid_cart = [
("Laptop", 1000),
("Mouse", "twenty-five"), ## Invalid price
("Keyboard", 45)
]
result = calculate_total_cost(invalid_cart)
print(result)
except (TypeError, ValueError) as e:
print(f"Error with invalid item: {e}")Сохраните и запустите:
python3 validate_args.pyВывод:
Shopping Cart Total:
Subtotal: $1070.00
Discount Amount: $107.00
Tax Amount: $81.86
Total: $1044.86
Error with invalid item: Price of item 1 must be a numberЭта функция демонстрирует надежную проверку, выполняя следующее:
Внедряя тщательную проверку в свои функции, вы можете предотвратить ошибки, предоставлять пользователям лучшую обратную связь и сделать свой код более надежным и удобным в обслуживании.
Теперь, когда мы изучили различные методы обработки и проверки аргументов функций, давайте применим эти навыки для создания простого, но завершенного приложения. Мы создадим базовую систему отслеживания расходов, которая демонстрирует лучшие практики обработки аргументов функций.
Давайте создадим новый файл Python для нашего трекера расходов:
expense_tracker.py в качестве имени файлаНаш трекер расходов будет иметь несколько функций, которые обрабатывают различные аспекты управления расходами:
def create_expense(description, amount, category=None, date=None):
"""
Create a new expense entry.
Args:
description (str): Description of the expense
amount (float): The amount spent
category (str, optional): Category of the expense
date (str, optional): The date in YYYY-MM-DD format
Returns:
dict: An expense entry
"""
## Validate description
if not isinstance(description, str):
raise TypeError("Description must be a string")
if not description:
raise ValueError("Description cannot be empty")
## Validate amount
if not isinstance(amount, (int, float)):
raise TypeError("Amount must be a number")
if amount <= 0:
raise ValueError("Amount must be positive")
## Create the expense dictionary
expense = {
"description": description,
"amount": float(amount),
"category": category or "Uncategorized",
"date": date or "Not specified"
}
return expense
def add_expense_to_list(expenses, **kwargs):
"""
Add a new expense to the expenses list.
Args:
expenses (list): The list of expenses
**kwargs: The expense details to be passed to create_expense
Returns:
list: The updated list of expenses
"""
## Validate the expenses list
if not isinstance(expenses, list):
raise TypeError("Expenses must be a list")
## Extract required arguments
if "description" not in kwargs:
raise ValueError("Expense description is required")
if "amount" not in kwargs:
raise ValueError("Expense amount is required")
## Create the expense and add it to the list
expense = create_expense(
kwargs["description"],
kwargs["amount"],
kwargs.get("category"),
kwargs.get("date")
)
expenses.append(expense)
return expenses
def get_total_expenses(expenses, category=None):
"""
Calculate the total amount of expenses, optionally filtered by category.
Args:
expenses (list): The list of expenses
category (str, optional): Filter by this category if provided
Returns:
float: The total amount
"""
## Validate the expenses list
if not isinstance(expenses, list):
raise TypeError("Expenses must be a list")
## Calculate the total
if category:
return sum(e["amount"] for e in expenses if e["category"] == category)
else:
return sum(e["amount"] for e in expenses)
def get_expense_summary(expenses):
"""
Get a summary of expenses by category.
Args:
expenses (list): The list of expenses
Returns:
dict: A dictionary with categories as keys and total amounts as values
"""
## Validate the expenses list
if not isinstance(expenses, list):
raise TypeError("Expenses must be a list")
## Create the summary
summary = {}
for expense in expenses:
category = expense["category"]
if category in summary:
summary[category] += expense["amount"]
else:
summary[category] = expense["amount"]
return summaryТеперь давайте используем наши функции для отслеживания некоторых расходов:
def print_expense_summary(summary):
"""Print a formatted summary of expenses by category."""
print("\nExpense Summary by Category:")
print("-" * 30)
for category, amount in summary.items():
print(f"{category}: ${amount:.2f}")
print("-" * 30)
print(f"Total: ${sum(summary.values()):.2f}")
## Initialize an empty expenses list
expenses = []
## Add some expenses
try:
## Add with required arguments only
expenses = add_expense_to_list(
expenses,
description="Groceries",
amount=45.75
)
## Add with all arguments
expenses = add_expense_to_list(
expenses,
description="Movie tickets",
amount=25.00,
category="Entertainment",
date="2023-11-15"
)
## Add another expense
expenses = add_expense_to_list(
expenses,
description="Dinner",
amount=65.40,
category="Food",
date="2023-11-14"
)
## Add with default category
expenses = add_expense_to_list(
expenses,
description="Gas",
amount=35.80,
date="2023-11-16"
)
## Display all expenses
print("All Expenses:")
for i, expense in enumerate(expenses, 1):
print(f"{i}. {expense['description']}: ${expense['amount']:.2f} " +
f"({expense['category']}, {expense['date']})")
## Get and display the total
total = get_total_expenses(expenses)
print(f"\nTotal expenses: ${total:.2f}")
## Get and display expenses for a specific category
food_total = get_total_expenses(expenses, "Food")
print(f"Food expenses: ${food_total:.2f}")
## Get and display the summary
summary = get_expense_summary(expenses)
print_expense_summary(summary)
except (TypeError, ValueError) as e:
print(f"Error: {e}")Давайте также добавим некоторый код для демонстрации обработки ошибок:
## Try some invalid inputs
print("\nTesting error handling:")
try:
## Invalid expense description
expenses = add_expense_to_list(expenses, description="", amount=10)
except ValueError as e:
print(f"Caught error: {e}")
try:
## Invalid expense amount
expenses = add_expense_to_list(expenses, description="Coffee", amount=-5)
except ValueError as e:
print(f"Caught error: {e}")
try:
## Missing required argument
expenses = add_expense_to_list(expenses, description="Coffee")
except ValueError as e:
print(f"Caught error: {e}")Сохраните файл и запустите:
python3 expense_tracker.pyОжидаемый вывод:
All Expenses:
1. Groceries: $45.75 (Uncategorized, Not specified)
2. Movie tickets: $25.00 (Entertainment, 2023-11-15)
3. Dinner: $65.40 (Food, 2023-11-14)
4. Gas: $35.80 (Uncategorized, 2023-11-16)
Total expenses: $171.95
Food expenses: $65.40
Expense Summary by Category:
------------------------------
Uncategorized: $81.55
Entertainment: $25.00
Food: $65.40
------------------------------
Total: $171.95
Testing error handling:
Caught error: Description cannot be empty
Caught error: Amount must be positive
Caught error: Expense amount is requiredНаш трекер расходов демонстрирует несколько важных концепций:
Проверка аргументов (Argument validation): Каждая функция проверяет свои аргументы, чтобы убедиться, что они соответствуют ожидаемым типам и ограничениям.
Значения по умолчанию (Default values): Мы используем значения по умолчанию, чтобы сделать определенные аргументы необязательными, например, category и date.
Обязательные аргументы (Required arguments): Для важной информации, такой как description и amount, мы гарантируем, что они предоставлены и действительны.
Ключевые аргументы (Keyword arguments): Функция add_expense_to_list использует **kwargs, чтобы принимать детали расходов гибким способом.
Обработка ошибок (Error handling): Мы используем соответствующие исключения со значимыми сообщениями об ошибках, чтобы упростить отладку.
Строки документации (Docstrings): Каждая функция включает в себя строку документации, которая объясняет ее назначение, аргументы и возвращаемые значения.
Применяя эти методы, мы создали надежное приложение, которое обрабатывает аргументы функций надежным и удобным для пользователя способом. Этот подход помогает предотвратить ошибки, улучшает удобство сопровождения кода и предоставляет четкую обратную связь, когда что-то идет не так.
В этом руководстве вы изучили основные методы обработки отсутствующих или недопустимых аргументов функций в Python:
Понимание базовых аргументов функций и значений по умолчанию: Вы изучили различные типы аргументов функций, включая обязательные аргументы, необязательные аргументы со значениями по умолчанию и ключевые аргументы. Этот фундамент помогает вам разрабатывать функции, которые являются одновременно гибкими и удобными для пользователя.
Обработка переменного количества аргументов: Вы узнали, как использовать *args и **kwargs для создания функций, которые могут принимать любое количество аргументов, делая ваши функции более адаптируемыми к различным вариантам использования.
Проверка аргументов функций: Вы реализовали различные методы проверки, чтобы убедиться, что аргументы соответствуют ожидаемым типам и ограничениям, что помогает предотвратить ошибки и предоставлять понятные сообщения об ошибках.
Создание завершенного приложения: Вы применили эти концепции для создания практического приложения для отслеживания расходов, демонстрируя, как правильная обработка аргументов приводит к надежному и удобному в обслуживании коду.
Эти навыки являются основополагающими для написания надежного кода на Python. Правильно обрабатывая аргументы функций, вы можете создавать функции, которые являются более гибкими, простыми в использовании и менее подвержены ошибкам. По мере продолжения вашего пути в Python эти методы помогут вам создавать более сложные приложения, которые могут изящно обрабатывать непредвиденные входные данные и крайние случаи.
