Do you know what the Python π `type` is?
But do you _really_ know what it is?
Here is a valuable thread that will give you insights into what `type` is and does.
Let's go ππ§΅
But do you _really_ know what it is?
Here is a valuable thread that will give you insights into what `type` is and does.
Let's go ππ§΅
What does `type` do?
You might say that `type` takes an object and returns the type of the argument.
Here are some examples:
You might say that `type` takes an object and returns the type of the argument.
Here are some examples:
Fine, so `type` is a function!
Or is it..?
Take a look at the example above.
`sum` is a built-in function and `type(sum)` returned βbuilt-in function or methodβ.
So, logically, if `type` is a (built-in) function, the type of `type` should give the same thing:
Or is it..?
Take a look at the example above.
`sum` is a built-in function and `type(sum)` returned βbuilt-in function or methodβ.
So, logically, if `type` is a (built-in) function, the type of `type` should give the same thing:
But it said that the type of `type` is... `type`? π€―
How's that?
What does that even mean?
Well, let's take a step back and look at `str` and `int`:
How's that?
What does that even mean?
Well, let's take a step back and look at `str` and `int`:
Interesting!
So `int` and `str` are built-in functions that convert things to integers and strings, respectively.
Right?
Well, let's check their type!
As it turns out, the type of `int` and `str` are also... `type`!
So `int` and `str` are built-in functions that convert things to integers and strings, respectively.
Right?
Well, let's check their type!
As it turns out, the type of `int` and `str` are also... `type`!
Ok, so these things seem to be connected!
Let's take one more step back.
Let's look at what the type of `3` is and to what `int` is:
Let's take one more step back.
Let's look at what the type of `3` is and to what `int` is:
Hey, `type(3)` and `int` look like the same thing!
Heck, they _are_ the same thing:
Heck, they _are_ the same thing:
So `type(3)` and `int` are the same thing!
That's interesting!
So, `int` is not a function, and it builds integers, so `int` is like an integer factory!
That's why `int` shows like βclass intβ, because it is a class.
This applies to `int`, `str`, `list`, `tuple`, `dict`, ...
That's interesting!
So, `int` is not a function, and it builds integers, so `int` is like an integer factory!
That's why `int` shows like βclass intβ, because it is a class.
This applies to `int`, `str`, `list`, `tuple`, `dict`, ...
So, all these objects are the objects that represent the classes.
All these objects are factories of a specific kind.
`str` is a string factory.
`dict` is a dictionary factory.
Your own custom classes, are also factories:
All these objects are factories of a specific kind.
`str` is a string factory.
`dict` is a dictionary factory.
Your own custom classes, are also factories:
But that brings us close to the end!
There's a bunch of objects, that we use regularly, that are just factories.
Fine, fine.
So, if all these objects are factories, maybe that's their type!
Their type could be βfactoryβ!
There's a bunch of objects, that we use regularly, that are just factories.
Fine, fine.
So, if all these objects are factories, maybe that's their type!
Their type could be βfactoryβ!
If something has the type βtypeβ, it means it's a factory.
Ok, so checking the type of `type` again shows that the type of `type` is... `type`.
So `type` is also a factory!
So what does `type` produce?
Let's see:
Ok, so checking the type of `type` again shows that the type of `type` is... `type`.
So `type` is also a factory!
So what does `type` produce?
Let's see:
So `type` is producing other factories...
Meaning `type` is a factory of factories! π€―π€―π€―
I mean, you can even create new classes dynamically with `type`! (Not that you generally should...)
Here's the `Person` class from before:
Meaning `type` is a factory of factories! π€―π€―π€―
I mean, you can even create new classes dynamically with `type`! (Not that you generally should...)
Here's the `Person` class from before:
And that's it, for now!
Recap:
πΒ `int`, `str`, `list`, ..., are NOT functions, but classes. Akin to the ones you create with the `class` keyword.
π These are like βfactoriesβ of objects.
π `type` accepts objects and returns classes, so `type` is a factory of factories!
Recap:
πΒ `int`, `str`, `list`, ..., are NOT functions, but classes. Akin to the ones you create with the `class` keyword.
π These are like βfactoriesβ of objects.
π `type` accepts objects and returns classes, so `type` is a factory of factories!
I hope you found value in this tweet!
If you did, follow me (@mathsppblog) for more content like this!
There's plenty of amazing Python π content in store!
Also, consider retweeting the first tweet of this thread if you learnt something new π
If you did, follow me (@mathsppblog) for more content like this!
There's plenty of amazing Python π content in store!
Also, consider retweeting the first tweet of this thread if you learnt something new π
https://twitter.com/mathsppblog/status/1441168776586616838
β’ β’ β’
Missing some Tweet in this thread? You can try to
force a refresh
γ
![Diagram showing how you can use f-strings and their format specification to redact private or sensitive information, like email addresses. The code from the diagram: def redact_email(email): user, _, domain = email.partition("@") return f"{user[:2]:*<{len(user)}}@{domain}" print(redact_email("rodrigo@mathspp.com")) # ro*****@mathspp.com](https://pbs.twimg.com/media/GqhlkWbXgAAE9kd.jpg)
