Using regular expressions, you can use re.finditer to find all (non-overlapping) occurences:

>>> import re
>>> text = 'Allowed Hello Hollow'
>>> for m in re.finditer('ll', text):
         print('ll found', m.start(), m.end())

ll found 1 3
ll found 10 12
ll found 16 18

Alternatively, if you don't want the overhead of regular expressions, you can also repeatedly use str.find to get the next index:

>>> text = 'Allowed Hello Hollow'
>>> index = 0
>>> while index < len(text):
        index = text.find('ll', index)
        if index == -1:
            break
        print('ll found at', index)
        index += 2 # +2 because len('ll') == 2

ll found at  1
ll found at  10
ll found at  16

This also works for lists and other sequences.

I must say your code is a bit clunky and hard to understand.

But if you want to apply the same operation to a list of indices, then just iterate over your list of indices and apply the same logic:

pos_list = [i for i in range(len(string)) if string[i] == userinput]
for pos in pos_list:
    word = word[:pos] + 'X' + word[pos + 1:]

You want enumerate to handle repeating characters, you can also use a list comprehension:

def capitals(word):
    return [i for i, ch in enumerate(word) if ch.isupper()]

ch is each character in the word, i is the index of the char.

On another note, if you want to add a single item to a list you should append not +=, if you have multiple elements to add it makes sense to +=/extend but for a single element just append :

def capitals(word):
    print word
    lst = []
    for i,ch in enumerate(word):
        if ch.isupper():
            lst.append(i)
    return lst

You can try join(), I hope this is the solution you are looking for

myArray = ["this ","is ","a ","test.","this ","is ","another ","test."]
print(' '.join(myArray[:4]))
print(' '.join(myArray[4:]))

Create a new str to avoid change the main_str:

main_str = 'Lorem Ipsum is simply dummy text of the printing and typesetting industry.'
indexes_list = [
    {
      "type": "first_type",
      "startOffset": 0,
      "endOffset": 5,
    },
    {
      "type": "second_type",
      "startOffset": 16,
      "endOffset": 22,
    }
]

new_str = ""
index = 0
for i in indexes_list:
    start = i["startOffset"]
    end = i["endOffset"]
    new_str += main_str[index: start] + "<span>" + main_str[start:end] + "</span>"
    index = end
new_str += main_str[index:]
print(new_str)

index returns exactly one index per call. It's not going to try to shove all indices into the result, changing return type based on the values.

Two obvious ways to handle it:

1. A listcomp with enumerate:

   allindices = [i for i, x in enumerate(a) if x == 'o']
   

2. A loop that calls index with an explicit start argument:

   idx = -1  # -1 means first search will begin at beginning of string
   try:
       while True:
           idx = a.index('o', idx + 1)  # Resume search after last index found
           print(idx)
   except ValueError:
       pass  # Ran out of 'o's, we're done
   

The listcomp solution is by far the most common and obvious solution (and can be made to work for length > 1 substrings by using start modified calls to str.startswith), but if you must use index to do it, option #2 exists.

s = 'long string that I want to split up'
indices = [0,5,12,17]
parts = [s[i:j] for i,j in zip(indices, indices[1:]+[None])]

returns

['long ', 'string ', 'that ', 'I want to split up']

which you can print using:

print '\n'.join(parts)

Another possibility (without copying indices) would be:

s = 'long string that I want to split up'
indices = [0,5,12,17]
indices.append(None)
parts = [s[indices[i]:indices[i+1]] for i in xrange(len(indices)-1)]

It seems that you're trying to find occurrences of a word inside a string: the re library has a function called finditer that is ideal for this purpose. We can use this along with a list comprehension to make a list of the indexes of a word:

>>> import re
>>> word = "foo"
>>> string = "Bar foo lorem foo ipsum"
>>> [x.start() for x in re.finditer(word, string)]
[4, 14]

This function will find matches even if the word is inside another, like this:

>>> [x.start() for x in re.finditer("foo", "Lorem ipsum foobar")]
[12]

If you don't want this, encase your word inside a regular expression like this:

[x.start() for x in re.finditer("\s+" + word + "\s+", string)]

I would turn this function into a generator so that an iteration over its values does not unnecessarily build a list into memory. If the caller trully needs a list, they can still call list(find_substring(...)). I would also rename this function substring_indexes as I feel it better convey what this function is about; also index could be something like last_known_position or last_found. But naming is hard and I might be wrong on this one.

def substring_indexes(substring, string):
    """ 
    Generate indices of where substring begins in string

    >>> list(find_substring('me', "The cat says meow, meow"))
    [13, 19]
    """
    last_found = -1  # Begin at -1 so the next position to search from is 0
    while True:
        # Find next index of substring, by starting after its last known position
        last_found = string.find(substring, last_found + 1)
        if last_found == -1:  
            break  # All occurrences have been found
        yield last_found

You could potentially use ‘compress()’ from Itertools to create a binary filter.

Compress takes two arguments

1. The iterable that you want to go over and ‘punch’ out characters

2. The data which defines which elements from the first iterable are removed. Any ‘True’ element will enable compress to remove the element from the first iterable