这看起来应该是微不足道的，但我是 Python 的新手，想以最 Pythonic 的方式来做。
我想找到与字符串中第 n 次出现的子字符串对应的索引。
必须有一些与我想做的事情相当的事情
mystring.find("substring", 2nd)
如何在 Python 中实现这一点？
【问题讨论】：
对于具有基本编程知识的人的简单解决方案：
# Function to find the nth occurrence of a substring in a text
def findnth(text, substring, n):
# variable to store current index in loop
count = -1
# n count
occurance = 0
# loop through string
for letter in text:
# increment count
count += 1
# if current letter in loop matches substring target
if letter == substring:
# increment occurance
occurance += 1
# if this is the nth time the substring is found
if occurance == n:
# return its index
return count
# otherwise indicate there is no match
return "No match"
# example of how to call function
print(findnth('C$100$150xx', "$", 2))
【讨论】：
我使用了 findnth() 函数并遇到了一些问题，因此我重写了该函数的更快版本（没有列表拆分）：
def findnth(haystack, needle, n):
if not needle in haystack or haystack.count(needle) < n:
return -1
last_index = 0
cumulative_last_index = 0
for i in range(0, n):
last_index = haystack[cumulative_last_index:].find(needle)
cumulative_last_index += last_index
# if not last element, then jump over it
if i < n-1:
cumulative_last_index += len(needle)
return cumulative_last_index
【讨论】：
这是一个简单而有趣的方法：
def index_of_nth(text, substring, n) -> int:
index = 0
for _ in range(n):
index = text.index(substring, index) + 1
return index - 1
【讨论】：
以防万一有人想从后面找到第 n 个：
def find_nth_reverse(haystack: str, needle: str, n: int) -> int:
end = haystack.rfind(needle)
while end >= 0 and n > 1:
end = haystack.rfind(needle, 0, end - len(needle))
n -= 1
return end
【讨论】：
当提供的发生输入值高于实际发生次数时，避免失败或错误输出。例如，在字符串 'overflow' 中，如果您要检查 'o' 的第 3 次出现（它只有 2 次出现），那么下面的代码将返回一条警告或消息，指示已超过出现值。
def check_nth_occurrence (string, substr, n):
## Count the Occurrence of a substr
cnt = 0
for i in string:
if i ==substr:
cnt = cnt + 1
else:
pass
## Check if the Occurrence input has exceeded the actual count of Occurrence
if n > cnt:
print (f' Input Occurrence entered has exceeded the actual count of Occurrence')
return
## Get the Index value for first Occurrence of the substr
index = string.find(substr)
## Get the Index value for nth Occurrence of Index
while index >= 0 and n > 1:
index = string.find(substr, index+ 1)
n -= 1
return index
【讨论】：
定义：
def get_first_N_words(mytext, mylen = 3):
mylist = list(mytext.split())
if len(mylist)>=mylen: return ' '.join(mylist[:mylen])
使用方法：
get_first_N_words(' One Two Three Four ' , 3)
输出：
'One Two Three'
【讨论】：
对于搜索第 n 次出现的字符（即长度为 1 的子字符串）的特殊情况，以下函数通过构建给定字符的所有出现位置的列表来工作：
def find_char_nth(string, char, n):
"""Find the n'th occurence of a character within a string."""
return [i for i, c in enumerate(string) if c == char][n-1]
如果给定字符的出现次数少于n，则会给出IndexError: list index out of range。
这源自@Zv_oDD 的answer，并针对单个字符的情况进行了简化。
【讨论】：
这是我在字符串a 中查找b 的nth 出现的解决方案：
from functools import reduce
def findNth(a, b, n):
return reduce(lambda x, y: -1 if y > x + 1 else a.find(b, x + 1), range(n), -1)
它是纯 Python 和迭代的。对于太大的 0 或 n，它返回 -1。它是单线的，可以直接使用。这是一个例子：
>>> reduce(lambda x, y: -1 if y > x + 1 else 'bibarbobaobaotang'.find('b', x + 1), range(4), -1)
7
【讨论】：
不使用循环和递归的解决方案。
在编译方法中使用所需的模式并输入所需的 出现在变量 'n' 中，最后一条语句将打印 给定模式中第 n 次出现的起始索引 细绳。这里是 finditer 的结果，即迭代器正在被转换 列出并直接访问第 n 个索引。
import re
n=2
sampleString="this is history"
pattern=re.compile("is")
matches=pattern.finditer(sampleString)
print(list(matches)[n].span()[0])
【讨论】：
这将在字符串中找到第二次出现的子字符串。
def find_2nd(string, substring):
return string.find(substring, string.find(substring) + 1)
编辑：我没有过多考虑性能，但快速递归可以帮助找到第 n 次出现：
def find_nth(string, substring, n):
if (n == 1):
return string.find(substring)
else:
return string.find(substring, find_nth(string, substring, n - 1) + 1)
【讨论】：
n 的情况。 （在这种情况下，返回值会周期性地循环遍历所有出现的位置）。
# return -1 if nth substr (0-indexed) d.n.e, else return index
def find_nth(s, substr, n):
i = 0
while n >= 0:
n -= 1
i = s.find(substr, i + 1)
return i
【讨论】：
find_nth('aaa', 'a', 0) 返回 1 而它应该返回 0。你需要像i = s.find(substr, i) + 1 这样的东西，然后返回i - 1。
基于 model13 的答案，但没有 re 模块依赖项。
def iter_find(haystack, needle):
return [i for i in range(0, len(haystack)) if haystack[i:].startswith(needle)]
我有点希望这是一个内置的字符串方法。
>>> iter_find("http://stackoverflow.com/questions/1883980/", '/')
[5, 6, 24, 34, 42]
【讨论】：
这将为您提供与 yourstring 匹配的起始索引数组：
import re
indices = [s.start() for s in re.finditer(':', yourstring)]
那么您的第 n 个条目将是：
n = 2
nth_entry = indices[n-1]
当然，您必须小心索引范围。您可以像这样获取yourstring 的实例数：
num_instances = len(indices)
【讨论】：
这是你真正想要的答案：
def Find(String,ToFind,Occurence = 1):
index = 0
count = 0
while index <= len(String):
try:
if String[index:index + len(ToFind)] == ToFind:
count += 1
if count == Occurence:
return index
break
index += 1
except IndexError:
return False
break
return False
【讨论】：
怎么样：
c = os.getcwd().split('\\')
print '\\'.join(c[0:-2])
【讨论】：
最简单的方法？
text = "This is a test from a test ok"
firstTest = text.find('test')
print text.find('test', firstTest + 1)
【讨论】：
提供另一个“棘手”的解决方案，使用split 和join。
在你的例子中，我们可以使用
len("substring".join([s for s in ori.split("substring")[:2]]))
【讨论】：
我提供了一些基准测试结果，比较了迄今为止提出的最突出的方法，即@bobince 的findnth()（基于str.split()）与@tgamblin 或@Mark Byers 的find_nth()（基于str.find() ）。我还将与 C 扩展 (_find_nth.so) 进行比较，看看我们能走多快。这里是find_nth.py：
def findnth(haystack, needle, n):
parts= haystack.split(needle, n+1)
if len(parts)<=n+1:
return -1
return len(haystack)-len(parts[-1])-len(needle)
def find_nth(s, x, n=0, overlap=False):
l = 1 if overlap else len(x)
i = -l
for c in xrange(n + 1):
i = s.find(x, i + l)
if i < 0:
break
return i
当然，如果字符串很大，性能最重要，所以假设我们想在一个名为“bigfile”的 1.3 GB 文件中找到第 1000001 个换行符（“\n”）。为了节省内存，我们想处理文件的mmap.mmap 对象表示：
In [1]: import _find_nth, find_nth, mmap
In [2]: f = open('bigfile', 'r')
In [3]: mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
findnth() 已经存在第一个问题，因为mmap.mmap 对象不支持split()。所以我们实际上必须将整个文件复制到内存中：
In [4]: %time s = mm[:]
CPU times: user 813 ms, sys: 3.25 s, total: 4.06 s
Wall time: 17.7 s
哎哟！幸运的是 s 仍然适合我的 Macbook Air 的 4 GB 内存，所以让我们对 findnth() 进行基准测试：
In [5]: %timeit find_nth.findnth(s, '\n', 1000000)
1 loops, best of 3: 29.9 s per loop
显然是糟糕的表现。让我们看看基于str.find() 的方法是如何做的：
In [6]: %timeit find_nth.find_nth(s, '\n', 1000000)
1 loops, best of 3: 774 ms per loop
好多了！显然，findnth() 的问题在于它在split() 期间被强制复制字符串，这已经是我们在s = mm[:] 之后第二次复制大约 1.3 GB 的数据。 find_nth() 的第二个优点是：我们可以直接在 mm 上使用它，这样就需要 零 个文件副本：
In [7]: %timeit find_nth.find_nth(mm, '\n', 1000000)
1 loops, best of 3: 1.21 s per loop
在mm 与s 上运行似乎存在小的性能损失，但这说明find_nth() 可以在1.2 秒内为我们提供答案，而findnth 的总时间为47 秒。
我没有发现基于str.find() 的方法明显比基于str.split() 的方法差的情况，所以在这一点上，我认为应该接受@tgamblin 或@Mark Byers 的答案而不是@bobince 的答案。
在我的测试中，上面find_nth() 的版本是我能想到的最快的纯Python 解决方案（与@Mark Byers 的版本非常相似）。让我们看看使用 C 扩展模块可以做得更好。这里是_find_nthmodule.c：
#include <Python.h>
#include <string.h>
off_t _find_nth(const char *buf, size_t l, char c, int n) {
off_t i;
for (i = 0; i < l; ++i) {
if (buf[i] == c && n-- == 0) {
return i;
}
}
return -1;
}
off_t _find_nth2(const char *buf, size_t l, char c, int n) {
const char *b = buf - 1;
do {
b = memchr(b + 1, c, l);
if (!b) return -1;
} while (n--);
return b - buf;
}
/* mmap_object is private in mmapmodule.c - replicate beginning here */
typedef struct {
PyObject_HEAD
char *data;
size_t size;
} mmap_object;
typedef struct {
const char *s;
size_t l;
char c;
int n;
} params;
int parse_args(PyObject *args, params *P) {
PyObject *obj;
const char *x;
if (!PyArg_ParseTuple(args, "Osi", &obj, &x, &P->n)) {
return 1;
}
PyTypeObject *type = Py_TYPE(obj);
if (type == &PyString_Type) {
P->s = PyString_AS_STRING(obj);
P->l = PyString_GET_SIZE(obj);
} else if (!strcmp(type->tp_name, "mmap.mmap")) {
mmap_object *m_obj = (mmap_object*) obj;
P->s = m_obj->data;
P->l = m_obj->size;
} else {
PyErr_SetString(PyExc_TypeError, "Cannot obtain char * from argument 0");
return 1;
}
P->c = x[0];
return 0;
}
static PyObject* py_find_nth(PyObject *self, PyObject *args) {
params P;
if (!parse_args(args, &P)) {
return Py_BuildValue("i", _find_nth(P.s, P.l, P.c, P.n));
} else {
return NULL;
}
}
static PyObject* py_find_nth2(PyObject *self, PyObject *args) {
params P;
if (!parse_args(args, &P)) {
return Py_BuildValue("i", _find_nth2(P.s, P.l, P.c, P.n));
} else {
return NULL;
}
}
static PyMethodDef methods[] = {
{"find_nth", py_find_nth, METH_VARARGS, ""},
{"find_nth2", py_find_nth2, METH_VARARGS, ""},
{0}
};
PyMODINIT_FUNC init_find_nth(void) {
Py_InitModule("_find_nth", methods);
}
这是setup.py 文件：
from distutils.core import setup, Extension
module = Extension('_find_nth', sources=['_find_nthmodule.c'])
setup(ext_modules=[module])
使用python setup.py install 照常安装。 C 代码在这里发挥了优势，因为它仅限于查找单个字符，但让我们看看这有多快：
In [8]: %timeit _find_nth.find_nth(mm, '\n', 1000000)
1 loops, best of 3: 218 ms per loop
In [9]: %timeit _find_nth.find_nth(s, '\n', 1000000)
1 loops, best of 3: 216 ms per loop
In [10]: %timeit _find_nth.find_nth2(mm, '\n', 1000000)
1 loops, best of 3: 307 ms per loop
In [11]: %timeit _find_nth.find_nth2(s, '\n', 1000000)
1 loops, best of 3: 304 ms per loop
显然还是要快很多。有趣的是，内存中的情况和映射的情况在 C 级别上没有区别。同样有趣的是，基于string.h 的memchr() 库函数的_find_nth2() 输给了_find_nth() 中的直接实现：memchr() 中的额外“优化”显然适得其反。 ..
总之，findnth()（基于str.split()）中的实现确实是个坏主意，因为（a）由于需要复制，它对较大的字符串执行得非常糟糕，以及（b）
它根本不适用于mmap.mmap 对象。在任何情况下都应该首选find_nth()（基于str.find()）中的实现（因此是这个问题的公认答案）。
仍有相当大的改进空间，因为 C 扩展的运行速度几乎是纯 Python 代码的 4 倍，这表明可能需要专门的 Python 库函数。
【讨论】：
更换一个衬里很棒，但只能工作，因为 XX 和 bar 具有相同的 lentgh
一个好的通用定义是：
def findN(s,sub,N,replaceString="XXX"):
return s.replace(sub,replaceString,N-1).find(sub) - (len(replaceString)-len(sub))*(N-1)
【讨论】：
这里是直接迭代解决方案的更 Pythonic 版本：
def find_nth(haystack, needle, n):
start = haystack.find(needle)
while start >= 0 and n > 1:
start = haystack.find(needle, start+len(needle))
n -= 1
return start
例子：
>>> find_nth("foofoofoofoo", "foofoo", 2)
6
如果你想找到needle的第n个重叠，你可以增加1而不是len(needle)，像这样：
def find_nth_overlapping(haystack, needle, n):
start = haystack.find(needle)
while start >= 0 and n > 1:
start = haystack.find(needle, start+1)
n -= 1
return start
例子：
>>> find_nth_overlapping("foofoofoofoo", "foofoo", 2)
3
这比Mark的版本更容易阅读，而且不需要拆分版本的额外内存或导入正则表达式模块。它还遵守Zen of python 中的一些规则，与各种re 方法不同：
【讨论】：
find_nth 的建议文档字符串："""Finds index of the *n*'th occurrence of *needle* within *haystack*. Returns -1 when the *n*'th occurrence is not found."""
start = haystack.find(needle, start_position)
这是另一个re + itertools 版本，在搜索str 或RegexpObject 时应该可以使用。我会坦率地承认，这可能是过度设计的，但出于某种原因，它让我很开心。
import itertools
import re
def find_nth(haystack, needle, n = 1):
"""
Find the starting index of the nth occurrence of ``needle`` in \
``haystack``.
If ``needle`` is a ``str``, this will perform an exact substring
match; if it is a ``RegexpObject``, this will perform a regex
search.
If ``needle`` doesn't appear in ``haystack``, return ``-1``. If
``needle`` doesn't appear in ``haystack`` ``n`` times,
return ``-1``.
Arguments
---------
* ``needle`` the substring (or a ``RegexpObject``) to find
* ``haystack`` is a ``str``
* an ``int`` indicating which occurrence to find; defaults to ``1``
>>> find_nth("foo", "o", 1)
1
>>> find_nth("foo", "o", 2)
2
>>> find_nth("foo", "o", 3)
-1
>>> find_nth("foo", "b")
-1
>>> import re
>>> either_o = re.compile("[oO]")
>>> find_nth("foo", either_o, 1)
1
>>> find_nth("FOO", either_o, 1)
1
"""
if (hasattr(needle, 'finditer')):
matches = needle.finditer(haystack)
else:
matches = re.finditer(re.escape(needle), haystack)
start_here = itertools.dropwhile(lambda x: x[0] < n, enumerate(matches, 1))
try:
return next(start_here)[1].start()
except StopIteration:
return -1
【讨论】：
>>> s="abcdefabcdefababcdef"
>>> j=0
>>> for n,i in enumerate(s):
... if s[n:n+2] =="ab":
... print n,i
... j=j+1
... if j==2: print "2nd occurence at index position: ",n
...
0 a
6 a
2nd occurence at index position: 6
12 a
14 a
【讨论】：
这是使用 re.finditer 的另一种方法。
不同的是，这只是在必要时查看干草堆
from re import finditer
from itertools import dropwhile
needle='an'
haystack='bananabanana'
n=2
next(dropwhile(lambda x: x[0]<n, enumerate(re.finditer(needle,haystack))))[1].start()
【讨论】：
我可能会做这样的事情，使用带有索引参数的 find 函数：
def find_nth(s, x, n):
i = -1
for _ in range(n):
i = s.find(x, i + len(x))
if i == -1:
break
return i
print find_nth('bananabanana', 'an', 3)
我猜这不是特别 Pythonic，但它很简单。您可以使用递归来代替：
def find_nth(s, x, n, i = 0):
i = s.find(x, i)
if n == 1 or i == -1:
return i
else:
return find_nth(s, x, n - 1, i + len(x))
print find_nth('bananabanana', 'an', 3)
这是一种解决问题的实用方法，但我不知道这是否使它更 Pythonic。
【讨论】：
for _ in xrange(n):可以代替while n: ... n-=1
return find_nth(s, x, n - 1, i + 1) 应该是 return find_nth(s, x, n - 1, i + len(x))。没什么大不了的，但节省了一些计算时间。
了解正则表达式并不总是最好的解决方案，我可能会在这里使用一个：
>>> import re
>>> s = "ababdfegtduab"
>>> [m.start() for m in re.finditer(r"ab",s)]
[0, 2, 11]
>>> [m.start() for m in re.finditer(r"ab",s)][2] #index 2 is third occurrence
11
【讨论】：
(m.start() for m in re.finditer(r"ab",s))[2]
itertools.islice 函数可以实现类似且丑陋的解决方案：next(islice(re.finditer(r"ab",s), 2, 2+1)).start()
我认为，Mark 的迭代方法将是通常的方法。
这里有一个字符串分割的替代方案，它通常对查找相关的过程很有用：
def findnth(haystack, needle, n):
parts= haystack.split(needle, n+1)
if len(parts)<=n+1:
return -1
return len(haystack)-len(parts[-1])-len(needle)
这里有一个快速（而且有点脏，因为你必须选择一些无法匹配针的箔条）单线：
'foo bar bar bar'.replace('bar', 'XXX', 1).find('bar')
【讨论】：
.rfind('XXX') 等效的操作，但如果'XXX' 无论如何都出现在输入的后面，那将分崩离析。