Question

说我有以下字符串之一：

"a b c d e f f g" || "a b c f d e f g"

我希望整个字符串中只出现一个子字符串（在这种情况下为 f ），以便对其进行某种程度的清理。每个字符串的结果将是：

"a b c d e f g" || "a b c d e f g"

使用示例为：

str = "a b c d e f g g g g g h i j k l"
str.leaveOne("g") 
#// a b c d e f g h i j k l

Answer 1

如果您离开哪个实例都没有关系，则可以使用pom.xml，它带有一个参数，表示要执行的替换次数：

str.replace

这将保留最后一个事件。

我们可以通过两次反转字符串来修改它以使 first 出现：

def leave_one_last(source, to_remove):
    return source.replace(to_remove, '', source.count(to_remove) - 1)

但是，这很丑陋，更不用说效率低下了。一种更优雅的方法可能是找到以字符的第一次出现结尾的子字符串，将其替换为其余字符，最后将它们串联在一起：

def leave_one_first(source, to_remove):
    return source[::-1].replace(to_remove, '', source.count(to_remove) - 1)[::-1]

如果我们尝试这样做：

def leave_one_first_v2(source, to_remove):
    first_index = source.index(to_remove) + 1
    return source[:first_index] + source[first_index:].replace(to_remove, '')

输出：

string = "a b c d e f g g g g g h i j k l g"

print(leave_one_last(string, 'g'))
print(leave_one_first(string, 'g'))
print(leave_one_first_v2(string, 'g'))

如果您不想保留空格，则应使用基于a b c d e f h i j k l g a b c d e f g h i j k l a b c d e f g h i j k l的版本：

split

输出：

def leave_one_split(source, to_remove):
    chars = source.split()
    first_index = chars.index(to_remove) + 1
    return ' '.join(chars[:first_index] + [char for char in chars[first_index:] if char != to_remove])

string = "a b c d e f g g g g g h i j k l g"

print(leave_one_split(string, 'g'))

Answer 2

如果我的理解正确，您可以使用正则表达式和re.sub查找包含两个或多个字母的组（带或不带空格）并将其替换为单个实例：

import re
def leaveOne(s, char):  
    return re.sub(r'((%s\s?)){2,}' % char, r'\1' , s)

leaveOne("a b c d e f g g g h i j k l", 'g') 
# 'a b c d e f g h i j k l'

leaveOne("a b c d e f ggg h i j k l", 'g')
# 'a b c d e f g h i j k l'

leaveOne("a b c d e f g h i j k l", 'g')
# 'a b c d e f g h i j k l'

编辑

如果目标是消除字母中的所有个字母，那么您仍然可以使用带正则表达式的正则表达式来选择所有字母，然后选择相同的字母

import re
def leaveOne(s, char):  
    return re.sub(r'(%s)\s?(?=.*?\1)' % char, '' , s)

print(leaveOne("a b c d e f g g g h i j k l g", 'g'))
# 'a b c d e f h i j k l g'

print(leaveOne("a b c d e f ggg h i j k l gg g", 'g'))
# 'a b c d e f h i j k l g'

print(leaveOne("a b c d e f g h i j k l", 'g'))
# 'a b c d e f g h i j k l'

这甚至可以用于更复杂的模式，例如：

leaveOne("a b c ffff d e ff g", 'ff')
# 'a b c d e ff g'

Answer 3

给出字符串

mystr = 'defghhabbbczasdvakfafj'

cache = {}

seq = 0
for i in mystr:
    if i not in cache:
        cache[i] = seq
        print (cache[i])
        seq+=1

mylist = []

在这里我给字典订购了值

 for key,value in sorted(cache.items(),key=lambda x : x[1]):
        mylist.append(key)
 print ("".join(mylist))

如何在Python的字符串中仅保留一个已定义的子字符串

3 个答案: