mystring.replace("substring", 2nd)
最简单、最符合 Python 风格的方法是什么？如果存在，您可以使用while循环和str.find查找第n次出现并使用该位置创建新字符串：
def nth_repl(s, sub, repl, n):
find = s.find(sub)
# If find is not -1 we have found at least one match for the substring
i = find != -1
# loop util we find the nth or we find no match
while find != -1 and i != n:
# find + 1 means we start searching from after the last match
find = s.find(sub, find + 1)
i += 1
# If i is equal to n we found nth match so replace
if i == n:
return s[:find] + repl + s[find+len(sub):]
return s
示例：
In [14]: s = "foobarfoofoobarbar"
In [15]: nth_repl(s, "bar","replaced",3)
Out[15]: 'foobarfoofoobarreplaced'
In [16]: nth_repl(s, "foo","replaced",3)
Out[16]: 'foobarfooreplacedbarbar'
In [17]: nth_repl(s, "foo","replaced",5)
Out[17]: 'foobarfoofoobarbar'
我使用一个简单的函数，该函数列出所有出现的情况，选择第n个位置并将其用于将原始字符串拆分为两个子字符串。然后它会在第二个子字符串中替换第一个出现的情况，并将子字符串连接起来形成新的字符串：
import re
def replacenth(string, sub, wanted, n):
where = [m.start() for m in re.finditer(sub, string)][n-1]
before = string[:where]
after = string[where:]
after = after.replace(sub, wanted, 1)
newString = before + after
print(newString)
对于这些变量：
string = 'ababababababababab'
sub = 'ab'
wanted = 'CD'
n = 5
输出：
ababababCDabababab
注意：
where变量实际上是一个匹配位置的列表，你可以选择第n个。但列表项索引通常从0开始，而不是从1开始。因此有一个n-1的索引，而n变量是实际的第n个子字符串。我的示例找到了第5个字符串。如果你使用n索引并想要查找第5个位置，则需要将n设置为4。你通常使用哪一个取决于生成我们的n的函数。
这应该是最简单的方法，但可能不是最 Pythonic 的方法，因为
where变量的构建需要导入re库。也许有人会发现更 Pythonic 的方法。
来源和一些链接如下：
这可能是最简短的解决方案之一，而且没有使用任何外部库。
def replace_nth(sub,repl,txt,nth):
arr=txt.split(sub)
part1=sub.join(arr[:nth])
part2=sub.join(arr[nth:])
return part1+repl+part2
我做了几项测试，一切都完美无缺。
def nth_replace(string, old, new, n=1, option='only nth'):
"""
This function replaces occurrences of string 'old' with string 'new'.
There are three types of replacement of string 'old':
1) 'only nth' replaces only nth occurrence (default).
2) 'all left' replaces nth occurrence and all occurrences to the left.
3) 'all right' replaces nth occurrence and all occurrences to the right.
"""
if option == 'only nth':
left_join = old
right_join = old
elif option == 'all left':
left_join = new
right_join = old
elif option == 'all right':
left_join = old
right_join = new
else:
print("Invalid option. Please choose from: 'only nth' (default), 'all left' or 'all right'")
return None
groups = string.split(old)
nth_split = [left_join.join(groups[:n]), right_join.join(groups[n:])]
return new.join(nth_split)
def Nreplacer(string,srch,rplc,n):
Sstring = string.split(srch)
#first check if substring is even present n times
#then paste the part before the nth substring to the part after the nth substring
#, with the replacement inbetween
if len(Sstring) > (n):
return f'{srch.join(Sstring[:(n)])}{rplc}{srch.join(Sstring[n:])}'
else:
return string
不符合Pythonic规范，也不高效，但可以用一行代码实现：
def replace_nth(base_str, find_str, replace_str, n):
return base_str.replace(find_str, "xxxxx", n-1).replace(find_str, replace_str, 1).replace("xxxxx", find_str)
def replace_nth_occurance(some_str, original, replacement, n):
""" Replace nth occurance of a string with another string
"""
all_replaced = some_str.replace(original, replacement, n) # Replace all originals up to (including) nth occurance and assign it to the variable.
for i in range(n):
first_originals_back = all_replaced.replace(replacement, original, i) # Restore originals up to nth occurance (not including nth)
return first_originals_back
import re
def replacenth(string, sub, wanted, n):
pattern = re.compile(sub)
where = [m for m in pattern.finditer(string)][n-1]
before = string[:where.start()]
after = string[where.end():]
newString = before + wanted + after
return newString
replacenth('abdsahd124njhdasjk124ndjaksnd124ndjkas', '1.*?n', '15', 1)
abdsahd15jhdasjk124ndjaksnd124ndjkas。注意使用 ? 可以避免贪婪匹配。上一个答案几乎完美 - 只需要一个更正：
def replacenth(string, sub, wanted, n):
where = [m.start() for m in re.finditer(sub, string)][n - 1]
before = string[:where]
after = string[where:]
after = after.replace(sub, wanted)
newString = before + after
return newString
string中的wanted字符串比你想要替换的sub出现次数少时。 - sophros@Padraic Cunningham的答案中存在一个简单的错误，当出现次数n只比允许的次数（n = maximum_occurances + 1）多1时。
以下是他代码的修正版本：
def nth_repl(s, old, new, n):
find = s.find(old)
# If find is not -1 we have found at least one match for the substring
i = find != -1
# loop until we find the nth or we find no match
while find != -1 and i != n:
# find + 1 means we start searching from after the last match
find = s.find(old, find + 1)
i += 1
# If i is equal to n we found nth match so replace
if i == n and i <= len(s.split(old))-1:
return s[:find] + new + s[find+len(old):]
return s