Change two characters into one symbol (Python)

Question

Im currently working on a file compression task for school, and I find myself unable to understand what's happening in this code (more specifically what ISN'T happening and why it is not happening).

So in this section of the code what I'm aiming to do is, in non-coding terms, change two adjacent letters which are the same into one symbol, therefore taking up less memory:

          for i, word in enumerate(file_contents): 
           #file_contents = LIST of words in any given text file       

                word_contents = (file_contents[i]).split()
                for ind,letter in enumerate(word_contents[:-1]):
                    if word_contents[ind] == word_contents[ind+1]:
                         word_contents[ind] = ''
                         word_contents[ind+1] = '★'

However, when I run the full code with a sample text file, it seemingly doesn't do what I told it to do. For instance, the word 'Sally' should be 'Sa★y' but instead stays the same. Could anyone help me get on the right track?

EDIT: I missed out a pretty key detail. I want the compressed string to somehow appear back in the original file_contents list where there are double letters, as the purpose of the full compression algorithm is to return a compressed version of the text in an inputted file.

Answer 1

There are a few things wrong with your code (I think).

1) split produces a list not a str, so when you say this enumerate(word_contents[:-1]) It looks like you're assuming that gets you a string?!? at any rate... I'm not sure it is or not.

but then!

2)with this line:

if word_contents[ind] == word_contents[ind+1]:
                   word_contents[ind] = ''
                   word_contents[ind+1] = '★'

You're operating on your list again. Where it looks pretty clear that you want to be operating on the string, or a list of characters in a word you're processing. At best this function will do nothing, and at worst, you're corrupting the word content list.

So when you perform your modifications you are modifying the word_contents list and not the list item [:-1] you are actually looking over. There are more issues, but I think that answers your question (I hope)

If you really want to understand what you're doing wrong I recommend putting in print statements along what you're doing. If you're looking for someone to do your homework for you, there is another which already gave you an answer I guess.

Here is an example of how you should add logging to the function

  for i, word in enumerate(file_contents): 
   #file_contents = LIST of words in any given text file       

        word_contents = (file_contents[i]).split()
        # See what the word content list actually is
        print(word_contents)
        # See what your slice is actually returning
        print(word_contents[:-1])
        # Unless you have something modifying your list elsewhere you probably want to iterate over the words list generally and not just the slice of it as well.
        for ind,letter in enumerate(word_contents[:-1]):
            # See what your other test is testing
            print(word_contents[ind], word_contents[ind+1])
            # Here you probably actually want
            # word_contents[:-1][ind]
            # which is the list item you iterate over and then the actual string I suspect you get back
            if word_contents[ind] == word_contents[ind+1]:
                 word_contents[ind] = ''
                 word_contents[ind+1] = '★'

UPDATE: based on the follow up questions from the OP I've made a sample program annotated with descriptions. Note this isn't an optimal solution, but mainly an exercise in teaching flow control and using basic structures.

# define the initial data...
file = "sally was a quick brown fox and jumped over the lazy dog which we'll call billy"
file_contents = file.split()

# Enumerate isn't needed in your example unless you intend to use the index later (example below)
for list_index, word in enumerate(file_contents):

# changing something you iterate over is dangerous and sometimes confusing like in your case you iterated over 
# word contents and then modified it.  if you have to take
# two characters you change the index and size of the structure making changes potentially invalid. So we'll create a new data structure to dump the results in
    compressed_word = []

    # since we have a list of strings we'll just iterate over each string (or word) individually
    for character in word:
        # Check to see if there is any data in the intermediate structure yet if not there are no duplicate chars yet
        if compressed_word:
            # if there are chars in new structure, test to see if we hit same character twice 
            if character == compressed_word[-1]:
                # looks like we did, replace it with your star
                compressed_word[-1] = "*"
                # continue skips the rest of this iteration the loop
                continue
        # if we haven't seen the character before or it is the first character just add it to the list
        compressed_word.append(character)

    # I guess this is one reason why you may want enumerate, to update the list with the new item?
    # join() is just converting the list back to a string
    file_contents[list_index] = "".join(compressed_word)

# prints the new version of the original "file" string
print(" ".join(file_contents))

outputs: "sa*y was a quick brown fox and jumped over the lazy dog which we'* ca* bi*y"

Answer 2

I would suggest use a regex matching same adjacent characters.

Example:

import re

txt = 'sally and bobby'
print(re.sub(r"(.)\1", '*', txt))

# sa*y and bo*y

Loop and condition checking in your code are not required. Use below line instead:

word_contents = re.sub(r"(.)\1", '*', word_contents)