Using composition instead of inheritance and abstract classes

I'm not convinced using an abstract base class is really useful here. All of your methods follow exactly the same principles. The only differences are the names and fields and the allowed enumeration values.

So as a first step I would put all the code into the baseclass, and only add the check for the enumeration into the constructor and implement the get_data method in each subclass:

class DisplayingFormat:
    def __init__(self, data, result_format, enum_type):
        if not isinstance(enum_type, DisplayingFormatEnum):
            raise DisplayingFormatError("Entity must be an instance of DisplayingFormatEnum Enum")
        self.result_format = result_format
        self.data = data
        self.enum_type = enum_type
        self.title = None

    def get_data(self, obj):
        raise NotImplementedError

    def to_table(self):
        table = PrettyTable(self.title)
        for d in self.data:
            table.add_row(self.get_data(d))
        return table

    def to_json(self):
        return [dict(zip(self.title, self.get_data(d))) for d in self.data]

    def to_dsv(self):
        return [';'.join(map(str, self.get_data(d))) for d in self.data]

    def display_format_list(self):
        if self.result_format == 'table':
            print(self.to_table())
        elif self.result_format == 'json':
            print(self.to_json())
        else:
            print(self.to_dsv())


class DisplayingFormatPeople(DisplayingFormat):
    def __init__(self, people, result_format, enum_type):
        super().__init__(people, result_format, enum_type)

        if enum_type.value == DisplayingFormatEnum.OPTION_A.value:
            self.title = TITLE_OPTION_A['people']
        else:
            raise DisplayingFormatError(f"DisplayingFormatPeople can only use {DisplayingFormatEnum.OPTION_A.value} as a valid enum_type. Invalid enum_type: {enum_type.value}")

    def get_data(self, person):
        return person.get_name(), person.get_id()


class DisplayingFormatCars(DisplayingFormat):
    def __init__(self, cars, result_format, enum_type):
        super().__init__(cars, result_format, enum_type)

        if enum_type.value == DisplayingFormatEnum.OPTION_A.value:
            self.title = TITLE_OPTION_A['cars']
        else:
            raise DisplayingFormatError(f"DisplayingFormatProjects can only use {DisplayingFormatEnum.OPTION_A.value} as a valid enum_type. Invalid enum_type: {enum_type.value}")

    def get_data(self, car):
        return car.get_type()

class DisplayingFormatDogs(DisplayingFormat):
    def __init__(self, dogs, result_format, enum_type):
        super().__init__(cars, result_format, enum_type)

        if enum_type.value == DisplayingFormatEnum.OPTION_A.value:
            self.title = TITLE_OPTION_A['dogs']
        elif enum_type.value == DisplayingFormatEnum.OPTION_B.value:
            self.title = TITLE_OPTION_B['dogs']
        else:
            error_line  = f"DisplayingFormatDogs can only use {DisplayingFormatEnum.OPTION_A.value} and {DisplayingFormatEnum.OPTION_B.value} as valid entities."
            error_line += f"Invalid enum_type: {enum_type.value}"
            raise DisplayingFormatError(error_line)

    def get_data(self, dog):
        return dog.get_nickname(), dog.get_type()

Note that I also fixed some un-/needed f-strings and used list comprehensions where applicable. I also modified and renamed your format methods so they return the formatted object and are only printed in display_format_list, which might need a better name as well.

This could be simplified further. The easiest way is if you can modify the objects in data to have an implemented __getitem__ method, but you can also hack it together using getattr. What you really only need for each subclass are the field names and the association between the option and the title:

class DisplayingFormat:
    fields = []
    titles = {}
    def __init__(self, data, result_format, enum_type):
        if not isinstance(enum_type, DisplayingFormatEnum):
            raise DisplayingFormatError("Entity must be an instance of DisplayingFormatEnum Enum")
        if enum_type not in self.titles:
            raise DisplayingFormatError(f"enumy_type must be in {[opt.value for opt in self.titles]}. Invalid enum_type: {enum_type.value}")
        self.result_format = result_format
        self.data = data
        self.title = self.titles[enum_type]

    def get_data(self, obj):
        # if you implement __getitem__
        return [obj[f] for f in self.fields]
        # or this, if you cannot modify your objects interface
        return [getattr(obj, f"get_{f}")() for f in self.fields]

    ...

class DisplayingFormatPeople(DisplayingFormat):
    fields = ["name", "id"]
    titles = {DisplayingFormatEnum.OPTION_A: TITLE_OPTION_A['people']}

class DisplayingFormatCars(DisplayingFormat):
    fields = ["type"]
    titles = {DisplayingFormatEnum.OPTION_A: TITLE_OPTION_A['dogs']}

class DisplayingFormatDogs(DisplayingFormat):
    fields = ["nickname", "type"],
    titles = {DisplayingFormatEnum.OPTION_A: TITLE_OPTION_A['dogs']
              DisplayingFormatEnum.OPTION_B: TITLE_OPTION_B['dogs']}

If you really want to go the route of composition, you would probably want to make the formatter an argument, so that you have only one class with this interface:

class Display:
    def __init__(self, data, title, formatter):
        ...

where taking care of selecting the proper columns to go to data as well as selecting the proper title is all external to the class. The formatter then takes the role of the to_json, ... methods. And at that point it doesn't even need to be a class anymore, a function would suffice.