Python: Type Annotations

Type annotations are an ability to specify parameter types and return values for functions in Python. This is not a mandatorType annotations allow programmers to specify parameter types and return values for functions in Python. It is not a mandatory requirement of the language, but it can help programmers in further development, improve the readability of the code and increase its reliability.

Let's look at a simple example of a function without type annotations:

def concat(first, second):
    return first + second

This function concatenates two strings into one. At first glance, it is hard to understand what is going on in the code: what types the arguments have, why the function works with strings and not adding, for example, two numbers.

If we use it further in the code, we should check the types of arguments before passing them to the function. It increases the size of the code and makes it harder to understand.

Now let's add type annotations to the function:

def concat(first: str, second: str) -> str:
    return first + second

Here we have specified that the arguments first and second must be of string type (str). The return value will also be of string type. When we use this function in code, it will be easier to understand what argument types we can pass and what return value type we expect.

We also can use type annotations to define variable types within a function. For example::

def double(n: int) -> int:
    result: int = n * 2
    return result

In this example, we have defined the type of the result variable as int using type annotation.

Type annotations are not strict type-checking in Python. They do not guarantee that we will call a function with arguments and return values of the specified types. After all, Python is still a dynamically typed language. Type annotations in Python do not affect the ability to pass different argument types or to return values of different types. However, their use helps to track down errors and makes the code more readable.

Instructions

Implement a function, word_multiply(). It should accept two parameters:

• A word
• A number representing how many times to repeat the word

text = 'python'
print(word_multiply(text, 2)) # => pythonpython
print(word_multiply(text, 0)) # => 

Specify type annotations when declaring a function.