cpython: cbcab1fb1b8a (original) (raw)

Mercurial > cpython

changeset 102557:cbcab1fb1b8a 3.5

Better docs for typing.Any by Michael Lee. Fixes issue #27688. [#27688]

Guido van Rossum guido@python.org
date	Sat, 06 Aug 2016 13:46:48 -0700
parents	d0402caa0ef5
children	f60e16663f6e e947248100ae
files	Doc/library/typing.rst
diffstat	1 files changed, 71 insertions(+), 9 deletions(-)[+] [-] Doc/library/typing.rst 80

line wrap: on

line diff

--- a/Doc/library/typing.rst +++ b/Doc/library/typing.rst @@ -279,17 +279,79 @@ conflict. Generic metaclasses are not s The :class:Any type --------------------- -A special kind of type is :class:Any. Every type is a subtype of -:class:Any. This is also true for the builtin type object. However, to the -static type checker these are completely different. +A special kind of type is :class:Any. A static type checker will treat +every type as being compatible with :class:Any and :class:Any as being +compatible with every type. + +This means that it is possible to perform any operation or method call on a +value of type on :class:Any and assign it to any variable:: +

from typing import Any +
a = None # type: Any
a = [] # OK
a = 2 # OK +
s = '' # type: str
s = a # OK +
def foo(item: Any) -> int:

  # Typechecks; `item` could be any type,[](#l1.27)

  # and that type might have a `bar` method[](#l1.28)

```
  item.bar()[](#l1.29)
```
```
  ...[](#l1.30)
```

+ +Notice that no typechecking is performed when assigning a value of type +:class:Any to a more precise type. For example, the static type checker did +not report an error when assigning a to s even though s was +declared to be of type :class:str and receives an :class:int value at +runtime + +Furthermore, all functions without a return type or parameter types will +implicitly default to using :class:Any:: +

def legacy_parser(text):
```
  ...[](#l1.42)
```
```
  return data[](#l1.43)
```

-When the type of a value is :class:object, the type checker will reject -almost all operations on it, and assigning it to a variable (or using it as a -return value) of a more specialized type is a type error. On the other hand, -when a value has type :class:Any, the type checker will allow all operations -on it, and a value of type :class:Any can be assigned to a variable (or used -as a return value) of a more constrained type.

A static type checker will treat the above
as having the same signature as:
def legacy_parser(text: Any) -> Any:
```
  ...[](#l1.54)
```
```
  return data[](#l1.55)
```

+ +This behavior allows :class:Any to be used as an escape hatch when you +need to mix dynamically and statically typed code. + +Contrast the behavior of :class:Any with the behavior of :class:object. +Similar to :class:Any, every type is a subtype of :class:object. However, +unlike :class:Any, the reverse is not true: :class:object is not a +subtype of every other type. + +That means when the type of a value is :class:object, a type checker will +reject almost all operations on it, and assigning it to a variable (or using +it as a return value) of a more specialized type is a type error. For example::

def hash_a(item: object) -> int:

  # Fails; an object does not have a `magic` method.[](#l1.70)

```
  item.magic()[](#l1.71)
```
```
  ...[](#l1.72)
```

def hash_b(item: Any) -> int:
```
  # Typechecks[](#l1.75)
```
```
  item.magic()[](#l1.76)
```
```
  ...[](#l1.77)
```

Typechecks, since ints and strs are subclasses of object
hash_a(42)
hash_a("foo") +
Typechecks, since Any is compatible with all types
hash_b(42)
hash_b("foo") +

+Use :class:object to indicate that a value could be any type in a typesafe +manner. Use :class:Any to indicate that a value is dynamically typed. Classes, functions, and decorators ----------------------------------

cpython: cbcab1fb1b8a (original) (raw)

Mercurial > cpython

changeset 102557:cbcab1fb1b8a 3.5

A static type checker will treat the above

as having the same signature as:

Typechecks, since ints and strs are subclasses of object

Typechecks, since Any is compatible with all types