어떻게 파이썬에서 문장의 일부를 뒤집을 수 있습니까?

Question

나는 문장이, 이제 가정 해 봅시다 :

빠른 갈색 여우가 게으른 개를 내가 2 개 인자, 문장 및 무시하는 것들의 목록을받는 함수를 만들

을 통해 이동합니다. 그리고 그것은 반전 된 단어들로 그 문장을 되 돌린다. 그러나 나는 두 번째 주장에서 그것을 넘겨주는 것들을 무시해야한다.

def main(sentence, ignores): 
    return ' '.join(word[::-1] if word not in ignores else word for word in sentence.split()) 

하지만과 같이 두 번째 목록을 통과 할 경우에만 동작합니다 :

print(main('The quick brown fox jumps over the lazy dog', ['quick', 'lazy'])) 

그러나, 나는이 같은 목록을 전달하려는 : 이것은 내가 지금 무엇을 가지고

print(main('The quick brown fox jumps over the lazy dog', ['quick brown', 'lazy dog'])) 

예상 된 결과 : 두 번째 기본적으로 그래서 ehT quick brown xof spmuj revo eht lazy dog

인수 (목록)에는 무시해야하는 문장의 부분이 있습니다. 단 한 마디가 아닙니다.

정규 표현식을 사용해야합니까?

def main(sentence, ignores): 
    for phrase in ignores: 
     reversed_phrase = ' '.join([word[::-1] for word in phrase.split()]) 
     sentence = sentence.replace(phrase, reversed_phrase) 

    return ' '.join(word[::-1] for word in sentence.split()) 

print(main('The quick brown fox jumps over the lazy dog', ['quick', 'lazy'])) 
print(main('The quick brown fox jumps over the lazy dog', ['quick brown', 'lazy dog'])) 

반환 : 그냥 처음에 당신이 올바른 방법으로 주위에 원하는 문구를 반대하지 왜 ... 그것을 피하기 위해 대신 자리의

Answer 1

을 시도하고 있었다, 다음, 전체 문자열을 역

을

ehT quick nworb xof spmuj revo eht lazy god 
ehT quick brown xof spmuj revo eht lazy dog 

Answer 2

나는 정규 표현식을 피하는 추천하는 첫 번째 사람이야,하지만이 경우없이 수행의 복잡성을 사용하여 추가 복잡성보다 큰 :

import re 

def main(sentence, ignores): 
    # Dedup and allow fast lookup for determining whether to reverse a component 
    ignores = frozenset(ignores) 

    # Make a pattern that will prefer matching the ignore phrases, but 
    # otherwise matches each space and non-space run (so nothing is dropped) 
    # Alternations match the first pattern by preference, so you'll match 
    # the ignores phrases if possible, and general space/non-space patterns 
    # otherwise 
    pat = r'|'.join(map(re.escape, ignores)) + r'|\S+|\s+' 

    # Returns the chopped up pieces (space and non-space runs, but ignore phrases stay together 
    parts = re.findall(pat, sentence) 

    # Reverse everything not found in ignores and then put it all back together 
    return ''.join(p if p in ignores else p[::-1] for p in parts) 

Answer 3

그냥 다른 생각, 모든 단어를 반전 한 후 바로 다시 무시 역 :

>>> from functools import reduce 
>>> def main(sentence, ignores): 
     def r(s): 
      return ' '.join(w[::-1] for w in s.split()) 
     return reduce(lambda s, i: s.replace(r(i), i), ignores, r(sentence)) 

>>> main('The quick brown fox jumps over the lazy dog', ['quick brown', 'lazy dog']) 
'ehT quick brown xof spmuj revo eht lazy dog' 

Answer 4

내가 무시 중복 문구, 예를 들어 문제를 해결하기 위해 시도 ['brown fox', 'quick brown'] @PadraicCunningham 님이 올린 성기.

루핑이 훨씬 더 많고 코드가 덜 파이썬 적이기 때문에 개선 방법에 대한 의견을 듣고 싶습니다.

import re 

def _span_combiner(spans): 
    """replace overlapping spans with encompasing single span""" 
    for i, s in enumerate(spans): 
     start = s[0] 
     end = s[1] 
     for x in spans[i:]: 
      if x[0] < end: 
       end = x[1] 
     yield (start, end) 

def main(sentence, ignores): 
    # spans is a start and finish indices for each ignore phrase in order of occurence 
    spans = sorted(
      [[m.span() for m in re.finditer(p, sentence)][0] for p in ignores if p in sentence] 
    ) 
    # replace overlapping indices with single set of indices encompasing overlapped range 
    spans = [s for s in _span_combiner(spans)] 
    # recreate ignore list by slicing sentence with combined spans 
    ignores = [sentence[s[0]:s[1]] for s in spans] 
    for phrase in ignores: 
     reversed_phrase = ' '.join([word[::-1] for word in phrase.split()]) 
     sentence = sentence.replace(phrase, reversed_phrase) 

    return ' '.join(word[::-1] for word in sentence.split()) 

if __name__ == "__main__": 
    print(main('The quick brown fox jumps over the lazy dog', ['quick', 'lazy'])) 
    print(main('The quick brown fox jumps over the lazy dog', ['brown fox', 'lazy dog'])) 
    print(main('The quick brown fox jumps over the lazy dog', ['nonexistent' ,'brown fox', 'quick brown'])) 
    print(main('The quick brown fox jumps over the brown fox', ['brown fox', 'quick brown'])) 

결과 :

ehT quick nworb xof spmuj revo eht lazy god 
ehT kciuq brown fox spmuj revo eht lazy dog 
ehT quick brown fox spmuj revo eht yzal god 
ehT quick brown fox spmuj revo eht brown fox