Does the keyword type in Python refer to a function or a class that is built-in?

Question

Does the keyword type in Python refer to a function or a class that is built-in?

There is often confusion around the definition of type in Python. Some believe it to be a built-in function when provided with one argument, and a metaclass when provided with three arguments.

However, according to Python's official documentation, the signature of type is:

class type(object)
class type(name, bases, dict)

This raises the question: Is type actually a built-in class rather than a built-in function even when given only one argument?

python types metaclass

Answer 1

Answer №1

type is known as a "metaclass" because it functions as a class that generates other classes, also known as types. It operates similarly to a regular class and includes a __new__ method which would resemble this Python code:

class type(object):

    def __new__(cls, *args):
        num_args = len(args)

        if num_args not in (1, 3):
            raise TypeError('type() takes 1 or 3 arguments')

        # type(x)
        if num_args == 1:
            return args[0].__class__

        # type(name, bases, dict)
        name, bases, attributes = args
        bases = bases or (object,)

        class Type(*bases):
            pass

        Type.__name__ = name

        qualpath = Type.__qualname__.rsplit('.', 1)[0]
        Type.__qualname__ = '.'.join((qualpath, name))

        for name, value in attributes.items():
            setattr(Type, name, value)

        return Type

Class = type('Class', (), {'i': 1})
instance = Class()

print(type(instance))  # -> Class
print(instance.__class__)  # -> Class
print(type(type(instance)))  # -> type
print(Class.i)  # -> 1
print(instance.i)  # -> 1

It's important to note that when creating an instance of a class, the new instance's value depends on what is returned from __new__. When dealing with type, __new__ always produces a type object, or class. Here's an example where a class extends int to default to using -1 instead of 0:

def Int__new__(cls, *args):
    if not args:
        return cls(-1)
    return super(cls, cls).__new__(cls, *args)

Int = type('Int', (int,), {'__new__': Int__new__})

i = Int()
print(type(i))  # -> Int
print(i.__class__)  # -> Int
print(type(type(i)))  # -> type
print(i)  # -> -1

j = Int(1)
print(j)  # -> 1

To delve deeper into the inner workings of type, explore the C code within type_new. In the code snippet (scroll a few lines down), you'll find that type(x) is a special case that immediately returns the type, or class, of x. When executing type(name, bases, dict), the process of creating a new type is kickstarted.

For some additional fun, give these commands a try:

type(object)
type(type)
isinstance(object, object)
isinstance(type, object)
type(1)
type(type(1))

Answer 2

type is known as a "metaclass" because it functions as a class that generates other classes, also known as types. It operates similarly to a regular class and includes a __new__ method which would resemble this Python code:

class type(object):

    def __new__(cls, *args):
        num_args = len(args)

        if num_args not in (1, 3):
            raise TypeError('type() takes 1 or 3 arguments')

        # type(x)
        if num_args == 1:
            return args[0].__class__

        # type(name, bases, dict)
        name, bases, attributes = args
        bases = bases or (object,)

        class Type(*bases):
            pass

        Type.__name__ = name

        qualpath = Type.__qualname__.rsplit('.', 1)[0]
        Type.__qualname__ = '.'.join((qualpath, name))

        for name, value in attributes.items():
            setattr(Type, name, value)

        return Type

Class = type('Class', (), {'i': 1})
instance = Class()

print(type(instance))  # -> Class
print(instance.__class__)  # -> Class
print(type(type(instance)))  # -> type
print(Class.i)  # -> 1
print(instance.i)  # -> 1

It's important to note that when creating an instance of a class, the new instance's value depends on what is returned from __new__. When dealing with type, __new__ always produces a type object, or class. Here's an example where a class extends int to default to using -1 instead of 0:

def Int__new__(cls, *args):
    if not args:
        return cls(-1)
    return super(cls, cls).__new__(cls, *args)

Int = type('Int', (int,), {'__new__': Int__new__})

i = Int()
print(type(i))  # -> Int
print(i.__class__)  # -> Int
print(type(type(i)))  # -> type
print(i)  # -> -1

j = Int(1)
print(j)  # -> 1

To delve deeper into the inner workings of type, explore the C code within type_new. In the code snippet (scroll a few lines down), you'll find that type(x) is a special case that immediately returns the type, or class, of x. When executing type(name, bases, dict), the process of creating a new type is kickstarted.

For some additional fun, give these commands a try:

type(object)
type(type)
isinstance(object, object)
isinstance(type, object)
type(1)
type(type(1))

Answer 3

Answer №2

In Python, the line between classes and functions is not as rigid compared to other programming languages.

You are able to utilize function call syntax to trigger a function directly, but also an instance of a class with the __call__ method, and even a class that overrides __new__ can act like a function.

The term Python uses to encompass all these scenarios is callable: an object that can be invoked using call syntax (foo()), resulting in an output.

The built-in type is one such example of a callable. It is callable.

At times, you treat type as a function, and it functions accordingly, leading some to refer to it as a function. Conversely, there are instances where you treat it as a class, prompting others to label it as a class. Ultimately, the practical use is more significant than its classification.

This showcases duck typing theory: if it exhibits characteristics of a duck, such as walking and quacking like one, then it should be regarded as a duck.

Answer 4

In Python, the line between classes and functions is not as rigid compared to other programming languages.

You are able to utilize function call syntax to trigger a function directly, but also an instance of a class with the __call__ method, and even a class that overrides __new__ can act like a function.

The term Python uses to encompass all these scenarios is callable: an object that can be invoked using call syntax (foo()), resulting in an output.

The built-in type is one such example of a callable. It is callable.

At times, you treat type as a function, and it functions accordingly, leading some to refer to it as a function. Conversely, there are instances where you treat it as a class, prompting others to label it as a class. Ultimately, the practical use is more significant than its classification.

This showcases duck typing theory: if it exhibits characteristics of a duck, such as walking and quacking like one, then it should be regarded as a duck.

Answer 5

Answer №3

When using the built-in type function, it always returns a type object, essentially a class. This remains true whether you're using the one-argument or three-argument form. In the one-argument scenario, the returned object is the type (class) of the argument provided. Whereas in the three-argument case, the returned object is a new type object (class), which can be utilized to create instances of the class.

Some classes have the capability to act as metaclasses, with the three-argument form of type commonly employed for this purpose. However, there exist alternate methods for introducing a class that can serve as a metaclass, along with other uses for the three-argument variant of type.

This behavior is not dissimilar from that of the int function, another built-in feature that produces an object of type int. Like type, int is also the name of a class and can be used to generate new objects:

>>> x = int()
>>> x
0
>>> type(x)
<class 'int'>

Similar to type, int offers more than one format:

>>> y = int("A", 16)
>>> y
10

Answer 6

When using the built-in type function, it always returns a type object, essentially a class. This remains true whether you're using the one-argument or three-argument form. In the one-argument scenario, the returned object is the type (class) of the argument provided. Whereas in the three-argument case, the returned object is a new type object (class), which can be utilized to create instances of the class.

Some classes have the capability to act as metaclasses, with the three-argument form of type commonly employed for this purpose. However, there exist alternate methods for introducing a class that can serve as a metaclass, along with other uses for the three-argument variant of type.

This behavior is not dissimilar from that of the int function, another built-in feature that produces an object of type int. Like type, int is also the name of a class and can be used to generate new objects:

>>> x = int()
>>> x
0
>>> type(x)
<class 'int'>

Similar to type, int offers more than one format:

>>> y = int("A", 16)
>>> y
10

Does the keyword type in Python refer to a function or a class that is built-in?

Answer №1

Answer №2

Answer №3

Similar questions

Transform a section of a list from CSV format into a Pandas dataframe using Python

Silenium randomization is an essential concept that helps in creating

Exploring the world of multi-level indexing using tuples

Optimizing Python Selenium WebDriver Code for Improved Performance

Unable to execute Visio macro with Python script

I have been attempting to solve the Two Sum problem using a nested loop, but unfortunately, it appears

Python Selenium error: "WebDriverException: 'login' executable must be accessible in the PATH environment variable."

Tips for formatting multiple JSON files on the terminal

Accessing a JSON file from a zipped archive

What is the best way to retrieve the values of checked checkboxes in Django framework?

Retrieve values from a data-driven key within a dictionary

Vue template is not being rendered when served through Django

Discovering the initial non-zero element within an image

I am looking to save all the pictures from my Pinterest boards onto my device

I'm perplexed by the Segmentation Fault error I received in Python. Could it be related to the fact that /tmp is

Tips for using Selenium to scrape a pop-up window on a different webpage

Is it possible for values to disappear instead of being turned to zeroes when reading a CSV file in Python Pand

The Django implementation is returning a null response when handling an Ajax request

Getting an empty list result when utilizing Selenium and BeautifulSoup for web scraping

Selenium was unable to locate the element by its name or ID