How do I avoid deep nesting in this Python code?

Why not using a list of tuple (re, lambda match: action), that is something like

actions = [("(\S+) (\S+)", lambda match: "Multiword: %s+%s" % (match.group(1), match.group(2))),
           ("y$", lambda match: "Positive"),
           ("n$", lambda match: "Negative")]

and then:

for rex, action in actions:
     match = re.match(rex, s)
     if match: 
          print action(match)

If you need to mix search and match then you can use a list of tuple:

(matchmethod, rex, action)

as in

actions = [
    (re.search, "(\S+) (\S+)", lambda match: "Multiword: %s+%s"%(match.group(1), match.group(2)) ),
    (re.match, "y$", lambda match: "Positive"),
    (re.match, "n$", lambda match: "Negative")]

And of course:

for matchtype, rex, action in actions:
     match = matchtype(rex, s)
     if match: 
          print action(match)

I'd put it in a function and return from it when a match was found, that way you don't have all the indents for the else: cases, just a list of tests and returns for them:

import re
strings = ["abc zzz", "y", "#comment"]

def run_tests(s)
    match = re.search("(\S+) (\S+)", s)
    if match:
        print "Multiword: %s+%s" % (match.group(1), match.group(2))
        return

    if re.match("y$", s):
        print "Positive"
        return

    if re.match("n$", s):
        print "Negative"
        return

    # a few more matches possible in real life script,
    # and then the last catch-all:
    print "No match found, line skipped"

for s in strings:
    run_tests(s)

I'd try to put the list of tests into some data structure to loop over (like the messages and the patterns to test for), but because the code is slightly different (search vs match, simple print vs doing something with match) it's clearer just to keep it like this.

I like @hivert's approach, but would formalize it a bit more:

import re

tests = [
    ("(\S+) (\S+)", "Multiword: {0}+{1}"),
    ("^y$",         "Positive"),
    ("^n$",         "Negative")
]

def get_first_match(s, tests=tests, none_match="No match found, line skipped"):
    for reg,fmt in tests:
        match = re.search(reg, s)
        if match:
            return fmt.format(*match.groups())
    return none_match

then

strings = ["abc zzz", "y", "#comment"]
for s in strings:
    print(get_first_match(s))

This is a known issue with regexps. But you can just put the options in a container, such as a list, and then use a for loop:

import re
strings = ["abc zzz", "y", "#comment"]
regexps_and_messages = [
    ("(\S+) (\S+)", "Multiword: %s+%s"),
    ("y$", "Positive"),
    ("n$", "Negative"),
]

for s in strings:
    for regexp, message in regexps_and_messages:
        m = re.match(regexp, s)
        if m is not None:
            print message % m.groups()
            break
    else: # if no break in above loop
        print "No match found, line skipped"

To go even further on the approaches suggested that put the regexes in a list you could join the regexes together with | and then match the line against all possible patterns in one go.

import re

class LineMatcher(object):
    def __init__(self, patterns):
        # In order to match each string, we build a regex combining which can match
        # all the parts. 
        # Something like: ((\S+) (\S+))|(y$)|(n$)|(.*))
        # When we match against it, we can figure out which pattern was matched
        self._groups = {}
        regexes = []

        # because groups could contain groups, we need to keep track of the current
        # group index so that we know which index each pattern will end up with.
        current_group_index = 1
        for pattern, handler in patterns:
            group_count = re.compile(pattern).groups
            self._groups[current_group_index] = (group_count, handler)
            regexes.append("(%s)" % pattern)
            current_group_index += group_count + 1

        self._regex = re.compile("|".join(regexes))

    def match(self, string):
        match = self._regex.match(string)
        group_count, handler = self._groups[match.lastindex]
        captures = match.groups()[match.lastindex:match.lastindex + group_count]
        return handler(*captures)


matcher = LineMatcher([
    ("(\S+) (\S+)", lambda first, second: "Multiword: %s+%s"),
    ("y$", lambda: "Positive"),
    ("n$", lambda: "Negative"),
    (".*", lambda: "No match found, line skipped")
])


strings = ["abc zzz", "y", "#comment"]
for s in strings:
    print matcher.match(s)

Calpratt's answer without continue:

import re
strings = ["abc zzz", "y", "#comment"]
for s in strings:
    match = re.search("(\S+) (\S+)", s)
    if match:
        print "Multiword: %s+%s" % (match.group(1), match.group(2))
    elif re.match("y$", s):
        print "Positive"
    elif re.match("n$", s):
        print "Negative"
    else:
        print "No match found, line skipped"

You can make flow of your application more linear by either return-ing from the method when failing or do it Python way using Exceptions, e.g.:

try:
    if not do_action_1:
        raise Exception('Action 1 failed')
    if not do_action_2:
        raise Exception('Action 2 failed')
    if not do_action_3:
        raise Exception('Action 3 failed')
    if not do_action_4:
        raise Exception('Action 4 failed')
    if not do_action_5:
        raise Exception('Action 5 failed')
except Exception as e:
    print 'Whoops: %s' % e