Is `type` really a function, or not?

Question

First, I'm sorry if I'm asking something dumb, because I'm new to Python...
I was reading http://docs.python.org/3.1/reference/datamodel.html#objects-values-and-types and saw that phrase:

The type() function returns an object’s type (which is an object itself)

Of course, I decided to check this:

>>> def someFunction(x):
...     return x * x
...     
>>> type(someFunction)
<class 'function'>
>>> type(type)
<class 'type'>

So, looks like functions have the function type, but then why type function has a different type if it is a function? Or the docs are lying and it's not really a function?

It's a function implemented in C. And it is it's own type. Yes, it's turtles, all the way down! — Martijn Pieters, Mar 22 '14 at 08:45
`isinstance(type,object)`, `isinstance(object,type)`, and `isinstance(type,type)` are all `True`. *Obviously*. :-) — roippi, Mar 22 '14 at 08:59
Also see [this answer](http://stackoverflow.com/a/6581949/1599111). It's about metaclasses, but it should make it clear to you what the two distinct functions (type checking and class factory) of `type()` in Python are used for. — Lukas Graf, Mar 22 '14 at 12:18

Martijn Pieters · Accepted Answer · 2014-03-22T08:55:58.470

10

Yes, type is a function, but it is implemented in C.

It also has to be it's own type, otherwise you could not do:

>>> def foo(): pass
... 
>>> type(foo)
<type 'function'>
>>> type(type)
<type 'type'>
>>> isinstance(type(foo), type)
True

e.g. you could not test if a type is a type, if type's type was not type but function. With me still?

Technically speaking, type is a callable, and has two related roles to play. It is a metaclass (a class factory) and the base for all types in Python, and when called it produces a type instance (<type 'function'> is an instance of the type type).

The same applies to all types (including classes); call them and they produce a new instance of the given type.

edited Mar 22 '14 at 08:55

answered Mar 22 '14 at 08:48

Martijn Pieters

1,048,767
296
4,058
3,343

2

I always though that type is a class – m.wasowski Mar 22 '14 at 08:52
1

for me, it would be better if this couldn't be done... when testing for another type (not `type`), there's a general way of writing second argument to `isinstance` function? – Display Name Mar 22 '14 at 08:53
@SargeBorsch: and why would that be? – Martijn Pieters Mar 22 '14 at 08:53
It looks dirty, and it's not general — `isinstance(foo, function)` won't work – Display Name Mar 22 '14 at 08:55
2

@SargeBorsch: `isinstance(foo, types.FunctionType)` works just fine. – Martijn Pieters Mar 22 '14 at 09:00
@SargeBorsch: there is no need for a built-in `function` function, but the type object still exists. – Martijn Pieters Mar 22 '14 at 09:00
@MartijnPieters is there a type in `types` that corresponds to `type` type? – Display Name Mar 22 '14 at 09:03
I looked through attributes of `types` module, but haven't found anything similar (although I found `FunctionType`) – Display Name Mar 22 '14 at 09:04
@SargeBorsch the `types` module is for types that *aren't* directly available as builtins. So, `type` isn't in there, any more than `list`, `tuple` or `int` (among others). – lvc Mar 22 '14 at 09:06
@MartijnPieters there was no downvote I think, I just clicked in wrong place and immediately corrected – Display Name Mar 22 '14 at 09:26
1

No, someone else did downvote this answer; I'd just love to know why they thought it deserved one. – Martijn Pieters Mar 22 '14 at 09:30

score 2 · Answer 2 · edited May 23 '17 at 12:28

Note that in Python anything is object. An object may be callable, i.e. work as function.
type is a built-in function, i.e. object of type that you can call as function. You can call it with one argument to get the type of an object. But there is also another use case.
type is a metaclass, this means it is a type itself and can create classes (which are objects too).
All classes (and also metaclasses) are callable, this is one more reason why type is function. You can call it with three arguments to create a class.
type is basic built-in metaclass. So it is a base of anything in Python. Because type is on top of hierarchy of types, type(type) returns type, i.e. type is type of itself.

You also may wonder:

score 0 · Answer 3 · edited Mar 22 '14 at 09:17

0

type is a class, that deals with class objects. Invoking it with an object is only one way to use it. You can also use it to create meta classes.

For example

>>> MyMetaClass = type("MyMetaClass", (object,), {'foo': 'bar'})
>>> newmeta = MyMetaClass()
>>> newmeta.foo
'bar'
>>> type(MyMetaClass)
<type 'type'>
>>> type(newmeta)
<class '__main__.MyMetaClass'>

edited Mar 22 '14 at 09:17

lvc

34,233
10
73
98

answered Mar 22 '14 at 09:05

Victory

5,811
2
26
45

Your 'metaclass' isn't actually a metaclass - to be a metaclass, you would have to have `isinstance(newmeta, type)` be True. – lvc Mar 22 '14 at 09:08
1

Which means `MyMetaClass` is a class but not a metaclass. For it to be a metaclass, its *instances* would need to be classes, which they're not. It would also need to be a subclass of type, which it isn't. – lvc Mar 22 '14 at 09:16
@ivc - i see what you are saying now, you are right. +1 – Victory Mar 22 '14 at 09:19

score 0 · Answer 4 · answered Jun 20 '23 at 13:15

You should understand some concepts first:

Everything in Python is an object. Every object created in Python is inherited from parent class 'type', its called a Metaclass. Metaclass is parent class of all the object in Python world. So what is the type of 'type' metaclass since everything is an object in Python? its 'type' only. 'type' object is of self type.
Now 'type()' is a function and 'type' is an object.

class XYZ: pass print(type(XYZ))

output: <class 'type'>

Is `type` really a function, or not?

4 Answers4