What are the differences between Set, FrozenSet, MutableSet and AbstractSet in python typing module?

Question

I am trying to annotate my code with types but I am a little confused when it comes to sets. I read some points in PEP 484:

Note: Dict , List , Set and FrozenSet are mainly useful for annotating return values. For arguments, prefer the abstract collection types defined below, e.g. Mapping , Sequence or AbstractSet .

and

Set, renamed to AbstractSet . This name change was required because Set in the typing module means set() with generics.

but this does not help.

My first question is: what are the commonalities and differences between Set, FrozenSet, MutableSet and AbstractSet?

My second question is: why if I try

from collections import FrozenSet

I get

ImportError: cannot import name 'FrozenSet'

?

I am using Python 3.4 and I have installed mypy-lang via pip.

Answer 1

Be careful with annotations and typing. The ideas discussed in 484 are brand new, and implemented in the typing module. That module is only available in Python3.5 (the latest typing is also available from pip for both Py2 and Py3).

https://docs.python.org/3/library/typing.html

That note that you quoted is from a section in 484 that starts:

To open the usage of static type checking to Python 3.5 as well as older versions, a uniform namespace is required. For this purpose, a new module in the standard library is introduced called typing .

The things that the note lists are annotation types, not actual object classes (builtin or from collections). Don't confuse the two.

Note that Dict , List , Set and FrozenSet are all capitalized, where as the functions (and type names) are dict, list, set, frozenset. In other words to make a dictionary you use dict() or {}, not Dict.

Annotations are new to 3.0 (not in 2.n at all). In a regular interpreter all they do is populate the function's __annotations__ dictionary. There's nothing in the interpreter that uses or requires annotations.

http://mypy-lang.org/ describes itself as an experiemental typing checker. You need to look at it's documentation to see how compatible it is with 484 etc.

https://docs.python.org/3/library/collections.abc.html#module-collections.abc has some abstract definitions, which I believe typing uses. I've never used these. They are mainly for people developing new classes of objects, not 'regular' users.

The typing tag for this question is probably not a good idea. It doesn't have many followers, and is too generic. It does not refer to this Python module.

Search for [python] 484 for other SO questions dealing with this style of annotations.

https://github.com/python/typing - the typing development repository.

In this repository, there is a FrozenSet definition in the python2/typing.py file (the python2 backport), but not in src/typing.py. I'm not sure of the significance of that.

Answer 2

Two years late to the party, but anyway...

You can think of AbstractSet and MutableSet as like an interface in Java or an abstract base class in Python. Python's builtin set() and frozenset() are one implementation, but someone could create another implementation that doesn't use the builtins at all.

FrozenSet and Set, on the other hand, represent the types of the concrete built in classes frozenset and set.

For example, the "interface" types don't have union methods, while the concrete types do. So:

def merge(a: Set[str], b: Iterable[str]) -> Set[str]:
    return a.union(b)

will type check just fine, but if you change the type of a to AbstractSet, mypy says:

typetest.py:7: error: "AbstractSet[str]" has no attribute "union"

Answer 3

These type names are indeed a little confusing. There was a related discussion on mypy Gitter, and Guido provided a clarification.

typing.AbstractSet and typing.MutableSet are the types for ABCs (abstract base classes), not concrete implementations of the set type:

• typing.AbstractSet is the type for collections.abc.Set, which is an ABC (abstract base class) for an immutable set.
• typing.MutableSet is the type for collections.abc.MutableSet, which is an ABC for a mutable set.

typing.Set and typing.FrozenSet are the types for concrete set implementations, available in the stdlib:

• typing.Set is the type for stdlib set, which is a concrete implementation of a mutable set.
• typing.FrozenSet is the type for stdlib frozenset, which is a concrete implementation of an immutable set.

Answer 4

The set type is mutable -- the contents can be changed using methods like add() and remove(). Since it is mutable, it has no hash value and cannot be used as either a dictionary key or as an element of another set. The frozenset type is immutable and hashable -- its contents cannot be altered after is created; however, it can be used as a dictionary key or as an element of another set.

from: https://docs.python.org/3/library/stdtypes.html#frozenset

you don't need to include it, it's built in, you just do:

cities = frozenset(["Frankfurt", "Basel","Freiburg"])

tested in 3.4.2

Answer 5

Update in Python 3.9+ (2021+)

The relationship between builtin set, collections.abc.Set, typing.Set, and typing.AbstractSet had a complicated history. Starting in Python 3.9, PEP 585 deprecated collections.abc.Set, typing.Set, and typing.AbstractSet and aliased them to the builtin set. Correspondingly, typing.FrozenSet was deprecated and aliased to the builtin frozenset.

TL; DR: Use only the builtin set and frozenset for typing.

In action:

from collections.abc import Iterable

# using Python 3.12+ generics
def union[T](a: Iterable[T], b: Iterable[T]) -> set[T] | frozenset[T]:
    if isinstance(a, frozenset) or isinstance(b, frozenset):
        return frozenset(a) | frozenset(b)
    return set(a) | set(b)

assert union({1}, {2}) == {1, 2}
assert union(frozenset({1}), {2}) == frozenset({1, 2})