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.

Okey, so there a few things that need to be explained where.

What is try-except used for?

It is used for catching errors raised by the program. Any code susceptible of raising an exception is inserted inside a try statement, and below that statement, any number of except statements with any single error that you want to catch.

try:
    user_input = int(input('Give me a number: '))
except ValueError:
    print('That is not a number!')

When should i use try-except?

It is not a good practice to use a try-except on every single line of code that could raise an error, because that may be half of it, or more. So when shall you use it? Simple, ask this question: Do I want to do any custom action with that error being raised? If the answer is yes, you are good to go.

Catching Exception or empty except

As I see in your example, you are using an empty except. Using an empty except statement will catch every single error raised that the surrounded code, which is similar (but not the same) as catching Exception. The Exception class is the superclass of every single built-in exception in the Python environment that are non-system-exiting (read here) and its generally a bad practice to catch either all exceptions with except: or Exception with except Exception:. Why? Because you are not letting the user (or even you, the programmer) know what error you are handling. For example:

fruits = ['apple', 'pear', 'banana']
try: 
    selection = fruits[int(input('Select a fruit number (0-2): '))]  
except Exception:
    print('Error!')
    # But wait, are you catching ValueError because the user did not input a number, 
    # or are you catching IndexError because he selected an out of bound array index? 
    # You don't know  

Catching multiple exceptions

Based on the previous example, you can use multiple try-except statements to difference which errors are being raised.

fruits = ['apple', 'pear', 'banana']
try: 
    selection = fruits[int(input('Select a fruit number (0-2): '))]  
except ValueError:
    print('That is not a number')
except IndexError:
    print('That fruit number does not exist!')  

Grouping exceptions

If there are two particular exceptions that you want to use for a same purpose, you can group them in a tuple:

fruits = ['apple', 'pear', 'banana']
try: 
    selection = fruits[int(input('Select a fruit number (0-2): '))]  
except (ValueError, IndexError):
    print('Invalid selection!')  

Your case

Based on this information, add those try-except blocks to your code, and see what possible errors that could be raised during its execution, asking the previously recommended question Do I want to execute some custom action with this error?

Additionally

• There are try-except-else statements. See here
• There are try-except-finally statements. See here
• You can combine them all in a try-except1-except2...exceptN-else-finally statement.
• I recommend you get familiar with built-in errors why practicing this!

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.

You use python3 and in python3 the raise syntax no longer accepts comma-separated arguments.

Use as instead:

except getopt.GetoptError as e:

This form is also backwards-compatible with 2.6 and 2.7.

if self.is_empty:

will always evaluate to True, since it is a Truthy value. You need to call the function like this

if self.is_empty():

And a suggestion: You might want to pop the values only when is_empty() is False, like this

if not self.is_empty():

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.

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!")

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