Python Is Descendant

How do you check if a given Python object is a descendant of a given class? Here is a good way to do it using the inspect.getmro() function. This function returns a list of all the object's base classes, including all grand-parent classes, and so on, all the way up the class hierarchy.

Here is my version of the technique put into a simple function that will test if the specified object is a descendant of the specified class name.

from inspect import getmro

def istype(obj, typename):
  return typename in [clsobj.__name__ for clsobj in getmro(obj.__class__)]

class A(object):
  pass

class B(A):
  pass

if __name__ == "__main__":
  print istype(B(), "A")
  print istype(B(), "object")

Structured Components

With the UML, there is such a thing as a structured classifier. Structured classifiers allow for the modeling of the constituent parts that the make up the classifier.

This is handy because we can then show internal parts within the classifier, the connections between the internal parts and the boundary of the classifier itself. These connections can also illuminate the intricacies of the interface connections amongst the internal parts of the classifier.

So your main choices of modeling elements to use when showing a structured classifier are components and structured classes. I think it makes much better sense to use a component for this purpose. Components are geared slightly more toward the logical structure of a classifier and a a component is a structured classifier. Structured classes allow the same thing but I think classes are better used in the traditional way they were used before the advent of structured classifiers. The are good at showing the attributes, operations, and relationships with other classes. Components can show the same class in a different diagram but from a structural viewpoint.

Python Benchmarks

With new-style Python classes, one can help cut down on the memory cost associated with creating new instances. This is down by using the __slots__ class attribute. When the __slots__ attribute is used in the declaration of new-style classes, the __dict__ attribute is not created with instances of the class. The creation of the __dict__ attribute can be expensive in terms of memory when creating large numbers of instances. So, the questions that begs itself is why not use the __slots__ attribute for all classes throughout an application? The simple answer is, because of the lack of flexibility offered by attributes that live inside memory that has been pre-allocated by a slot. The other problem with using the __slots__ attribute for every class is the burden involved with maintaining all the slots, in all the classes. These could be in the several hundred range or more. So, this simply isn't feasible.

What is feasible, however, is to define __slots__ attributes for smaller classes with few attributes. Another factor to consider is instantiation density of these classes. That is, the __slots__ attribute is more beneficial with large numbers of instances because of the net memory savings involved. Consider the following example.

#Example; Using __slots__

import timeit

#A simple person class that defines slots.
class SlottedPerson(object):
  __slots__=("first_name", "last_name")

  def __init__(self, first_name="", last_name=""):
      self.first_name=first_name
      self.last_name=last_name
    
#A simple person class without slots.
class Person(object):
  def __init__(self, first_name="", last_name=""):
      self.first_name=first_name
      self.last_name=last_name

#Simple test for the slotted instances.
def time_slotted():
  person_obj=SlottedPerson(first_name="First Name", last_name="Last Name")
  first_name=person_obj.first_name
  last_name=person_obj.last_name

#Simple test for the non-slotted instances.
def time_non_slotted():
  person_obj=Person(first_name="First Name", last_name="Last Name")
  first_name=person_obj.first_name
  last_name=person_obj.last_name

#Main
if __name__=="__main__":
  #Initialize the timers.
  slotted_timer=timeit.Timer("time_slotted()",\
                             "from __main__ import time_slotted")
  non_slotted_timer=timeit.Timer("time_non_slotted()",\
                                 "from __main__ import time_non_slotted")

  #Display the results.
  print "SLOTTED    ",slotted_timer.timeit()
  print "NON-SLOTTED",non_slotted_timer.timeit()

In this example, we have two very simple classes. The SlottedPerson and the Person classes are identical except for the fact that the SlottedPerson class will always outperform Person. This is because there are always going to be performance gains when the interpreter doesn't need to allocate memory.

Flirting nerds?

Yep, it is true. They actually have a class for us now in Germany.

The class is supposed to teach the IT students flirtation and social skills. I think many nerds who would be considered "socially inept" may actually have required skill-set and choose not to be sociable. The class is a great idea for those who choose it. It shouldn't, however, be forced upon students.