A slightly modified example from the Python documentation shows best how to define and retrieve function annotations:

>>> def f(ham: str, eggs: str = 'eggs') -> str:
... pass
... 
>>> print(f.__annotations__)
{'return': <class 'str'>, 'eggs': <class 'str'>, 'ham': <class 'str'>}

As presented, parameter annotations are defined by the expression evaluating to the value of the annotation preceded by a colon. Return annotations are defined by the expression between the colon denoting the end of the def statement and literal -> that follows the parameter list.

Once defined, annotations are available in the __annotations__ attribute of the function object as a dictionary and can be retrieved during application runtime.

The fact that any expression can be used as the annotation and it is located just near the default arguments allows to create some confusing function definitions as follows:

>>> def square(number: 0<=3 and 1=0) -> (\
... +9000): return number**2
>>> square(10)
100

However, such usage of annotations serves no other purpose than obfuscation and even without them it is relatively easy to write code that is hard to read and maintain.

While annotations have a great potential, they are not widely used. An article explaining new features added to Python 3 (refer to https://docs.python.org/3/whatsnew/3.0.html) says that the intent of this feature was "to encourage experimentation through metaclasses, decorators, or frameworks". On the other hand, PEP 3107 that officially proposed function annotations lists the following set of possible use cases:

Although the function annotations are as old as Python 3, it is still very hard to find any popular and actively maintained package that uses them for something else than type checking. So function annotations are still mostly good only for experimentation and playing—the initial purpose why they were included in initial release of Python 3.