writing python function to handle error cases while parsing a list

Try ... except gives you lots of flexibility to work with the code, and it will be a good idea,

Check this doc python exception handling

Exception handling provides the following advantages over ``traditional'' error management techniques:

separating Error Handling Code from ``regular'' one provides a way to separate the details of what to do when something out-of-the-ordinary happens from the normal logical flow of the program code; propagating Errors Up the Call Stack lets the corrective action to be taken at a higher level. This allows the corrective action to be taken in the method that calling that one where an error occurs; grouping Error Types and Error Differentiation allows to create similar hierarchical structure for exception handling so groups they in logical way.

Just an Example:

def count_occurrences(p,letter):
    count = 0
    for elem in p:
        try:    # Put you code which can throw exception in try Block
            if elem[0]==letter:
                count = count+1
        except Exception, ex: # You can catch specific exceptions if you want over here
              print ex.message  # Handle your exception here
              #raise   # The 'raise' statement with no arguments inside an error
                       # handler tells Python to re-raise the exception with the 
                       # original traceback intact

    return count

You have to decide what you want from your function:

def count_occurrences(p,letter):
    count = 0
    for elem in p:
        if isinstance(elem, basestring):
            if elem[0]==letter:
                count = count+1
        else:
            # you could do something else here or just ignore it, but it seems
            # that your function really needs a list of strings as argument 
            # so it would be an error to call it with anything else and it should 
            # not fail silently.
            raise TypeError("String expected")
    return count

• Either it could ignore elements not matching the type. In that case you leave the else-section blank in the above example.
• You want to only accept list-of-strings as argument. In that case, the above example is completely yours and it will even raise an error if an invalid type is passed.

See the python documentation on isinstance for further help.

On a sidenote try-except block outside the loop could bring more performance though.

More effectively written as:

sum(1 for i in sequence if i.startswith('d')) # or for single char i[0] == 'd'

If it's an invalid type, then you can either fail the operation using try/except, or filter out only the suitable type, eg:

sum(1 for i in sequence if isinstance(i, basestring) and i[0] == 'd')

Or to handle a fail because the list should be homogeneous:

   try:
       return sum(1 for i in sequence if i[0] =='d')
   except TypeError as e:
       pass # type doesn't have subscripting
   except IndexError as e:
       pass # may or may not be a str, but len() == 0

etc...

On a side note: using str.startswith('d') won't raise, so ''.startswith('d') returns False.

If you won't to use the try ... except you could do something like this:

if isinstance(elem[0],int): 
 { ... }

In that way, perharps, you can "skip" over that element.

A better solution would be test isinstance with the correct type and, in case of "test failure" skip the element.

So

if isinstance(elem,str) and elem[0]==letter:
 {...}