这似乎应该是微不足道的，但我是 Python 的新手，想以最 Pythonic 的方式来做。
我想找到与字符串中第 n 次出现的子字符串相对应的索引。
必须有一些相当于我想做的事情是
mystring.find("substring", 2nd)
你如何在 Python 中实现这一点？
问问题
242359 次
26 回答
101
这是直接迭代解决方案的更 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
如果您想找到 的第 n 个重叠出现needle，您可以递增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 的版本更容易阅读，并且不需要拆分版本的额外内存或导入正则表达式模块。它还遵循python Zen 中的一些规则，与各种re方法不同：
- 简单胜于复杂。
- 平面优于嵌套。
- 可读性很重要。
于 2009-12-10T21:45:22.913 回答
89
我认为，马克的迭代方法将是通常的方法。
这是字符串拆分的替代方法，它通常对查找相关进程很有用：
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')
于 2009-12-10T21:26:39.770 回答
43
这将在字符串中找到第二次出现的子字符串。
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)
于 2012-10-26T20:59:02.150 回答
34
了解正则表达式并不总是最好的解决方案，我可能会在这里使用一个：
>>> 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
于 2009-12-10T21:36:42.980 回答
20
我提供了一些基准测试结果，比较了迄今为止提出的最突出的方法，即@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()，这已经是我们在 之后第二次复制 1.3 GB 的数据了s = mm[:]。这里有第二个优点find_nth()：我们可以mm直接使用它，这样就需要文件的零副本：
In [7]: %timeit find_nth.find_nth(mm, '\n', 1000000)
1 loops, best of 3: 1.21 s per loop
mm在vs.上运行似乎有一个小的性能损失s，但这说明find_nth()可以在 1.2 秒内为我们提供答案，findnth而 47 秒的总时间为 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 级别上没有区别。有趣的_find_nth2()是，基于string.h的memchr()库函数的 ，在 中的直接实现中失败了_find_nth()： 中的附加“优化”memchr()显然适得其反……
总之，findnth()（基于str.split()）中的实现确实是一个坏主意，因为（a）由于需要复制，它对较大的字符串执行得非常糟糕，并且（b）它根本不适用于mmap.mmap对象。在所有情况下都应该首选find_nth()（基于）中的实现（因此是这个问题的公认答案）。str.find()
仍有相当大的改进空间，因为 C 扩展的运行速度几乎比纯 Python 代码快 4 倍，这表明可能存在专用 Python 库函数的情况。
于 2014-05-05T18:16:34.320 回答
11
最简单的方法？
text = "This is a test from a test ok"
firstTest = text.find('test')
print text.find('test', firstTest + 1)
于 2015-09-02T15:32:41.587 回答
8
我可能会做这样的事情，使用带有索引参数的 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。
于 2009-12-10T21:14:24.897 回答
4
这将为您提供匹配到的起始索引数组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)
于 2017-01-13T02:19:03.440 回答
2
这是使用 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()
于 2009-12-10T21:45:18.683 回答
2
这是另一个re+itertools版本，在搜索 astr或 a时应该可以使用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
于 2009-12-11T15:06:23.220 回答
2
基于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]
于 2017-04-09T00:06:00.113 回答
2
对于搜索第 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 的答案，并针对单个字符的情况进行了简化。
于 2019-11-21T01:08:56.583 回答
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
于 2009-12-11T00:22:29.250 回答
1
提供另一个“棘手”的解决方案，它使用split和join.
在您的示例中，我们可以使用
len("substring".join([s for s in ori.split("substring")[:2]]))
于 2015-03-31T05:40:02.460 回答
1
# 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
于 2018-01-17T21:36:32.107 回答
1
不使用循环和递归的解决方案。
在编译方法中使用所需的模式并在变量'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])
于 2019-06-20T11:36:54.910 回答
1
这是我在字符串中查找n出现的解决方案：ba
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
于 2019-07-15T21:10:07.940 回答
1
我使用了 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
于 2021-08-28T16:00:21.220 回答
0
更换一个衬里很棒，但仅适用于 XX 和 bar 具有相同的长度
一个好的和一般的定义是：
def findN(s,sub,N,replaceString="XXX"):
return s.replace(sub,replaceString,N-1).find(sub) - (len(replaceString)-len(sub))*(N-1)
于 2013-04-17T22:53:29.533 回答
0
定义：
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'
于 2020-01-06T20:12:49.767 回答
0
当提供的发生输入值高于实际发生计数时，避免失败或错误输出。例如，在字符串 '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
于 2020-11-20T19:03:21.773 回答
0
这是一个简单而有趣的方法：
def index_of_nth(text, substring, n) -> int:
index = 0
for _ in range(n):
index = text.index(substring, index) + 1
return index - 1
于 2021-05-10T15:16:57.243 回答
0
以防万一有人想从后面找到第 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
于 2021-05-13T05:04:22.270 回答
-1
这是您真正想要的答案：
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
于 2016-07-19T18:53:32.347 回答
-1
对于具有基本编程知识的人来说，一个简单的解决方案：
# 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))
于 2021-10-03T00:51:07.423 回答
-3
怎么样：
c = os.getcwd().split('\\')
print '\\'.join(c[0:-2])
于 2016-06-13T16:01:08.760 回答