try:
    do_something()
except:
    pass

You will use the pass statement.

The pass statement does nothing. It can be used when a statement is required syntactically but the program requires no action.

If you literally want to raise an exception only on the empty string, you'll need to do that manually:

try:
    user_input = input() # raw_input in Python 2.x
    if not user_input:
        raise ValueError('empty string')
except ValueError as e:
    print(e)

But that "integer input" part of the comment makes me think what you really want is to raise an exception on anything other than an integer, including but not limited to the empty string.

If so, open up your interactive interpreter and see what happens when you type things like int('2'), int('abc'), int(''), etc., and the answer should be pretty obvious.

But then how do you distinguish an empty string from something different? Simple: Just do the user_input = input() before the try, and check whether user_input is empty within the except. (You put if statements inside except handlers all the time in real code, e.g., to distinguish an OSError with an EINTR errno from one with a different errno.)

I think you are accurate about the trade-off involved - neither is ideal. Out of those two, I personally prefer the first one since the control flow is easier to follow.

That said, I'd suggest considering a third option that you didn't mention: factor out some or all of the recovery logic into a separate function. That keeps the control flow simple and avoids having a big block of recovery code in the except clause.

I would just use return l if l else None, you could try to index the list but I would not recommend it.

def foo(l):
    try:
        l[0]
        return l
    except IndexError:
        return None

Sure, you can use pass to pass a block:

try:
    pass
except:
    pass
finally:
    pass

More examples:

def a():
    pass

while True:
    pass

for i in range(10):
    pass
...

This means the exception has no message attached. Print the exception type:

print repr(e)

You may also want to print the traceback:

import traceback

# ...
except BaseException as e:
    traceback.print_exc()

You want to avoid catching BaseException however, this is no better than a blanket except: statement. Catch more specific exceptions instead.

The function wikipedia.page will raise a wikipedia.exceptions.PageError if the page doesn't exist. That's the error you want to catch.

import wikipedia
links = ["CPython","no page"]
test=[]
for link in links:
    try:
        #try to load the wikipedia page
        page=wikipedia.page(link, auto_suggest=False)
        test.append(page)
    except wikipedia.exceptions.PageError:
        #if a "PageError" was raised, ignore it and continue to next link
        continue

You have to surround the function wikipedia.page by a try block, so I'm afraid you can't use list comprehension.

The answer is 1: no exceptions, in Python 2 and in Python 3.

exceptions = ()
try:
    a = 1 / 0
except exceptions as e:
    print ("the answer is 2")

Traceback (most recent call last):  File "<pyshell#38>", line 2, in <module>
a = 1 / 0
ZeroDivisionError: integer division or modulo by zero

If you want to the behaviour of answer 2 when the list of exceptions is empty, you can do

except exceptions or (Exception,) as e:

Just write

pass

as in

try:
    # Do something illegal.
    ...
except:
    # Pretend nothing happened.
    pass

EDIT: @swillden brings up a good point, viz., this is a terrible idea in general. You should, at the least, say

except TypeError, DivideByZeroError:

or whatever kinds of errors you want to handle. Otherwise you can mask bigger problems.

The answer is "no" to both of your questions.

As soon as an error is thrown in a try/except block, the try part is immediately exited:

>>> try:
...     1/0
...     print 'hi'
... except ZeroDivisionError, e:
...     print 'error'
...
error
>>>

As you can see, the code never gets to the print 'hi' part, even though I made an except for it.

You can read more here.

Either drop the except Block, or improove it really by adding

except [Exception-Class]:
    pass

where [Exception-Class] is the exception to be excepted. This adds some sugar on it, because really unexpected Errors are not getting catched by this. (Or add this as a seperate:

except Exception, ex:
    print "Unexpected error:", ex

Set sol in the beginning of each loop to some value and check it in the except clause

about else

try/except has an else which will be run the try block did not raise an Exception

and for has an else clause for when it was not broken out of!

for foo in iterable:
    # set value so the name will be available
    # can be set prior to the loop, but this clears it on each iteration
    # which seems more desirable for your case
    sol = None
    try:
        "logic here"
    except Exception:
        if isinstance(sol, list):
            "case where sol is a list and not None"
        # pass is implied
    else:  # did not raise an Exception
        break
else:  # did not break out of for loop
    raise Exception("for loop was not broken out of!")

except Exception:
    pass

Python docs for the pass statement