|
| 1 | +--- |
| 2 | +id: generics |
| 3 | +title: Generics |
| 4 | +sidebar_label: Generics |
| 5 | +sidebar_position: 4 |
| 6 | +tags: [python, generics, type hints, type safety, code flexibility] |
| 7 | +description: In this tutorial, you will learn about generics in Python. We will cover how to define functions, classes, or methods that can operate on multiple types while maintaining type safety using type hints and type variables. |
| 8 | +--- |
| 9 | + |
| 10 | +In Python, generics is a mechanism with which you to define functions, classes, or methods that can operate on multiple types while maintaining type safety. With the implementation of Generics enable it is possible to write reusable code that can be used with different data types. It ensures promoting code flexibility and type correctness. |
| 11 | + |
| 12 | +Generics in Python are implemented using type hints. This feature was introduced in Python with version 3.5 onwards. |
| 13 | + |
| 14 | +Normally, you don't need to declare a variable type. The type is determined dynamically by the value assigned to it. Python's interpreter doesn't perform type checks and hence it may raise runtime exceptions. |
| 15 | + |
| 16 | +Python's new type hinting feature helps in prompting the user with the expected type of the parameters to be passed. |
| 17 | + |
| 18 | +Type hints allow you to specify the expected types of variables, function arguments, and return values. Generics extend this capability by introducing type variables, which represent generic types that can be replaced with specific types when using the generic function or class. |
| 19 | + |
| 20 | +## Example 1 |
| 21 | + |
| 22 | +Let us have a look at the following example that defines a generic function − |
| 23 | + |
| 24 | +```python |
| 25 | +from typing import List, TypeVar |
| 26 | + |
| 27 | +T = TypeVar('T') |
| 28 | + |
| 29 | +def reverse(items: List[T]) -> List[T]: |
| 30 | + return items[::-1] |
| 31 | +``` |
| 32 | + |
| 33 | +Here, we define a generic function called 'reverse'. The function takes a list ('List[T]') as an argument and returns a list of the same type. The type variable 'T' represents the generic type, which will be replaced with a specific type when the function is used. |
| 34 | + |
| 35 | +## Example 2 |
| 36 | + |
| 37 | +The function `reverse()` function is called with different data types − |
| 38 | + |
| 39 | +```python |
| 40 | +numbers = [1, 2, 3, 4, 5] |
| 41 | +reversed_numbers = reverse(numbers) |
| 42 | +print(reversed_numbers) |
| 43 | + |
| 44 | +fruits = ['apple', 'banana', 'cherry'] |
| 45 | +reversed_fruits = reverse(fruits) |
| 46 | +print(reversed_fruits) |
| 47 | +``` |
| 48 | + |
| 49 | +It will produce the following output − |
| 50 | + |
| 51 | +``` |
| 52 | +[5, 4, 3, 2, 1] |
| 53 | +['cherry', 'banana', 'apple'] |
| 54 | +``` |
| 55 | + |
| 56 | +## Example 3 |
| 57 | + |
| 58 | +The following example uses generics with a generic class − |
| 59 | + |
| 60 | +```python |
| 61 | +from typing import TypeVar, Generic |
| 62 | + |
| 63 | +T = TypeVar('T') |
| 64 | + |
| 65 | +class Box(Generic[T]): |
| 66 | + def __init__(self, item: T): |
| 67 | + self.item = item |
| 68 | + |
| 69 | + def get_item(self) -> T: |
| 70 | + return self.item |
| 71 | +``` |
| 72 | + |
| 73 | +Let us create objects of the above generic class with `int` and `str` type |
| 74 | + |
| 75 | +```python |
| 76 | +box1 = Box(42) |
| 77 | +print(box1.get_item()) |
| 78 | + |
| 79 | +box2 = Box('Hello') |
| 80 | +print(box2.get_item()) |
| 81 | +``` |
| 82 | + |
| 83 | +It will produce the following output − |
| 84 | + |
| 85 | +``` |
| 86 | +42 |
| 87 | +Hello |
| 88 | +``` |
0 commit comments