Как проверить, является ли переменная класса или нет?

class MyFinxterClass1(object):
    pass

variable1 = MyFinxterClass1
variable2 = MyFinxterClass1()

$ python
Python 3.9.0b5 (default, Oct 19 2020, 11:11:59) 
>>> 
>>> ## Declare the class. Note that the 'pass' keyword is used to keep
>>> ## the code simple and easy to understand. It translates to a NOP.
>>> class MyFinxterClass1(object):
...     pass
... 
>>> ## 'inspect' is a Python Standard Library Module that contains a lot of
>>> ## useful Python Runtime Services
>>> import inspect
>>> 
>>> ## First test the Class itself...
>>> inspect.isclass(MyFinxterClass1)
True
>>> ## This is good!! We now know for sure, MyFinxterClass1 is a Class
>>> 
>>> ## Now, instantiate the Class…
>>> ## variable2 is an instance of Class MyFinxterClass1.
>>> variable2 = MyFinxterClass1()
>>> ## But what is variable1? The test for variable1 has a hint.
>>> variable1 = MyFinxterClass1
>>> 
>>> ## Next, test the variables...
>>> inspect.isclass(variable2)
False
>>> ## Still good!! Variable2 is an instance, hence not a class.  
>>>
>>> ## But what about variable1?
>>> inspect.isclass(variable1)
True
>>> ## variable1 is an alias of MyFinxterClass1, hence it is also considered a class.

$ python
Python 3.9.0b5 (default, Oct 19 2020, 11:11:59) 
>>> 
>>> ## First lets test the list class.
>>> ## Declare a list variable...
>>> l1 = [1, 2, 3, 4]
>>> ## Make sure it is a list… Yup! It is a list!!
>>> type(l1)

>>>
>>> ## Is 'list' a class? It should be!!!. Yup! It is a class!!
>>> inspect.isclass(list)
True
>>> ## What about the variable? 
>>> inspect.isclass(l1)
False
>>> ## So far, so good.  What about a Set?
>>> s1 = {1, 2, 3, 4}
>>> type(s1)

>>>
>>> inspect.isclass(set)
True
>>> inspect.isclass(s1)
False
>>> 
>>> ## Hmm, we are beginning to see a pattern here! Excellent!!
>>> t1 = (1, 2, 3, 4)
>>> type(t1)

>>> inspect.isclass(tuple)
True
>>> inspect.isclass(t1)
False
>>> 

$ python
Python 3.9.0b5 (default, Oct 19 2020, 11:11:59) 
>>> 
>>> ## Declare a list, a set and a tuple variable...
>>> l1 = [1, 2, 3, 4]
>>> s1 = {1, 2, 3, 4}
>>> t1 = (1, 2, 3, 4)
>>>
>>> ## Now let's play with the isinstance() built-in Python function.
>>> ## s1 is a 'set', not a 'tuple'
>>> isinstance(s1, tuple)
False
>>> ## But t1 is indeed a 'tuple'
>>> isinstance(t1, tuple)
True
>>> ## Is s1 really a set? Yes, it is...
>>> isinstance(s1, set)
True
>>> ## What if we ask if t1 is a 'set'?
>>> isinstance(t1, set)
False
>>> ## Still works!! Doesn't it?? Now we are beginning to have fun, lol!!!
>>> ## What about l1? Yeah! What about it???  Go ahead and test it...
>>> isinstance(l1, list)
True
>>> isinstance(l1, set)
False
>>> isinstance(l1, tuple)
False 

>>> ## Declare the class. Note that the 'pass' keyword is used to keep
>>> ## the code simple and easy to understand. It translates to a NOP.
>>> class MyFinxterClass1(object):
...     pass
... 
>>> ## 'inspect' is a Python Standard Library that contains a lot of
>>> ## useful Python Runtime Services
>>> import inspect
>>> 
>>> ## Declare a Class derived from MyFinxterClass1
>>> class Second1(MyFinxterClass1):
...     pass
... 
>>> ## Declare another Class derived from MyFinxterClass1
>>> ## Note that Second1 and Second2 are derived sibling classes because
>>> ## both of them are derived from MyFinxterClass1
>>> class Second2(MyFinxterClass1):
...     pass
... 
>>> ## Instantiate the derived Classes
>>> variable3 = Second1()
>>> variable4 = Second2()
>>> 
>>> ## Test whether they are classes. They should be!!!
>>> inspect.isclass(MyFinxterClass1)
True
>>> inspect.isclass(Second1)
True
>>> inspect.isclass(Second2)
True
>>> 
>>> ## So far so good. What about the instances? Do they have the 
>>> ## the relationships we think they should have?  Lets See...
>>> isinstance(variable3, Second1)
True
>>> ## Yes, variable3 is an instance of Second1.
>>> isinstance(variable3, MyFinxterClass1)
True
>>> ## Yes, variable3 is *also* an instance of MyFinxterClass1. This is 
>>> ## because Second1 is derived from MyFinxterClass1. Makes Sense!!
>>> 
>>> ## This is the interesting one!! Second1 and Second2 are siblings.
>>> ## So yes, they are related because MyFinxterClass1 is their parent.
>>> ## But variable3 is *not* an instance of Second2. Therefore....
>>> isinstance(variable3, Second2)
False
>>> ## Phew!! What a relief :)
>>> 
>>> ## In a similar vein, can the reader predict answers to the following?
>>> isinstance(variable4, Second1)
False
>>> isinstance(variable4, MyFinxterClass1)
True
>>> isinstance(variable4, Second2)
True
>>> 

$ python
Python 3.9.0b5 (default, Oct 19 2020, 11:11:59) 
>>>
>>> ## Declare the Classes and Instantiate them as was done before
>>> ## in code snippets shown above.
>>> class MyFinxterClass1(object):
...     pass
... 
>>> variable1 = MyFinxterClass1
>>> variable2 = MyFinxterClass1()
>>> 
>>> class Second1(MyFinxterClass1):
...     pass
... 
>>> class Second2(MyFinxterClass1):
...     pass
...     
>>> variable3 = Second1()
>>> variable4 = Second2()
>>> 
>>> ## Next, run the type() function on each of them.
>>> type(MyFinxterClass1)

>>> type(Second1)

>>> type(Second2)

>>> type(variable1)

>>> ## So, User defined classes and their aliases, show up as the 'type' metaclass
>>>
>>> ## On the other hand, for the instantiations(i.e. variables) type() shows the
>>> ## appropriate class. 
>>> type(variable2)

>>> type(variable3)

>>> type(variable4)

>>> 
>>> ## What about the Python built-in classes. Well, declare a list, a set and a tuple
>>> ## variable...
>>> l1 = [1, 2, 3, 4]
>>> s1 = {1, 2, 3, 4}
>>> t1 = (1, 2, 3, 4)
>>> 
>>> ## As above, run the type() function on each of them. Again, type() shows the
>>> ## appropriate class. 
>>> type(l1)

>>> type(s1)

>>> type(t1)

>>> 
>>> ## What happens when type() is run on Python's built-in classes
>>> ## such as list, set and tuple? 
>>> type(list)

>>> type(set)

>>> type(tuple)

>>> 
>>> ## Again, just as the user defined classes, the Python built-in classes show up
>>> ## as the 'type' metaclass.
>>>