Check if a variable is list in Python

In Python programming, it is often crucial to determine the type of a variable for proper handling and execution of code. When dealing with lists, a common scenario arises where one needs to check if a particular variable is, in fact, a list. This verification is essential for ensuring that the subsequent operations or functions are appropriate for the data structure at hand.

Using type() function

The type() function in Python is a built-in function that returns the type of the specified object, generally the same object as returned by object.__class__. For example, if you pass a list object to the type() function, it will return <class 'list'>. You can use the type() function to test if a variable is a list by comparing its type with the list class using the == or is operators.

x = [1, 2, 3]
y = (4, 5, 6)
z = "Hello"

print(type(x) is list) # True
print(type(x) == list) # True
print(type(y) is list) # False
print(type(z) is list) # False

The == operator compares the values of the operands, while the is operator compares the identities of the operands. In most cases, this does not matter for types, since there is only one instance of each type object in memory.

The is operator is faster than the == operator, since it only compares the memory addresses of the operands, while the == operator may involve calling methods and performing type conversions.

Using isinstance() function

This method checks if the variable is an instance of list or a subclass of list. This is more flexible than the previous method, as it allows for inheritance and polymorphism.

class MyList(list):
    pass

x = [1, 2, 3]
y = MyList([4, 5, 6])
z = "Hello"

print(isinstance(x, list)) # True
print(isinstance(y, list)) # True
print(isinstance(z, list)) # False

You can use the isinstance() function to perform type checking, validation, or branching logic in your code. It is often preferred over the type() function, which only checks for the exact type of an object, not its subclasses.

Using __class__ attribute

This method is similar to the first one, but it uses the __class__ attribute of the variable instead of the type() function. This can be useful if you want to avoid calling a function, or if you want to compare the class names as strings.

x = [1, 2, 3]
y = (4, 5, 6)
z = "Hello"

print(x.__class__ == list) # True
print(y.__class__ == list) # False
print(z.__class__ == list) # False

The __class__ attribute in Python is a reference to the class object that created an instance. It allows you to access the class attributes and methods from the instance.

# Define a class with a class attribute and a class method
class Foo:
    name = "Foo"
    def hello():
        print("Hello from Foo")

# Create an instance of Foo
a = Foo()

# Access the class attribute and method from the instance
print(a.__class__.name) # Foo
a.__class__.hello() # Hello from Foo