我在这里可能有点过火了，但 tl;dr 是原始代码实际上比（编辑：macOS 的）strpbrk() 快，但一些 strpbrk() 实现可能更快！
str.count() 在其内部使用 this bundle of strange and beautiful magic - 难怪它很快。
完整代码在https://github.com/akx/so55822235
Python 代码
这些方法都是用纯 Python 编写的，包括 OP 的原版
def gc_characters_original(haystack):
gc_characters = 0
for c in ("c", "C", "g", "G"):
gc_characters += haystack.count(c)
return gc_characters
def gc_characters_counter(haystack):
counter = Counter(haystack)
return sum(counter.get(c, 0) for c in ["c", "C", "g", "G"])
def gc_characters_manual(haystack):
gc_characters = 0
for x in haystack:
if x in ("c", "C", "g", "G"):
gc_characters += 1
return gc_characters
def gc_characters_iters(haystack):
gc_characters = haystack.count("c") + haystack.count("C") + haystack.count("g") + haystack.count("G")
return gc_characters
Cython 扩展包装 strpbrk()
from libc.string cimport strpbrk
cdef int _count(char* s, char *key):
assert s is not NULL, "byte string value is NULL"
cdef int n = 0
cdef char* pch = strpbrk (s, key)
while pch is not NULL:
n += 1
pch = strpbrk (pch + 1, key)
return n
def count(s, key):
return _count(s, key)
...
def gc_characters_cython(haystack_bytes):
return charcount_cython.count(haystack_bytes, b"cCgG")
手工C扩展包strpbrk()
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <string.h>
static unsigned int count(const char *str, const char *key) {
unsigned int n = 0;
char *pch = strpbrk(str, key);
while (pch != NULL) {
n++;
pch = strpbrk(pch + 1, key);
}
return n;
}
static PyObject *charcount_count(PyObject *self, PyObject *args) {
const char *str, *key;
Py_ssize_t strl, keyl;
if (!PyArg_ParseTuple(args, "s#s#", &str, &strl, &key, &keyl)) {
PyErr_SetString(PyExc_RuntimeError, "invalid arguments");
return NULL;
}
int n = count(str, key);
return PyLong_FromLong(n);
}
static PyMethodDef CharCountMethods[] = {
{"count", charcount_count, METH_VARARGS,
"Count the total occurrences of any s2 characters in s1"},
{NULL, NULL, 0, NULL},
};
static struct PyModuleDef spammodule = {PyModuleDef_HEAD_INIT, "charcount",
NULL, -1, CharCountMethods};
PyMODINIT_FUNC PyInit_charcount(void) { return PyModule_Create(&spammodule); }
...
def gc_characters_cext_b(haystack_bytes):
return charcount.count(haystack_bytes, b"cCgG")
def gc_characters_cext_u(haystack):
return charcount.count(haystack, "cCgG")
测量
在我的 Mac 上，将cCgG 计算在一百万个随机字母的字符串中，即
haystack = "".join(random.choice(string.ascii_letters) for x in range(1_000_000))
haystack_bytes = haystack.encode()
print("original", timeit.timeit(lambda: gc_characters_original(haystack), number=100))
print("unrolled", timeit.timeit(lambda: gc_characters_iters(haystack), number=100))
print("cython", timeit.timeit(lambda: gc_characters_cython(haystack_bytes), number=100))
print("c extension, bytes", timeit.timeit(lambda: gc_characters_cext_b(haystack_bytes), number=100))
print("c extension, unicode", timeit.timeit(lambda: gc_characters_cext_u(haystack), number=100))
print("manual loop", timeit.timeit(lambda: gc_characters_manual(haystack), number=100))
print("counter", timeit.timeit(lambda: gc_characters_counter(haystack), number=100))
产生以下结果：
original 0.34033612700000004
unrolled 0.33661798900000006
cython 0.6542106270000001
c extension, bytes 0.46668797900000003
c extension, unicode 0.4761082090000004
manual loop 11.625232557
counter 7.0389275090000005
因此，除非我的 mac 的 libc 中的 strpbrk() 实现功能严重不足（编辑：确实如此），否则最好使用 .count()。
编辑
我添加了glibc's strcspn()/strpbrk()，它比the näive version of strpbrk() shipped with macOS快得惊人：
original 0.329256
unrolled 0.333872
cython 0.433299
c extension, bytes 0.432552
c extension, unicode 0.437332
c extension glibc, bytes 0.169704 <-- new
c extension glibc, unicode 0.158153 <-- new
glibc 也有 SSE2 和 SSE4 版本的函数，可能会更快。
编辑 2
我又一次回到这个话题，因为我顿悟了 glibc 的 strcspn() 的巧妙查找表如何用于字符计数：
size_t fastcharcount(const char *str, const char *haystack) {
size_t count = 0;
// Prepare lookup table.
// It will contain 1 for all characters in the haystack.
unsigned char table[256] = {0};
unsigned char *ts = (unsigned char *)haystack;
while(*ts) table[*ts++] = 1;
unsigned char *s = (unsigned char *)str;
#define CHECK_CHAR(i) { if(!s[i]) break; count += table[s[i]]; }
for(;;) {
CHECK_CHAR(0);
CHECK_CHAR(1);
CHECK_CHAR(2);
CHECK_CHAR(3);
s += 4;
}
#undef CHECK_CHAR
return count;
}
结果非常令人印象深刻，优于 glibc 实现 4 倍和原始 Python 实现 8.5 倍。
original | 6.463880 sec / 2000 iter | 309 iter/s
unrolled | 6.378582 sec / 2000 iter | 313 iter/s
cython libc | 8.443358 sec / 2000 iter | 236 iter/s
cython glibc | 2.936697 sec / 2000 iter | 681 iter/s
cython fast | 0.766082 sec / 2000 iter | 2610 iter/s
c extension, bytes | 8.373438 sec / 2000 iter | 238 iter/s
c extension, unicode | 8.394805 sec / 2000 iter | 238 iter/s
c extension glib, bytes | 2.988184 sec / 2000 iter | 669 iter/s
c extension glib, unicode | 2.992429 sec / 2000 iter | 668 iter/s
c extension fast, bytes | 0.754072 sec / 2000 iter | 2652 iter/s
c extension fast, unicode | 0.762074 sec / 2000 iter | 2624 iter/s