Pythonプログラム練習問題10選：アノテーションを活用してコードの品質を高めよう

www.amazon.co.jp

Python プログラム練習問題 10 選：アノテーションを活用してコードの品質を高めよう

Python プログラム練習問題 10 選：アノテーションを活用してコードの品質を高めよう

Python は汎用性の高いプログラミング言語であり、その柔軟性ゆえに様々な書き方が可能です。しかし、コードが複雑になるにつれて、可読性や保守性が低下する可能性があります。そこで役立つのが「アノテーション (Annotation)」です。本記事では、アノテーションの基礎から応用までを解説しつつ、Python プログラム練習問題 10 選を通して、アノテーションを活用してコードの品質を高める方法を紹介します。

1. アノテーションとは？

アノテーションは、Python 3.5 以降で導入された機能で、関数やメソッドの引数、返り値に対して型情報などのメタデータを付与することができます。アノテーション自体は Python インタプリタによって実行されるわけではなく、あくまでコードを読みやすくしたり、静的解析ツール (mypy など) を利用して型エラーを検出したりするために用いられます。

アノテーションの基本的な書き方:

def greet(name: str) -> str:
  """挨拶文を返す関数"""
  return "Hello, " + name + "!"

# 例：
message = greet("Alice")
print(message) # Output: Hello, Alice!

この例では、greet 関数の引数 name には型アノテーション : str が付与され、返り値には型アノテーション -> str が付与されています。これにより、name は文字列であるべきであり、関数が文字列を返すことが明確になります。

What is Annotation?

Annotation, introduced in Python 3.5 and later, allows you to add metadata like type information to function arguments and return values. The annotation itself isn't executed by the Python interpreter; instead, it enhances code readability and enables static analysis tools (like mypy) to detect type errors.

2. アノテーションの種類と用途

アノテーションは、単なる型情報だけでなく、様々な情報を付与することができます。以下に代表的な種類とその用途を紹介します。

型アノテーション (Type Annotation): 引数や返り値の型を指定します。mypy などの静的解析ツールによる型チェックに利用されます。
デフォルト値アノテーション (Default Value Annotation): 引数のデフォルト値を指定します。Python の標準的なデフォルト値の指定とは異なり、より詳細な情報を記述できます。
オプション型アノテーション (Optional Type Annotation): 引数や返り値が None を許容する場合に利用します。Union[str, None] や Optional[str] などの表記を用います。
リスト/タプル/辞書のアノテーション: リスト、タプル、辞書の要素の型を指定します。List[int], Tuple[str, int], Dict[str, float] のように記述します。
カスタムアノテーション: 独自のメタデータを付与するために使用します。

Types of Annotations and Their Uses

Annotations can convey various types of information beyond simple type hints. Here's a breakdown of common types and their purposes:

Type Annotation: Specifies the type of arguments or return values. Used by static analysis tools like mypy for type checking.
Default Value Annotation: Defines default values for arguments, allowing for more detailed information than standard Python default value assignments.
Optional Type Annotation: Indicates that an argument or return value can be None. Uses notations like Union[str, None] or Optional[str].
List/Tuple/Dictionary Annotations: Specifies the types of elements within lists, tuples, and dictionaries. Examples include List[int], Tuple[str, int], and Dict[str, float].
Custom Annotation: Used to attach custom metadata for specific purposes.

3. アノテーションを活用するメリット

アノテーションを導入することで、以下のようなメリットが得られます。

コードの可読性向上: 引数や返り値の型が明確になるため、コードを読む人が意図を理解しやすくなります。
静的解析によるエラー検出: mypy などの静的解析ツールを利用して、実行前に型エラーを発見することができます。これにより、バグの早期発見と修正が可能になります。
IDE のサポート強化: IDE (統合開発環境) がアノテーションを認識することで、コード補完やリファクタリングなどの機能が向上します。
ドキュメント生成の効率化: アノテーションから自動的にドキュメントを生成することができます。

Benefits of Using Annotations

Introducing annotations provides several advantages:

Improved Code Readability: Clear type information for arguments and return values makes it easier for readers to understand the code's intent.
Early Error Detection through Static Analysis: Static analysis tools like mypy can detect type errors before runtime, enabling early bug detection and correction.
Enhanced IDE Support: IDEs recognize annotations, improving features such as code completion and refactoring.
Efficient Documentation Generation: Annotations can be automatically used to generate documentation.

4. Python プログラム練習問題 10 選 (アノテーション活用)

それでは、アノテーションを活用した Python プログラム練習問題を 10 問紹介します。各問題には難易度と解答例を示し、解説を加えます。

問題 1: 簡単な型アノテーション (難易度: 低)

def add(x: int, y: int) -> int:
  """2つの整数の和を返す関数"""
  return x + y

# 例：
result = add(5, 3)
print(result) # Output: 8

解説: add 関数の引数 x と y には型アノテーション : int を、返り値には型アノテーション -> int を付与しています。これにより、関数が整数を受け取り、整数を返すことが明確になります。

Problem 1: Simple Type Annotation (Difficulty: Easy)

def add(x: int, y: int) -> int:
  """Returns the sum of two integers."""
  return x + y

# Example:
result = add(5, 3)
print(result) # Output: 8

Explanation: The add function has type annotations : int for both arguments x and y, and a return type annotation -> int. This clearly indicates that the function accepts integers as input and returns an integer.

問題 2: 文字列の結合と型アノテーション (難易度: 低)

def full_name(first_name: str, last_name: str) -> str:
  """名前を結合してフルネームを返す関数"""
  return first_name + " " + last_name

# 例：
full = full_name("John", "Doe")
print(full) # Output: John Doe

解説: first_name と last_name には型アノテーション : str を、返り値には型アノテーション -> str を付与しています。

Problem 2: String Concatenation and Type Annotation (Difficulty: Easy)

def full_name(first_name: str, last_name: str) -> str:
  """Concatenates names to return a full name."""
  return first_name + " " + last_name

# Example:
full = full_name("John", "Doe")
print(full) # Output: John Doe

Explanation: The first_name and last_name arguments are annotated with : str, and the return value is annotated with -> str. This clarifies that the function expects strings as input and returns a string.

問題 3: リストの要素の型指定 (難易度: 中)

def process_numbers(numbers: List[int]) -> int:
  """整数のリストを受け取り、合計を返す関数"""
  total = 0
  for number in numbers:
    total += number
  return total

# 例：
nums = [1, 2, 3, 4, 5]
sum_of_numbers = process_numbers(nums)
print(sum_of_numbers) # Output: 15

解説: numbers 引数には型アノテーション List[int] を付与しています。これにより、numbers が整数のリストであることを明示しています。 List は typing モジュールに含まれる型ヒントです。

Problem 3: Specifying the Type of List Elements (Difficulty: Medium)

def process_numbers(numbers: List[int]) -> int:
  """Receives a list of integers and returns their sum."""
  total = 0
  for number in numbers:
    total += number
  return total

# Example:
nums = [1, 2, 3, 4, 5]
sum_of_numbers = process_numbers(nums)
print(sum_of_numbers) # Output: 15

Explanation: The numbers argument is annotated with List[int], explicitly indicating that it expects a list of integers. List is a type hint from the typing module.

問題 4: オプション型の利用 (難易度: 中)

from typing import Optional

def get_name(id: int) -> Optional[str]:
  """ID に対応する名前を返す関数。存在しない場合は None を返す"""
  names = {1: "Alice", 2: "Bob"}
  return names.get(id)

# 例：
name1 = get_name(1)
print(name1) # Output: Alice

name2 = get_name(3)
print(name2) # Output: None

解説: get_name 関数の返り値には型アノテーション Optional[str] を付与しています。これにより、関数が文字列または None を返す可能性があることを明示しています。 Optional[T] は Union[T, None] と同じ意味です。

Problem 4: Using Optional Types (Difficulty: Medium)

from typing import Optional

def get_name(id: int) -> Optional[str]:
  """Returns a name corresponding to an ID. Returns None if not found."""
  names = {1: "Alice", 2: "Bob"}
  return names.get(id)

# Example:
name1 = get_name(1)
print(name1) # Output: Alice

name2 = get_name(3)
print(name2) # Output: None

Explanation: The return value of the get_name function is annotated with Optional[str], indicating that it can return either a string or None. Optional[T] is equivalent to Union[T, None].

問題 5: タプルの要素の型指定 (難易度: 中)

def get_coordinates() -> Tuple[float, float]:
  """ランダムな座標を返す関数"""
  import random
  x = random.random()
  y = random.random()
  return x, y

# 例：
coords = get_coordinates()
print(coords) # Output: (0.5678, 0.9123) など

解説: get_coordinates 関数の返り値には型アノテーション Tuple[float, float] を付与しています。これにより、関数が 2 つの浮動小数点数からなるタプルを返すことを明示しています。 Tuple は typing モジュールに含まれる型ヒントです。

Problem 5: Specifying the Types of Tuple Elements (Difficulty: Medium)

def get_coordinates() -> Tuple[float, float]:
  """Returns random coordinates."""
  import random
  x = random.random()
  y = random.random()
  return x, y

# Example:
coords = get_coordinates()
print(coords) # Output: (0.5678, 0.9123) etc.

Explanation: The return value of the get_coordinates function is annotated with Tuple[float, float], explicitly indicating that it returns a tuple containing two floating-point numbers. Tuple is a type hint from the typing module.

問題 6: 辞書のキーと値の型指定 (難易度: 中)

from typing import Dict

def count_words(text: str) -> Dict[str, int]:
  """文字列を受け取り、単語の出現回数をカウントする関数"""
  word_counts = {}
  for word in text.split():
    if word in word_counts:
      word_counts[word] += 1
    else:
      word_counts[word] = 1
  return word_counts

# 例：
text = "this is a test string this is"
word_counts = count_words(text)
print(word_counts) # Output: {'this': 2, 'is': 2, 'a': 1, 'test': 1, 'string': 1}

解説: count_words 関数の引数 text には型アノテーション : str を、返り値には型アノテーション Dict[str, int] を付与しています。これにより、関数が文字列を受け取り、キーが文字列で値が整数の辞書を返すことを明示しています。 Dict は typing モジュールに含まれる型ヒントです。

Problem 6: Specifying Dictionary Key and Value Types (Difficulty: Medium)

from typing import Dict

def count_words(text: str) -> Dict[str, int]:
  """Receives a string and counts the occurrences of each word."""
  word_counts = {}
  for word in text.split():
    if word in word_counts:
      word_counts[word] += 1
    else:
      word_counts[word] = 1
  return word_counts

# Example:
text = "this is a test string this is"
word_counts = count_words(text)
print(word_counts) # Output: {'this': 2, 'is': 2, 'a': 1, 'test': 1, 'string': 1}

Explanation: The text argument is annotated with : str, and the return value is annotated with Dict[str, int]. This clarifies that the function expects a string as input and returns a dictionary where keys are strings and values are integers. Dict is a type hint from the typing module.

問題 7: デフォルト値アノテーション (難易度: 高)

from typing import Optional

def greet(name: str = "Guest") -> str:
  """挨拶文を返す関数。名前が指定されていない場合はデフォルトのメッセージを返す"""
  return "Hello, " + name + "!"

# 例：
message1 = greet("Alice")
print(message1) # Output: Hello, Alice!

message2 = greet()
print(message2) # Output: Hello, Guest!

解説: greet 関数の引数 name には型アノテーション : str とデフォルト値 "Guest" を付与しています。これにより、名前が指定されなかった場合にデフォルトのメッセージを返すことが明確になります。

Problem 7: Using Default Value Annotations (Difficulty: High)

from typing import Optional

def greet(name: str = "Guest") -> str:
  """Returns a greeting message. Returns a default message if no name is provided."""
  return "Hello, " + name + "!"

# Example:
message1 = greet("Alice")
print(message1) # Output: Hello, Alice!

message2 = greet()
print(message2) # Output: Hello, Guest!

Explanation: The name argument is annotated with : str and a default value of "Guest". This clarifies that if no name is provided, the function will return a message using the default value.

問題 8: カスタムアノテーション (難易度: 高)

from typing import NewType

UserId = NewType('UserId', int)

def get_user(user_id: UserId) -> str:
  """ユーザー ID に対応するユーザー名を取得する関数"""
  # 実際にはデータベースなどから取得する処理を記述
  return "User with ID " + str(user_id)

# 例：
user_id = UserId(123)
username = get_user(user_id)
print(username) # Output: User with ID 123

解説: UserId は NewType を使用して定義されたカスタム型です。これにより、UserId 型は整数型を継承しつつ、異なる意味を持つ型として扱われます。 NewType は typing モジュールに含まれる型ヒントです。

Problem 8: Using Custom Annotations (Difficulty: High)

from typing import NewType

UserId = NewType('UserId', int)

def get_user(user_id: UserId) -> str:
  """Retrieves a username corresponding to a user ID."""
  # In reality, this would involve fetching data from a database etc.
  return "User with ID " + str(user_id)

# Example:
user_id = UserId(123)
username = get_user(user_id)
print(username) # Output: User with ID 123

Explanation: UserId is a custom type defined using NewType. This allows the UserId type to inherit from the integer type while still being treated as a distinct type with different meaning. NewType is a type hint from the typing module.

問題 9: Union 型 (難易度: 高)

from typing import Union

def process_value(value: Union[int, str]) -> str:
  """整数または文字列を受け取り、文字列に変換して返す関数"""
  return str(value)

# 例：
result1 = process_value(10)
print(result1) # Output: "10"

result2 = process_value("hello")
print(result2) # Output: "hello"

解説: process_value 関数の引数 value には型アノテーション Union[int, str] を付与しています。これにより、関数が整数または文字列を受け取ることを明示しています。 Union[T1, T2, ...] は、複数の型のいずれかの型であることを示す型ヒントです。

Problem 9: Using Union Types (Difficulty: High)

from typing import Union

def process_value(value: Union[int, str]) -> str:
  """Receives an integer or a string and returns it as a string."""
  return str(value)

# Example:
result1 = process_value(10)
print(result1) # Output: "10"

result2 = process_value("hello")
print(result2) # Output: "hello"

Explanation: The value argument is annotated with Union[int, str], explicitly indicating that it can accept either an integer or a string. Union[T1, T2, ...] is a type hint that indicates the type can be one of several types.

問題 10: Any 型 (難易度: 高)

from typing import Any

def process_anything(data: Any) -> None:
  """任意の型のデータを受け取り、何らかの処理を行う関数"""
  print("Processing data:", data)

# 例：
process_anything(123)
process_anything("hello")
process_anything([1, 2, 3])

解説: process_anything 関数の引数 data には型アノテーション Any を付与しています。これにより、関数が任意の型のデータを受け取ることを明示しています。 Any 型は、型チェックを完全に無視する型ヒントです。通常は、どうしても型を特定できない場合にのみ使用します。

Problem 10: Using the Any Type (Difficulty: High)

from typing import Any

def process_anything(data: Any) -> None:
  """Receives data of any type and performs some processing."""
  print("Processing data:", data)

# Example:
process_anything(123)
process_anything("hello")
process_anything([1, 2, 3])

Explanation: The data argument is annotated with Any. This explicitly indicates that the function accepts data of any type. The Any type effectively disables type checking for that parameter. It should be used sparingly when the type cannot be determined.

5. まとめ (Conclusion)

This article has explained annotations in Python and introduced practice problems to illustrate their use. By using annotations appropriately, you can improve code readability and maintainability, and efficiently detect errors with static analysis tools. We hope this blog post helps deepen your understanding of annotations and improves your Python programming skills.

References:

Python Type Hints (typing): https://docs.python.org/ja/3/library/typing.html
mypy: Static Type Checker: https://mypy.readthedocs.io/en/stable/

We hope these exercises and explanations are helpful in your journey to writing cleaner, more robust Python code! Remember that annotations are a powerful tool for improving the quality of your projects, especially as they grow in complexity. Don't hesitate to experiment with different types of annotations and explore how they can best fit into your coding style and workflow.

ななぶろ

-お役立ち情報を気楽に紹介するブログ-