Python type(): Type Introspection, Metaclasses & Dynamic Class Generation

1. Syntax & Dual Parameter Specifications 🔝

The type() function takes either one argument or three arguments:

# Formal syntax of built-in type()
# 1-argument form: inspection
obj_type = type(object)

# 3-argument form: dynamic class generation
ClassType = type(name, bases, dict, **kwds)

2. Video Tutorials 🔝

• Python Data Types Live Session
  #pythonbasics #datatypes

3. 1-Argument Type Inspection 🔝

Passing a single object returns its underlying type object:

# 1. Type inspection across primitives and sequences
print("Integer:  ", type(42))
print("String:   ", type("plus2net"))
print("List:     ", type([1, 2, 3]))
print("NoneType: ", type(None))

Terminal Output:

Integer:   <class 'int'>
String:    <class 'str'>
List:      <class 'list'>
NoneType:  <class 'NoneType'>

4. type() vs. isinstance(): Exact Match vs. Subclass Polymorphism 🔝

While type(obj) is Class tests for exact identity, isinstance() accounts for inheritance hierarchies:

# 2. type() vs. isinstance(): Exact match vs. Inheritance
flag = True

print("type(flag) is bool:     ", type(flag) is bool)
print("type(flag) is int:      ", type(flag) is int)
print("isinstance(flag, bool): ", isinstance(flag, bool))
print("isinstance(flag, int):  ", isinstance(flag, int))

Terminal Output:

type(flag) is bool:      True
type(flag) is int:       False
isinstance(flag, bool):  True
isinstance(flag, int):   True

5. 3-Argument Form: Dynamic Runtime Class Generation 🔝

Using type(name, bases, dict) allows generating classes dynamically on the fly without using the class keyword:

# 3. Dynamic class creation via 3-argument constructor
# type(name, bases, attributes_dict)
UserClass = type("UserClass", (object,), {
    "role": "MEMBER",
    "greet": lambda self, n: f"Hello, {n}!"
})

user = UserClass()
print("Class name:    ", UserClass.__name__)
print("Instance call: ", user.greet("Alexander"))

Terminal Output:

Class name:     UserClass
Instance call:  Hello, Alexander!

6. Data Type Conversion & Type Casting 🔝

To convert between compatible types, call the specific type constructors: int(), float(), str(), complex(), or bool():

# 4. Converting data types using type constructors
num_str = "125"
num_int = int(num_str)
num_float = float(num_int)
num_complex = complex(num_int, 4)

print("Parsed int:    ", num_int, type(num_int))
print("Converted float:", num_float, type(num_float))
print("Complex number: ", num_complex, type(num_complex))

Terminal Output:

Parsed int:     125 <class 'int'>
Converted float: 125.0 <class 'float'>
Complex number:  (125+4j) <class 'complex'>

7. Data Types in Action: Choosing the Right Container for Your Data 🔝

8. Production Recipe: Dynamic Model Factory 🔝

Using type() to dynamically construct structured model classes from schema definitions:

# 5. Production Recipe: Dynamic Model Factory
def make_record_class(model_name: str, fields: list):
    """Dynamically creates a model class from field definitions."""
    def __init__(self, **kwargs):
        for f in fields:
            setattr(self, f, kwargs.get(f))
    def __repr__(self):
        items = ", ".join(f"{f}={getattr(self, f)!r}" for f in fields)
        return f"{model_name}({items})"
    return type(model_name, (object,), {"__init__": __init__, "__repr__": __repr__})

Product = make_record_class("Product", ["sku", "price"])
p = Product(sku="PROD-99", price=49.99)
print("Dynamic instance:", p)

Terminal Output:

Dynamic instance: Product(sku='PROD-99', price=49.99)

9. Interactive Notebook & Practice Exercises 🔝

Practice type inspection, dynamic class construction, and metaclass properties in our interactive companion Jupyter Notebook:

Self-Verifying Assertion Suite

Run these unit checks directly in Python or your local environment to verify type() mechanics:

# 7. Self-verifying unit test suite for type()
assert type(10) is int and type("text") is str and type([1, 2]) is list

class Base: pass
class Child(Base): pass
c = Child()
assert type(c) is Child and type(c) is not Base and isinstance(c, Base)

DynamicModel = type("DynamicModel", (), {"val": 100})
assert DynamicModel.val == 100 and isinstance(DynamicModel(), DynamicModel)
assert type(type) is type and issubclass(type, object)

print("All type() unit assertions successfully verified!")

Terminal Output:

All type() unit assertions successfully verified!

10. Frequently Asked Questions (FAQ) 🔝

Further Reading & Related Tutorials 🔝

• Python isinstance() Function — Checking inheritance and polymorphic type conformance.
• Python issubclass() Function — Evaluating inheritance relationships between classes.
• Python object() Function — The root base class of all Python hierarchies.
• Python id() Function — Returning object memory addresses and identity checks.
• Python hash() Function — Hashable objects and dictionary key requirements.
• All Built-in Functions — Complete index of standard Python built-ins.

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: