What are type hints in Python 3 5

Question

One of the most talked-about features in Python 3.5 is type hints.

An example of type hints is mentioned in this article and this one while also mentioning to use type hints responsibly. Can someone explain more about them and when they should be used and when not?

User · Answer

Type hint are a recent addition to a dynamic language where for decades folks swore naming conventions as simple as Hungarian  object label with first letter b   Boolean  c   character  d   dictionary  i   integer  l   list  n   numeric  s   string  t  tuple  were not needed  too cumbersome  but now have decided that  oh wait     it is way too much trouble to use the language  type    to recognize objects  and our fancy IDEs need help doing anything that complicated  and that dynamically assigned object values make them completely useless anyhow  whereas a simple naming convention could have resolved all of it  for any developer  at a mere glance

User · Answer

The newly released PyCharm 5 supports type hinting. In their blog post about it (see Python 3.5 type hinting in PyCharm 5) they offer a great explanation of what type hints are and aren't along with several examples and illustrations for how to use them in your code.

Additionally, it is supported in Python 2.7, as explained in this comment:

PyCharm supports the typing module from PyPI for Python 2.7, Python 3.2-3.4. For 2.7 you have to put type hints in *.pyi stub files since function annotations were added in Python 3.0.

User · Answer

Adding to Jim s elaborate answer  Check the typing module -- this module supports type hints as specified by PEP 484  For example  the function below takes and returns values of type str and is annotated as follows  def greeting name  str  - gt  str      return  Hello     name  The typing module also supports   Type aliasing  Type hinting for callback functions  Generics - Abstract base classes have been extended to support subscription to denote expected types for container elements  User-defined generic types - A user-defined class can be defined as a generic class  Any type - Every type is a subtype of Any

User · Answer

I would suggest reading PEP 483 and PEP 484 and watching this presentation by Guido on type hinting  In a nutshell  Type hinting is literally what the words mean  You hint the type of the object s  you re using  Due to the dynamic nature of Python  inferring or checking the type of an object being used is especially hard  This fact makes it hard for developers to understand what exactly is going on in code they haven t written and  most importantly  for type checking tools found in many IDEs  PyCharm and PyDev come to mind  that are limited due to the fact that they don t have any indicator of what type the objects are  As a result they resort to trying to infer the type with  as mentioned in the presentation  around 50  success rate   To take two important slides from the type hinting presentation  Why type hints   Helps type checkers  By hinting at what type you want the object to be the type checker can easily detect if  for instance  you re passing an object with a type that isn t expected  Helps with documentation  A third person viewing your code will know what is expected where  ergo  how to use it without getting them TypeErrors  Helps IDEs develop more accurate and robust tools  Development Environments will be better suited at suggesting appropriate methods when know what type your object is  You have probably experienced this with some IDE at some point  hitting the   and having methods attributes pop up which aren t defined for an object   Why use static type checkers   Find bugs sooner  This is self-evident  I believe  The larger your project the more you need it  Again  makes sense  Static languages offer a robustness and control that dynamic languages lack  The bigger and more complex your application becomes the more control and predictability  from a behavioral aspect  you require  Large teams are already running static analysis  I m guessing this verifies the first two points   As a closing note for this small introduction  This is an optional feature and  from what I understand  it has been introduced in order to reap some of the benefits of static typing  You generally do not need to worry about it and definitely don t need to use it  especially in cases where you use Python as an auxiliary scripting language   It should be helpful when developing large projects as it offers much needed robustness  control and additional debugging capabilities   Type hinting with mypy  In order to make this answer more complete  I think a little demonstration would be suitable  I ll be using mypy  the library which inspired Type Hints as they are presented in the PEP  This is mainly written for anybody bumping into this question and wondering where to begin  Before I do that let me reiterate the following  PEP 484 doesn t enforce anything  it is simply setting a direction for function annotations and proposing guidelines for how type checking can should be performed  You can annotate your functions and hint as many things as you want  your scripts will still run regardless of the presence of annotations because Python itself doesn t use them  Anyways  as noted in the PEP  hinting types should generally take three forms   Function annotations  PEP 3107   Stub files for built-in user modules  Special    type  type comments that complement the first two forms   See  What are variable annotations  for a Python 3 6 update for   type  type comments   Additionally  you ll want to use type hints in conjunction with the new typing module introduced in Py3 5  In it  many  additional  ABCs  abstract base classes  are defined along with helper functions and decorators for use in static checking  Most ABCs in collections abc are included  but in a generic form in order to allow subscription  by defining a   getitem     method   For anyone interested in a more in-depth explanation of these  the mypy documentation is written very nicely and has a lot of code samples demonstrating describing the functionality of their checker  it is definitely worth a read  Function annotations and special comments  First  it s interesting to observe some of the behavior we can get when using special comments  Special   type  type comments can be added during variable assignments to indicate the type of an object if one cannot be directly inferred  Simple assignments are generally easily inferred but others  like lists  with regard to their contents   cannot  Note  If we want to use any derivative of containers and need to specify the contents for that container we must use the generic types from the typing module  These support indexing    Generic List  supports indexing  from typing import List    In this case  the type is easily inferred as type  int  i   0    Even though the type can be inferred as of type list   there is no way to know the contents of this list    By using type  List str  we indicate we want to use a list of strings  a         type  List str     Appending an int to our list   is statically not correct  a append i     Appending a string is fine  a append  quot i quot    print a      0   i    If we add these commands to a file and execute them with our interpreter  everything works just fine and print a  just prints the contents of list a  The   type comments have been discarded  treated as plain comments which have no additional semantic meaning  By running this with mypy  on the other hand  we get the following response   Python3 jimmi jim  mypy typeHintsCode py typesInline py 14  error  Argument 1 to  quot append quot  of  quot list quot  has incompatible type  quot int quot   expected  quot str quot   Indicating that a list of str objects cannot contain an int  which  statically speaking  is sound  This can be fixed by either abiding to the type of a and only appending str objects or by changing the type of the contents of a to indicate that any value is acceptable  Intuitively performed with List Any  after Any has been imported from typing   Function annotations are added in the form param name   type after each parameter in your function signature and a return type is specified using the - gt  type notation before the ending function colon  all annotations are stored in the   annotations   attribute for that function in a handy dictionary form  Using a trivial example  which doesn t require extra types from the typing module   def annotated x  int  y  str  - gt  bool      return x  lt  y  The annotated   annotations   attribute now has the following values    y    lt class  str  gt    return    lt class  bool  gt    x    lt class  int  gt    If we re a complete newbie  or we are familiar with Python  2 7 concepts and are consequently unaware of the TypeError lurking in the comparison of annotated  we can perform another static check  catch the error and save us some trouble   Python3 jimmi jim  mypy typeHintsCode py typeFunction py  note  In function  quot annotated quot   typeFunction py 2  error  Unsupported operand types for  gt    quot str quot  and  quot int quot    Among other things  calling the function with invalid arguments will also get caught  annotated 20  20     mypy complains  typeHintsCode py 4  error  Argument 2 to  quot annotated quot  has incompatible type  quot int quot   expected  quot str quot   These can be extended to basically any use case and the errors caught extend further than basic calls and operations  The types you can check for are really flexible and I have merely given a small sneak peak of its potential  A look in the typing module  the PEPs or the mypy documentation will give you a more comprehensive idea of the capabilities offered  Stub files  Stub files can be used in two different non mutually exclusive cases   You need to type check a module for which you do not want to directly alter the function signatures You want to write modules and have type-checking but additionally want to separate annotations from content   What stub files  with an extension of  pyi  are is an annotated interface of the module you are making want to use  They contain the signatures of the functions you want to type-check with the body of the functions discarded  To get a feel of this  given a set of three random functions in a module named randfunc py  def message s       print s   def alterContents myIterable       return  i for i in myIterable if i   2    0   def combine messageFunc  itFunc       messageFunc  quot Printing the Iterable quot       a   alterContents range 1  20       return set a   We can create a stub file randfunc pyi  in which we can place some restrictions if we wish to do so  The downside is that somebody viewing the source without the stub won t really get that annotation assistance when trying to understand what is supposed to be passed where  Anyway  the structure of a stub file is pretty simplistic  Add all function definitions with empty bodies  pass filled  and supply the annotations based on your requirements  Here  let s assume we only want to work with int types for our Containers    Stub for randfucn py from typing import Iterable  List  Set  Callable  def message s  str  - gt  None  pass  def alterContents myIterable  Iterable int  - gt  List int   pass  def combine      messageFunc  Callable  str   Any       itFunc  Callable  Iterable int    List int    - gt  Set int   pass  The combine function gives an indication of why you might want to use annotations in a different file  they some times clutter up the code and reduce readability  big no-no for Python   You could of course use type aliases but that sometime confuses more than it helps  so use them wisely    This should get you familiarized with the basic concepts of type hints in Python  Even though the type checker used has been mypy you should gradually start to see more of them pop-up  some internally in IDEs  PyCharm   and others as standard Python modules  I ll try and add additional checkers related packages in the following list when and if I find them  or if suggested   Checkers I know of   Mypy  as described here  PyType  By Google  uses different notation from what I gather  probably worth a look   Related Packages Projects   typeshed  Official Python repository housing an assortment of stub files for the standard library   The typeshed project is actually one of the best places you can look to see how type hinting might be used in a project of your own  Let s take as an example the   init   dunders of the Counter class in the corresponding  pyi file  class Counter Dict  T  int   Generic  T             overload         def   init   self  - gt  None               overload         def   init   self  Mapping  Mapping  T  int   - gt  None               overload         def   init   self  iterable  Iterable  T   - gt  None       Where  T   TypeVar   T   is used to define generic classes  For the Counter class we can see that it can either take no arguments in its initializer  get a single Mapping from any type to an int or take an Iterable of any type   Notice  One thing I forgot to mention was that the typing module has been introduced on a provisional basis  From PEP 411   A provisional package may have its API modified prior to  quot graduating quot  into a  quot stable quot  state  On one hand  this state provides the package with the benefits of being formally part of the Python distribution  On the other hand  the core development team explicitly states that no promises are made with regards to the the stability of the package s API  which may change for the next release  While it is considered an unlikely outcome  such packages may even be removed from the standard library without a deprecation period if the concerns regarding their API or maintenance prove well-founded   So take things here with a pinch of salt  I m doubtful it will be removed  or altered in significant ways  but one can never know      Another topic altogether  but valid in the scope of type-hints  PEP 526  Syntax for Variable Annotations is an effort to replace   type comments by introducing new syntax which allows users to annotate the type of variables in simple varname  type statements  See What are variable annotations   as previously mentioned  for a small introduction to these

User · Answer

Type hints are for maintainability and don t get interpreted by Python  In the code below  the line def add self  ic int  doesn t result in an error until the next return    line  class C1      def   init   self           self idn   1     def add self  ic  int           return self idn   ic  c1   C1   c1 add 2   c1 add c1   Traceback  most recent call last     File  quot  lt input gt  quot   line 1  in  lt module gt    File  quot  lt input gt  quot   line 5  in add TypeError  unsupported operand type s  for     int  and  C1

[python] What are type hints in Python 3.5?

The answer is

Examples related to python

Examples related to python-3.x

Examples related to python-3.5

Examples related to type-hinting

Tags