Search for a multiword string in a list of stringsModifying an array during a foreach loop [closed]Custom CursorAdapter DesignAdvanced and Detailed Minesweeper ProbabilitiesMultiple indexes over an in memory collection for faster searchFull-color clone of Conway's Game of Life, with a decent GUIA* pathfinding algorithm too slowTiny image scraper for xkcd.comPI Calculator, Interview ChallengeProject Euler #7 10001st primeChecking if a number is divisible by 9Unbreakable average programWhen “How To Ask” is too subtleSelect first value if exists, otherwise select default valueI have a problem …factoryLinkedList with Node implementationInt overflow check in JavaAdministration ElevationEntity framework with repository and Unit Of Work pattern and POCO architectureExtension methods to make ConcurrentDictionary GetOrAdd and AddOrUpdate thread safe when using valueFactory delegatesFactor script to change case of all filenames in a directorySorting large 1GB file with 100 millions numbers using merge sortCar crash reaction timeMatch blood types in CCounting rows in a CSV file that correspond to a database row, each with a million recordsRandom string generationis_numeric_array() is missingDecide if the sum of three numbers is even or oddWhat are some indicators that I was over-thinking my solution to this problem?Chess game for my studentsTo 'this' or not to 'this'?Project Euler Problem 45Brute Force Algorithm in CTic Tac Toe C++Check for balanced parenthesesLoading… animating dots in CSnowfall in HTMLStandardly deviated FibonacciInteger to Alphabet string (“A”, “B”, …“Z”, “AA”, “AB”…)Recording audio in C“Compliment giver” mini-programAliens at the trainA multi-threaded Producer Consumer with C++11Regex to parse horizontal rules in MarkdownA grid and a menu walked into a programLexer+Parser code for my “Reedoo” programming languageTiny Encryption Algorithm (TEA) for arbitrary sized dataUsing default None values in Python when assigning split() to a tuple Attraction near a straight cosmic string Security implications of granting non-root access to privileged ports (<1024) Computing a square root in TeX How can I prevent cheating in my collecting and trading game? Short story identification - man in contact with his parallel world counterparts Find a sequence in the binary digits of π Plot[Zeta[x], {x, 2, 20}, ScalingFunctions -> "Log"] is not logarithmic Peer review: Is this "citation tower" a bad practice? I need a systematic way to consider all crucial factors when building different kinds of near-future cities What are the advantages and disadvantages of water bottles versus bladders? Paradox? Pure Prolog is Turing-complete and yet incapable of expressing list intersection? Best Practice To Provide Contact Information in Paper Honeycomb: a hexagonal grid of letters Why do we need instantaneous speed? Is Collection really stronger than Replacement? Why add vodka to batter for frying fish? Output a unique sign sequence As a teenager volunteering at an organization with otherwise adult members, should I be doing anything to maintain respect? Can my 6 years old daughter be my business partner? In Catan, if you roll a seven and move the robber, do you actually have to rob someone? Is it better for me to study chemistry or physics? Why can members-elect vote for Speaker of the US House of Representatives? A four-letter word in two ways Is my drive failing and is this the same reason my laptop is running slower?

#1 楼

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))
        continue
    match = re.match("y$", s)
    if match:
        print "Positive"
        continue
    match = re.match("n$", s)
    if match:
        print "Negative"
        continue

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

#2 楼

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

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

(matchmethod, rex, action)

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

#3 楼

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)

#4 楼

#5 楼

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"

#6 楼

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)

#7 楼

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"

#8 楼

import re

class Handler:
    PATTERN = ''
    def __init__(self):
        self._pattern = re.compile(self.PATTERN)

    def match(self, *args, **kwargs):
        return self._pattern.match(*args, **kwargs)

    def handle(self, matched):
        pass

class MultiwordHandler(Handler):
    PATTERN = '(\S+) (\S+)'

    def match(self, *args, **kwargs):
        return self._pattern.search(*args, **kwargs)

    def handle(self, matched):
        print 'Multiword: %s+%s' % (matched.group(1), matched.group(2))

class PositiveHandler(Handler):
    PATTERN = 'y$'

    def handle(self, matched):
        print 'Positive'

class NegativeHandler(Handler):
    PATTERN = 'n$'

    def handle(self, matched):
        print 'Negative'

handlers = [MultiwordHandler(), PositiveHandler(), NegativeHandler()]

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

for s in strings:
    for handler in handlers:
        matched = handler.match(s)
        if matched:
            handler.handle(matched)
            break
    else:
        print "No match found, line skipped"

#9 楼

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