class example():
  def __init__(self, login=False):
      self.setting = 'A'
      print '__init__'
 
  def __enter__(self):
      print 'Entering '
      return self
 
  def __exit__(self, exctype, value, traceback):
      print 'Exiting '
 
with example() as e:
   print e.setting

The output of this script is :

__init__
Entering
A
Exiting

So __init__ is called first and then __enter__. Then the block after the with statement is executed, followed by __exit__ .

Of course you can return another object in __enter__ if necessary. In a lot of cases that might make more sense.

• Astronomy Cast
• The history of Rome

Well worth subscribing to.

Some people have too much spare time though.

The nice thing about the job is that I get to program Python for a living now .

This is Customs House, on the bank of the river Liffey.

BTW : The picture shows the interior of the Mezquita in Cordoba.

The photo is of the Clifton suspension bridge.

The problem is that there is no easy way to direct the logging to a new file for every test case. Here’s how I got around it. Firstly the setup method of my testcase object contains the following :

def setUp(self):
    self.logger = logging.getLogger('MyLogger')
    self.logger.setLevel(logging.DEBUG)
    self.log_handler = None
    self.formatter = logging.Formatter("%(asctime)s - %(name)s - %(message)s")

A logger is created and the default level is set. Then variables are set for the log_handler and formatter. These are used in the settestcasename method found below. This gets called in every test method of the testcase class. First it removes the old handler. The testcase name given as parameter is then used to create a new FileHandler. This will create and log to a new file when something is logged. This new handler is then added to the logger.

def settestcasename(self,giventestcasename,description=""):
    now=datetime.datetime.today().strftime('%Y%m%d_%H%M%S')
    if self.log_handler is not None:
        self.log_handler.close()
        self.logger.removeHandler(self.log_handler)
    filename='%s_%s.log' % (giventestcasename.replace(' ','_'), now)
    self.log_handler=logging.FileHandler(filename,'w')
    self.log_handler.setFormatter(self.formatter)
    self.logger.addHandler(self.log_handler)

The fact that the settestcasename has to be called is not ideal. but it works me. Something evil like this could be used to get the name of the current method, which can then be used as a filename. A decorator can possibly be created as well.

   mydict={'first':1, 'second':2, 'third':3}

and you want to get the values into a list with a certain order you can do this :

   mylist=[mydict['first'], mydict['second'], mydict['third']]

However, that can get a bit verbose if there are a lot of entries. For every entry you have to repeat ‘mydict’. An elegant way of solving this is using the map function :

   mylist=map(mydict.get,['first', 'second', 'third'])

This applies to ‘get’ function of mydict to each of the arguments given in the list. This ‘get’ function is the equivalent of calling mydict['some index'] .

List comprehensions can be used a lot of times instead of map. That’s the case here as well :

   mylist=[mydict[x] for x in ['first','second','third']]

This is arguably easier to understand than the version using map.

This picture is Windsor Castle, by the way.