In this section:
- Basics
- Type syntax for docstrings
- Specifying types of parameters
- Specifying return types
- Specifying types of local variables
- Specifying types of fields
Basics
Python is dynamically typed. That's why one doesn't need to specify variable types explicitly. However, it is possible to
use docstrings (reStructuredText,
epytext
) and
Python 3 function annotations
to specify information
about the expected types of the following values:
- parameters passed to a function
- return values
- local variables
- fields
PyCharm suggests code completion with these expected types.
PyCharm has preliminary support for type hinting using function annotations as specified by
PEP 484. (see PY-15206
for updates)
Type syntax for docstrings
Type syntax in Python docstrings is not defined by any standard. Thus, PyCharm suggests the following notation:
Syntax | Description |
---|---|
Foo | Class Foo visible in the current scope |
x.y.Bar | Class Bar from x.y module |
Foo | Bar | Foo or Bar |
(Foo, Bar) | Tuple of Foo and Bar |
list[Foo] | List of Foo elements |
dict[Foo, Bar] | Dict from Foo to Bar |
T | Generic type (T-Z are reserved for generics) |
T <= Foo | Generic type with upper bound Foo |
Foo[T] | Foo parameterized with T |
(Foo, Bar) -> Baz | Function of Foo and Bar that returns Baz |
list[dict[str, datetime]] | List of dicts from str to datetime (nested arguments) |
Specifying types of parameters
Consider adding information about the expected parameter type. This information is specified using :type
or
@type
docstrings, for example, :param "type_name" "param_name": "param_description"
.
When Python 3 is specified as the project interpreter, you can also use annotations to specify the expected parameter type:
Specifying return types
Use docstrings :rtype
or @rtype
to specify the expected return type:
:rtype: collections.Iterable[int] # return type
: 'items' is of typegenerator
orcollections.Iterable
, 'a' is of typeint
, see the following code:def my_iter(): for i in range(10): yield i items = my_iter() for a in items: print a
- :rtype: list[int] for my_iter # return type: 'a' is of type
int
, see the following code:def my_iter(): for i in range(10): yield i for a in my_iter(): print a
When Python 3 is specified as the project interpreter, you can use annotations to specify the expected return type:
Specifying types of local variables
Consider adding information about the expected type of a local variable using :type
or @type
docstrings:

It is also possible to use isinstance
to define the expected local variable type:

Specifying types of fields
Finally, you can use type hinting to specify the expected type of fields:

Alternatively, you can specify types of fields in the docstring of a class: