Как найти первый индекс любого из набора символов в строке

Я хотел бы найти индекс первого вхождения любого "специального" символа в строке, например:

>>> "Hello world!".index([' ', '!'])
5

... за исключением того, что недействителен синтаксис Python. Конечно, я могу написать функцию, которая эмулирует это поведение:

def first_index(s, characters):
    i = []
    for c in characters:
        try:
            i.append(s.index(c))
        except ValueError:
            pass
    if not i:
        raise ValueError
    return min(i)

Я мог бы также использовать регулярные выражения, но оба решения кажутся немного переборщиками. Есть ли какой-либо "нормальный" способ сделать это в Python?

ОТВЕТЫ

Ответ 1

Вы можете использовать enumerate и next с помощью выражение генератора, получение первого совпадения или возврат Нет, если в s не отображается символ:

s = "Hello world!"

st = {"!"," "}
ind = next((i for i, ch  in enumerate(s) if ch in st),None)
print(ind)

Вы можете передать любое значение, которое вы хотите использовать в качестве возвращаемого значения по умолчанию, если нет совпадения.

Если вы хотите использовать функцию и поднять значение ValueError:

def first_index(s, characters):
    st = set(characters)
    ind = next((i for i, ch in enumerate(s) if ch in st), None)
    if ind is not None:
        return ind
    raise ValueError

Для небольших входов с использованием набора не будет много, если будет какая-либо разница, но для больших строк это будет более эффективно.

Некоторые тайминги:

В строке, последний символ набора символов:

In [40]: s = "Hello world!" * 100    
In [41]: string = s    
In [42]: %%timeit
st = {"x","y","!"}
next((i for i, ch in enumerate(s) if ch in st), None)
   ....: 
1000000 loops, best of 3: 1.71 µs per loop    
In [43]: %%timeit
specials = ['x', 'y', '!']
min(map(lambda x: (string.index(x) if (x in string) else len(string)), specials))
   ....: 
100000 loops, best of 3: 2.64 µs per loop

Не в строке, большой набор символов:

In [44]: %%timeit
st = {"u","v","w","x","y","z"}
next((i for i, ch in enumerate(s) if ch in st), None)
   ....: 
1000000 loops, best of 3: 1.49 µs per loop

In [45]: %%timeit
specials = ["u","v","w","x","y","z"]
min(map(lambda x: (string.index(x) if (x in string) else len(string)), specials))
   ....: 
100000 loops, best of 3: 5.48 µs per loop

В строке находится самый первый символ набора символов:

In [47]: %%timeit
specials = ['H', 'y', '!']
min(map(lambda x: (string.index(x) if (x in string) else len(string)), specials))
   ....: 
100000 loops, best of 3: 2.02 µs per loop

In [48]: %%timeit
st = {"H","y","!"}
next((i for i, ch in enumerate(s) if ch in st), None)
   ....: 
1000000 loops, best of 3: 903 ns per loop

Ответ 2

Используйте метод gen-exp и find.

>>> a = [' ', '!']
>>> s = "Hello World!"
>>> min(s.find(i) for i in a)
5

Чтобы удалить -1, если они произойдут, вы можете иметь фильтр в списке comp

>>> a = [' ', '!','$']
>>> s = "Hello World!"
>>> min(s.find(i) for i in a if i in s)
5

или вы можете заменить None

>>> min(s.find(i) if i in s else None for i in a)
5

Добавление результатов timeit

$ python -m timeit "a = [' ', '\!'];s = 'Hello World\!';min(s.find(i) for i in a if i in s)"
1000000 loops, best of 3: 0.902 usec per loop
$ python -m timeit "a = [' ', '\!'];s = 'Hello World\!';next((i for i, ch  in enumerate(s) if ch in a),None)"
1000000 loops, best of 3: 1.25 usec per loop
$ python -m timeit "a = [' ', '\!'];s = 'Hello World\!';min(map(lambda x: (s.index(x) if (x in s) else len(s)), a))"
1000000 loops, best of 3: 1.12 usec per loop

В примере вашего примера красивое решение Padraic немного медленное. Однако в больших тестовых случаях это определенно победитель. (Это немного удивительно, что альфасин "Не так оптимизирован" также здесь быстрее)

Добавлены сведения о реализации

>>> def take1(s,a):
...     min(s.find(i) for i in a if i in s)
... 
>>> import dis
>>> dis.dis(take1)
  2           0 LOAD_GLOBAL              0 (min)
              3 LOAD_CLOSURE             0 (s)
              6 BUILD_TUPLE              1
              9 LOAD_CONST               1 (<code object <genexpr> at 0x7fa622e961b0, file "<stdin>", line 2>)
             12 MAKE_CLOSURE             0
             15 LOAD_FAST                1 (a)
             18 GET_ITER            
             19 CALL_FUNCTION            1
             22 CALL_FUNCTION            1
             25 POP_TOP             
             26 LOAD_CONST               0 (None)
             29 RETURN_VALUE        
>>> def take2(s,a):
...     next((i for i, ch  in enumerate(s) if ch in a),None)
... 
>>> dis.dis(take2)
  2           0 LOAD_GLOBAL              0 (next)
              3 LOAD_CLOSURE             0 (a)
              6 BUILD_TUPLE              1
              9 LOAD_CONST               1 (<code object <genexpr> at 0x7fa622e96e30, file "<stdin>", line 2>)
             12 MAKE_CLOSURE             0
             15 LOAD_GLOBAL              1 (enumerate)
             18 LOAD_FAST                0 (s)
             21 CALL_FUNCTION            1
             24 GET_ITER            
             25 CALL_FUNCTION            1
             28 LOAD_CONST               0 (None)
             31 CALL_FUNCTION            2
             34 POP_TOP             
             35 LOAD_CONST               0 (None)
             38 RETURN_VALUE        
>>> def take3(s,a):
...     min(map(lambda x: (s.index(x) if (x in s) else len(s)), a))
... 
>>> dis.dis(take3)
  2           0 LOAD_GLOBAL              0 (min)
              3 LOAD_GLOBAL              1 (map)
              6 LOAD_CLOSURE             0 (s)
              9 BUILD_TUPLE              1
             12 LOAD_CONST               1 (<code object <lambda> at 0x7fa622e44eb0, file "<stdin>", line 2>)
             15 MAKE_CLOSURE             0
             18 LOAD_FAST                1 (a)
             21 CALL_FUNCTION            2
             24 CALL_FUNCTION            1
             27 POP_TOP             
             28 LOAD_CONST               0 (None)
             31 RETURN_VALUE

Как вы можете ясно видеть в случае Padraic, загрузка глобальных функций next и enumerate - это те, которые убивают время вместе с None в конце. В решении альфазина основным замедлением является функция lambda.

Ответ 3

Не так оптимизирован, как решение Padraic Cunningham, но еще один лайнер:

string = "Hello world!"
specials = [' ', '!', 'x']
min(map(lambda x: (string.index(x) if (x in string) else len(string)), specials))

Ответ 4

Я бы поддержал модуль re, поскольку он был встроен и уже протестирован. Он также оптимизирован для такого рода вещей.

>>> import re
>>> re.search(r'[ !]', 'Hello World!').start()
5

Вероятно, вы захотите проверить, что совпадение было найдено или исключить исключение, если это не так.

Есть причины не использовать re, но я бы хотел увидеть хороший комментарий, оправдывающий рациональность. Думать, что вы можете "сделать это лучше", как правило, не нужно, затрудняет чтение другими людьми кода и менее удобен для обслуживания.