>>> ['a', 'b'].index('b')
1

If the list is already sorted, you can of course do better than linear search.

This is because str.index(ch) will return the index where ch occurs the first time. Try:

def find(s, ch):
    return [i for i, ltr in enumerate(s) if ltr == ch]

This will return a list of all indexes you need.

P.S. Hugh's answer shows a generator function (it makes a difference if the list of indexes can get large). This function can also be adjusted by changing [] to ().

Using enumerate is the standard way to go. Although, you can take advantage of the speed of str.find for time-critical operations.

Code

def find_all(s, c):
    idx = s.find(c)
    while idx != -1:
        yield idx
        idx = s.find(c, idx + 1)

print(*find_all('Apples are totally awesome', 'o')) # 12 23

I made the above return a generator for elegance and to account for very large strings. Put it can of course be casted to a list if need be.

Benchmark

Here is a benchmark against a solution using enumerate and a list-comprehension. Both solutions have linear time-complexity, but str.find is significantly faster.

import timeit

def find_all_enumerate(s, c):
    return [i for i, x in enumerate(s) if c == x]

print(
    'find_all:',
    timeit.timeit("list(find_all('Apples are totally awesome', 'o'))",
                  setup="from __main__ import find_all")
)

print(
    'find_all_enumerate:',
    timeit.timeit("find_all_enumerate('Apples are totally awesome', 'o')",
                  setup="from __main__ import find_all_enumerate")
)

Output

find_all: 1.1554179692960915
find_all_enumerate: 1.9171753468076869

The function:

def findOccurrences(s, ch):
    return [i for i, letter in enumerate(s) if letter == ch]


findOccurrences(yourString, '|')

will return a list of the indices of yourString in which the | occur.