Yes, there is a difference. Although in Python 3, all objects are instances of object, including object itself, only Any documents that the return value should be disregarded by the typechecker.
The Any type docstring states that object is a subclass of Any and vice-versa:
>>> import typing
>>> print(typing.Any.__doc__)
Special type indicating an unconstrained type.
- Any object is an instance of Any.
- Any class is a subclass of Any.
- As a special case, Any and object are subclasses of each other.
However, a proper typechecker (one that goes beyond isinstance() checks, and which inspects how the object is actually used in the function) can readily object to object where Any is always accepted.
From the Any type documentation:
Notice that no typechecking is performed when assigning a value of type
Anyto a more precise type.
and
Contrast the behavior of
Anywith the behavior ofobject. Similar toAny, every type is a subtype ofobject. However, unlikeAny, the reverse is not true: object is not a subtype of every other type.That means when the type of a value is
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.
and from the mypy documentation section Any vs. object:
The type
objectis another type that can have an instance of arbitrary type as a value. UnlikeAny,objectis an ordinary static type (it is similar toObjectin Java), and only operations valid for all types are accepted for object values.
object can be cast to a more specific type, while Any really means anything goes and a type checker disengages from any use of the object (even if you later assign such an object to a name that is typechecked).
You already painted your function into a an un-typed corner by accepting list, which comes down to being the same thing as List[Any]. The typechecker disengaged there and the return value no longer matters, but since your function accepts a list containing Any objects, the proper return value would be Any here.
To properly participate in type-checked code, you need to mark your input as List[T] (a genericly typed container) for a typechecker to then be able to care about the return value. Which in your case would be T since you are retrieving a value from the list. Create T from a TypeVar:
from typing import TypeVar, List
T = TypeVar('T')
def get_item(L: List[T], i: int) -> T:
return L[i]
or, using Python 3.12 or newer:
def get_itemT -> T:
return L[i]
Yes, there is a difference. Although in Python 3, all objects are instances of object, including object itself, only Any documents that the return value should be disregarded by the typechecker.
The Any type docstring states that object is a subclass of Any and vice-versa:
>>> import typing
>>> print(typing.Any.__doc__)
Special type indicating an unconstrained type.
- Any object is an instance of Any.
- Any class is a subclass of Any.
- As a special case, Any and object are subclasses of each other.
However, a proper typechecker (one that goes beyond isinstance() checks, and which inspects how the object is actually used in the function) can readily object to object where Any is always accepted.
From the Any type documentation:
Notice that no typechecking is performed when assigning a value of type
Anyto a more precise type.
and
Contrast the behavior of
Anywith the behavior ofobject. Similar toAny, every type is a subtype ofobject. However, unlikeAny, the reverse is not true: object is not a subtype of every other type.That means when the type of a value is
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.
and from the mypy documentation section Any vs. object:
The type
objectis another type that can have an instance of arbitrary type as a value. UnlikeAny,objectis an ordinary static type (it is similar toObjectin Java), and only operations valid for all types are accepted for object values.
object can be cast to a more specific type, while Any really means anything goes and a type checker disengages from any use of the object (even if you later assign such an object to a name that is typechecked).
You already painted your function into a an un-typed corner by accepting list, which comes down to being the same thing as List[Any]. The typechecker disengaged there and the return value no longer matters, but since your function accepts a list containing Any objects, the proper return value would be Any here.
To properly participate in type-checked code, you need to mark your input as List[T] (a genericly typed container) for a typechecker to then be able to care about the return value. Which in your case would be T since you are retrieving a value from the list. Create T from a TypeVar:
from typing import TypeVar, List
T = TypeVar('T')
def get_item(L: List[T], i: int) -> T:
return L[i]
or, using Python 3.12 or newer:
def get_itemT -> T:
return L[i]
Any and object are superficially similar, but in fact are entirely opposite in meaning.
object is the root of Python's metaclass hierarchy. Every single class inherits from object. That means that object is in a certain sense the most restrictive type you can give values. If you have a value of type object, the only methods you are permitted to call are ones that are a part of every single object. For example:
foo: object = 3
# Error, not all objects have a method 'hello'
bar = foo.hello()
# OK, all objects have a __str__ method
print(str(foo))
In contrast, Any is an escape hatch meant to allow you to mix together dynamic and statically typed code. Any is the least restrictive type -- any possible method or operation is permitted on a value of type Any. For example:
from typing import Any
foo: Any = 3
# OK, foo could be any type, and that type might have a 'hello' method
# Since we have no idea what hello() is, `bar` will also have a type of Any
bar = foo.hello()
# Ok, for similar reasons
print(str(foo))
You should generally try and use Any only for cases where...
- As a way of mixing together dynamic and statically typed code. For example, if you have many dynamic and complex functions, and don't have time to fully statically type all of them, you could settle for just giving them a return type of Any to nominally bring them into the typechecked work. (Or to put it another way, Any is a useful tool for helping migrate an untypechecked codebase to a typed codebase in stages).
- As a way of giving a type to an expression that is difficult to type. For example, Python's type annotations currently do not support recursive types, which makes typing things like arbitrary JSON dicts difficult. As a temporary measure, you might want to give your JSON dicts a type of
Dict[str, Any], which is a bit better then nothing.
In contrast, use object for cases where you want to indicate in a typesafe way that a value MUST literally work with any possible object in existence.
My recommendation is to avoid using Any except in cases where there is no alternative. Any is a concession -- a mechanism for allowing dynamism where we'd really rather live in a typesafe world.
For more information, see:
- https://docs.python.org/3/library/typing.html#the-any-type
- http://mypy.readthedocs.io/en/latest/kinds_of_types.html#the-any-type
For your particular example, I would use TypeVars, rather then either object or Any. What you want to do is to indicate that you want to return the type of whatever is contained within the list. If the list will always contain the same type (which is typically the case), you would want to do:
from typing import List, TypeVar
T = TypeVar('T')
def get_item(L: List[T], i: int) -> T:
return L[i]
This way, your get_item function will return the most precise type as possible.
How am I supposed to do type annotation in Python when it's all Any type?
Typing: `object` vs `Any` (and `None` as a default)
Will typing objects like `Any` or `Never` ever become built-ins?
Python typing, what's the difference between dict[any,str] and dict(any,str)?
Videos
So for example, I am using BeautifulSoup library. And unlike other statically typed languages, no one seems to care about types in Python so the documentation does not tell me what's the return type of a function.
from bs4 import BeautifulSoup
soup = BeautifulSoup(self.driver.page_source, "html.parser")
result = soup.find("pre").textI use VSCode as my IDE, and when I hover over variables soup and result, it says unknown. So how am I supposed to annotate those types?
I'm learning to use a linter to make my code more consistent, and I've been learning more about type-hinting because of that.
In order to make my linter happy, I need to add return types to all my functions and methods. For most of them this is easy (int, None, tuple[int, int]) etc. however it seems like it's actually impossible to properly type-hint certain functions without importing the typing module, to access those extra hinting types.
I know you used to have to import this module to do things like unions (which you can now do with something like int|list[int, ...]). And I wonder if these typing-specific objects could ever be made into a built-in that doesn't require an import (the same way many other named objects like None, NotImplemented, Ellipses, or many others, are).
I know people here probably can't give me a certain answer, I'm just looking to talk about it because I'm curious :)
Hi, I am trying to declare the type for a parameter. In visual studio code, when I hover over a variable i see for example:
example_variable: dict[Any,str]
Now when I write a function and want to declare the type I have to write:
def example_function(variable: dict(Any,str)):
else the dict will be underlined red and I get an error. Do the brackets and the () mean the same thing?