For working professionals
For fresh graduates
More
13. Print In Python
15. Python for Loop
19. Break in Python
23. Float in Python
25. List in Python
27. Tuples in Python
29. Set in Python
53. Python Modules
57. Python Packages
59. Class in Python
61. Object in Python
73. JSON Python
79. Python Threading
84. Map in Python
85. Filter in Python
86. Eval in Python
96. Sort in Python
101. Datetime Python
103. 2D Array in Python
104. Abs in Python
105. Advantages of Python
107. Append in Python
110. Assert in Python
113. Bool in Python
115. chr in Python
118. Count in python
119. Counter in Python
121. Datetime in Python
122. Extend in Python
123. F-string in Python
125. Format in Python
131. Index in Python
132. Interface in Python
134. Isalpha in Python
136. Iterator in Python
137. Join in Python
140. Literals in Python
141. Matplotlib
144. Modulus in Python
147. OpenCV Python
149. ord in Python
150. Palindrome in Python
151. Pass in Python
156. Python Arrays
158. Python Frameworks
160. Python IDE
164. Python PIP
165. Python Seaborn
166. Python Slicing
168. Queue in Python
169. Replace in Python
173. Stack in Python
174. scikit-learn
175. Selenium with Python
176. Self in Python
177. Sleep in Python
179. Split in Python
184. Strip in Python
185. Subprocess in Python
186. Substring in Python
195. What is Pygame
197. XOR in Python
198. Yield in Python
199. Zip in Python
Type in Python is a built-in function that returns the type of a given object stored in a variable. It is used for debugging purposes and creates a class dynamically within selected objects. We use type in Python to find out what type the object is and return parameters of given objects. It is a very straightforward function, easy to use, and is used mostly in metaprogramming practices, being especially valuable in libraries where new classes have to be made. Today, we will cover everything you need to know about type in Python below.
Type() is a simple function that tells the developer what type of value a variable holds. If a variable contains a value of 5.95 and uses type() on it, it will return the result as float. Another example is if a variable 'subj' has the word 'Python' and uses type(subj) on it, then the type returned for the value would be a string. Data type in Python can be integers, strings, floats, tuples, etc.
type() can be used to determine what type of object is declared within a variable. There are 2 types of parameters that can be passed onto type(). The first is a single parameter and the second is a type() function with 3 parameters. type() is used to return data type in Python function with the outputs and works on multiple variables.
The syntax of the type() function Python is as follows:
type(object)
type(name, bases, dict)
A single argument is passed on the type() function in Python to display the type of only one object. If multiple arguments are passed, type() will return the newest object. type() can take up to 3 object parameters which are - name, bases, and dict. The name parameters return the class name while the bases attribute specifies the base classes. Bases is similar to _bases_. The dict attribute in Python is the same as _dict_ and returns dictionary objects from specified key-value pairs.
Let's check out a few examples of how the type() function works in action when new arguments are passed.
Example 1 - Finding out the class type of a variable
prime_numbers = [8, 9, 1, 2]
# check type of prime_numbers
result = type(prime_numbers)
print(result)
# Output: <class 'list'>
Explanation:
In the above type() function in Python example, type() will return the type of object based on the new arguments passed. The programmer created a variable called 'prime_numbers' and used the result to find out the type of the variable. When the user runs the output, the console will print the output <class 'list'> because the type of variable is a list.
Example 2 - Finding out the type of a Python object
x = 10
print(type(x))
s = 'abc'
print(type(s))
from collections import OrderedDict
od = OrderedDict()
print(type(od))
class Data: pass
d = Data()
print(type(d))
Output:
<class 'int'>
<class 'str'>
<class 'collections.OrderedDict'>
<class '__main__.Data'>
Explanation:
The type() function will return the module name along with the type of an object. In this example, the Python script doesn't have a module which is why it returns the module as _main_.
Example 3 - Return the type of different objects
a = ('apple', 'banana', 'cherry')
b = "Hello World"
c = 33
x = type(a)
y = type(b)
z = type(c)
Output:
<class 'tuple'>
<class 'str'>
<class 'int'>
Explanation:
type() was used to identify the objects stored in variables a,b, and c. x,y, and z variables were used to store the results for type() function. When the user printed the output, it returned 'a' as tuple (a list), 'b' as string, and 'c' as integer.
Example 4: Creating a class dynamically with type()
Let's say we want to create two classes. The first class will be about a car 'Porsche' and it will contain attributes such as non-electric and have a speed of 100. A second class will be named 'Tesla' and Tesla will be an electric car that is faster than Porsche, preferably having a speed of 110.
Here is how we would dynamically create these classes with type().
porsche = type('Car', (object,), {speed: 100, 'electric': False})
tesla = type('Car', (object,),{speed: 110, 'electric': True})
If we type porsche for the output, the class would be returned as <class '_main_.Car'>
porsche.speed would give us a result of 100
porsche.electric would return false
tesla.speed would give us 110
tesla.electric would return true
Notice how we didn't have to create a separate class MyCar and define individual attributes within the braces. We used type() to predefined classes within a single line of code. This is how powerful type() is and it saves programmers a lot of time! It's important to note that type() can take between 1 or 3 arguments. There are 2 arguments and 4 or more arguments are not supported. The first argument is the name of a class being created, the second is the base form which your other classes will inherit, and finally, the third is the dictionary attribute that holds methods and variables inside classes.
Example 5: Pulling metadata details from classes
Let's say we want to pull metadata from Python classes and extract the bases, dict, doc properties, and Python type class. We can write a class, define attributes, and print the properties of those classes. Type() can be used to make similar classes and extract those details directly.
Here's how to go about it.
Step 1: Create the class
class Data:
"""Data Class"""
d_id = 10
class SubData(Data):
"""SubData Class"""
sd_id = 20
Step 2: Print the class
print(Data.__class__)
print(Data.__bases__)
print(Data.__dict__)
print(Data.__doc__)
print(SubData.__class__)
print(SubData.__bases__)
print(SubData.__dict__)
print(SubData.__doc__)
Step 3: Print properties of said classes
print(Data.__class__)
print(Data.__bases__)
print(Data.__dict__)
print(Data.__doc__)
print(SubData.__class__)
print(SubData.__bases__)
print(SubData.__dict__)
print(SubData.__doc__)
We will get this output:
<class 'type'>
(<class 'object'>,)
{'__module__': '__main__', '__doc__': 'Data Class', 'd_id': 10, '__dict__': <attribute '__dict__' of 'Data' objects>, '__weakref__': <attribute '__weakref__' of 'Data' objects>}
Data Class
<class 'type'>
(<class '__main__.Data'>,)
{'__module__': '__main__', '__doc__': 'SubData Class', 'sd_id': 20}
SubData Class
Step 4: Create similar classes using type() and print them for faster results
Data1 = type('Data1', (object,), {'__doc__': 'Data1 Class', 'd_id': 10})
SubData1 = type('SubData1', (Data1,), {'__doc__': 'SubData1 Class', 'sd_id': 20})
print(Data1.__class__)
print(Data1.__bases__)
print(Data1.__dict__)
print(Data1.__doc__)
print(SubData1.__class__)
print(SubData1.__bases__)
print(SubData1.__dict__)
print(SubData1.__doc__)
The output for the type() function will be as follows:
<class 'type'>
(<class 'object'>,)
{'__doc__': 'Data1 Class', 'd_id': 10, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Data1' objects>, '__weakref__': <attribute '__weakref__' of 'Data1' objects>}
Data1 Class
<class 'type'>
(<class '__main__.Data1'>,)
{'__doc__': 'SubData1 Class', 'sd_id': 20, '__module__': '__main__'}
SubData1 Class
Type() can be used in versatile ways but remember that we cannot make functions in the dynamic class using type() in Python.
Example 6: Recreating Movie class with type()
We know that it can instantiate a class in Python and have its own. The Movie class can have a higher class above it. Let's create the class.
class Movie:
def __init__(self, rating, genre):
self.rating = rating
self.genre = genre
def show_characteristics(self):
characteristics = [self.genre, self.rating]
return characteristics
Now, what happens if we choose to inspect the object in class Movie using type()?
print(type(Movie))
We will get the output <class 'type'>. If we try to execute type() on any string, integer, or other Python classes within the class, we will still get the output as <class 'type'>. It's because the Python type hints class is the parent and all classes and objects inherit everything from it.
If we are to recreate the Movie class using type(), here is how we would do it:
def movie_init(self, genre, rating):
self.genre = genre
self.rating = rating
def show_characteristics(self):
characteristics = [self.rating, self.genre]
return characteristics
movie_class = type("MovieClass", (), {"__init__": movie_init, "show_characteristics": show_characteristics})
Our Movie class will not inherit from any other class which is why the base class is left void (empty tuple). The init and show_characteristics are methods we have created because it can be challenging to fit them within the dictionary.
What we end up with is a movie_class that we can use.
Let's see it in action.
movie = movie_class("10", "horror")
print(movie.show_characteristics())
Output:
['10', 'horror']
Let's see what happens when we pass 3 parameters to type().
# Python type() function when three arguments are passed
BaseClass = type(' BaseClass ', (), { 'a' : 100})
print(type(BaseClass))
Output:
<class 'type'>
In this case, we have created a new class called BaseClass and assigned 3 arguments to it. A void tuple was used to define that there are no base classes and the dictionary attributes were set to a word 'a' having a value of 100. We have printed the print type Python of the class BaseClass using the type() function and it returned the result as <class 'type'>.
The type() function can be used to find out the type of object stored in Python variables or create new classes dynamically. It can take between one to three arguments and is helpful for programmers.
1. What are the different ways of writing the type() syntax?
There are only 2 ways of using the type() syntax: type(object) and type(name,base,dict)
2. What is the use of type() in Python programming?
type() is a pre-built function that describes the type of data stored in variables. It can also be used to dynamically create classes and assign attributes to them in the code.
3. What are Python tuples in type()?
Python tuples associated with the type() functions are similar to lists. Tuples are immutable and cannot be changed once created. They are used for storing constants and useful in cases such as maintaining database records which cannot be modified.
Take our Free Quiz on Python
Answer quick questions and assess your Python knowledge
Author
Talk to our experts. We are available 7 days a week, 9 AM to 12 AM (midnight)
Indian Nationals
1800 210 2020
Foreign Nationals
+918045604032
1.The above statistics depend on various factors and individual results may vary. Past performance is no guarantee of future results.
2.The student assumes full responsibility for all expenses associated with visas, travel, & related costs. upGrad does not provide any a.