This example shows only a name, type and value, however, __dataclass_fields__ is a dict of Field objects, each containing information such as name, type, default value, etc.

Using dataclasses.fields()

Using dataclasses.fields() you can access fields you defined in your dataclass.

fields = dataclasses.fields(dataclass_instance)

Using inspect.getmembers()

Using inspect.getmembers() you can access all fields in your dataclass.

members = inspect.getmembers(type(dataclass_instance))
fields = list(dict(members)['__dataclass_fields__'].values())

Complete code solution

import dataclasses
import inspect


@dataclasses.dataclass
class Test:
    a: str = "a value"
    b: str = "b value"


def print_data_class(dataclass_instance):

    # option 1: fields
    fields = dataclasses.fields(dataclass_instance)

    # option 2: inspect
    members = inspect.getmembers(type(dataclass_instance))
    fields = list(dict(members)['__dataclass_fields__'].values())

    for v in fields:
        print(f'{v.name}: ({v.type.__name__}) = {getattr(dataclass_instance, v.name)}')


print_data_class(Test())
# a: (str) = a value
# b: (str) = b value

print_data_class(Test(a="1", b="2"))
# a: (str) = 1
# b: (str) = 2

Inspecting __annotations__ gives you the raw annotations, but those don't necessarily correspond to a dataclass's field types. Things like ClassVar and InitVar show up in __annotations__, even though they're not fields, and inherited fields don't show up.

Instead, call dataclasses.fields on the dataclass, and inspect the field objects:

field_types = {field.name: field.type for field in fields(MyClass)}

Neither __annotations__ nor fields will resolve string annotations. If you want to resolve string annotations, the best way is probably typing.get_type_hints. get_type_hints will include ClassVars and InitVars, so we use fields to filter those out:

resolved_hints = typing.get_type_hints(MyClass)
field_names = [field.name for field in fields(MyClass)]
resolved_field_types = {name: resolved_hints[name] for name in field_names}

Use dataclasses.fields to pull out the fields, from the class or an instance. Then use the .name attribute to get the field names.

>>> from dataclasses import fields
>>> attributes = [field.name for field in fields(Car)]
>>> print(attributes)
['make', 'model', 'color', 'owner']

Use dataclasses.fields() to iterate over all the fields, making a list of their names.

Use dataclasses.is_dataclass() to tell if a field is a nested dataclass. If so, recurse into it instead of adding its name to the list.

from dataclasses import fields, is_dataclass

def all_fields(c: type) -> list[str]:
    field_list = []
    for f in fields(c):
        if is_dataclass(f.type):
            field_list.extend(all_fields(f.type))
        else:
            field_list.append(f.name)
    return field_list

The answer depends on whether or not you have access to an object of the class.

Just using the class

If you only have access to the class, then you can use dataclasses.fields(C) which returns a list of field objects (each of which has a .name property):

[field.name for field in dataclasses.fields(C)]

From an existing object

If you have a constructed object of the class, then you have two additional options:

1. Use dataclasses.fields on the object:

[field.name for field in dataclasses.fields(obj)]

2. Use dataclasses.asdict(obj) (as pointed out by this answer) which returns a dictionary from field name to field value. It sounds like you are only interested in the .keys() of the dictionary:

dataclasses.asdict(obj).keys()       # gives a dict_keys object
list(dataclasses.asdict(obj).keys()) # gives a list
list(dataclasses.asdict(obj))        # same 

Full example

Here are all of the options using your example:

from dataclasses import dataclass, fields, asdict


@dataclass
class C:
    x: int
    y: int
    z: int
    t: int

# from the class
print([field.name for field in fields(C)])

# using an object
obj = C(1, 2, 3, 4)

print([field.name for field in fields(obj)])
print(asdict(obj).keys())
print(list(asdict(obj).keys()))
print(list(asdict(obj)))

Output:

['x', 'y', 'z', 't']
['x', 'y', 'z', 't']
dict_keys(['x', 'y', 'z', 't'])
['x', 'y', 'z', 't']
['x', 'y', 'z', 't']