# pydoc > abc

---
type: CommandReference
command: abc
mode: pydoc
section: ""
source: pydoc3
---

## Quick Reference

- `from abc import ABC, abstractmethod` — import main classes
- `class MyABC(ABC):` — define an ABC by inheriting from `ABC`
- `@abstractmethod` — decorator for abstract methods
- `@classmethod @abstractmethod` — abstract classmethod (preferred over deprecated `abstractclassmethod`)
- `@property @abstractmethod` — abstract property (preferred over deprecated `abstractproperty`)
- `@staticmethod @abstractmethod` — abstract staticmethod (preferred over deprecated `abstractstaticmethod`)
- `ABCMeta.register(subclass)` — register a virtual subclass
- `issubclass(MyClass, MyABC)` — check virtual subclass
- `update_abstractmethods(MyClass)` — recalculate abstract methods after runtime changes

## Name

abc — Abstract Base Classes (ABCs) according to PEP 3119.

## Synopsis

python
import abc

class MyABC(abc.ABC):
    @abc.abstractmethod
    def my_method(self):
        pass
## Options

### Decorators

- `@abstractmethod` — Indicates an abstract method. Requires metaclass derived from `ABCMeta`. A class with abstract methods cannot be instantiated unless all are overridden. Abstract methods can be called via `super()`.
- `@abstractclassmethod` — **Deprecated.** Use `@classmethod @abstractmethod` instead.
- `@abstractproperty` — **Deprecated.** Use `@property @abstractmethod` instead.
- `@abstractstaticmethod` — **Deprecated.** Use `@staticmethod @abstractmethod` instead.

### Functions

- `get_cache_token()` — Returns the current ABC cache token (opaque object). Changes with every `register()` call on any ABC.
- `update_abstractmethods(cls)` — Recalculates the set of abstract methods of `cls`. Should be called after runtime addition/implementation of abstract methods. Returns `cls`. If `cls` is not an instance of `ABCMeta`, does nothing.

### Metaclass: `ABCMeta`

- `ABCMeta.register(subclass)` — Register a virtual subclass of an ABC. Returns the subclass, allowing use as a class decorator.
- `__instancecheck__(cls, instance)` — Override for `isinstance(instance, cls)`.
- `__subclasscheck__(cls, subclass)` — Override for `issubclass(subclass, cls)`.
- Inherits methods from `type`: `__call__`, `__init__`, `__new__`, `mro`, etc.

### Classes

- `ABC` — Helper class that inherits from `object` and uses `ABCMeta` as its metaclass. Provides a standard way to create an ABC via inheritance. Has attribute `__abstractmethods__ = frozenset()`.
- `abstractclassmethod(builtins.classmethod)` — Deprecated, use `@classmethod @abstractmethod`.
- `abstractproperty(builtins.property)` — Deprecated, use `@property @abstractmethod`.
- `abstractstaticmethod(builtins.staticmethod)` — Deprecated, use `@staticmethod @abstractmethod`.

## Examples

### Defining an ABC with abstract methods

python
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass
### Concrete subclass

python
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)
### Registering a virtual subclass

python
from abc import ABC

class MyABC(ABC):
    pass

class MyClass:
    pass

MyABC.register(MyClass)
assert issubclass(MyClass, MyABC)   # True
assert isinstance(MyClass(), MyABC) # True
### Using `update_abstractmethods`

python
from abc import ABC, abstractmethod, update_abstractmethods

class MyABC(ABC):
    @abstractmethod
    def foo(self):
        pass

# Later, implement foo on the class
MyABC.foo = lambda self: 42
update_abstractmethods(MyABC)
# Now MyABC is no longer abstract
## See Also

- [Python docs: abc — Abstract Base Classes](https://docs.python.org/3.10/library/abc.html)

## Exit Codes

Not applicable.