Return to Answer

Another not so good example would be...

show_it = lambda i: ' '.join('_' for _ in range(0, i))

... which'll output _ _ _ _ _ via show_it(5), but unless you're changing changing i constantly it's far better to assign a variable that calculates things once...

show_it = ' '.join('_' for _ in range(0, 5))

... Reasons that remove_spaces should be a function and not show_it is wonderfully obvious in this case, in the future figuring out how things should be assigned can be a little murky.

Even more updates

So I spent a little more time examining your code and other things popped out...

## ...
            if guess == 'help':
                if hints == 0:
                    print('Sorry, you don\'t have anymore hints')
                    continue
                else:
                    guess = random.choice(itWord) 
                    while guess in newIt:
                        guess = random.choice(itWord)
## ...

... doesn't need an else, because when the if statement trips continue things move on to the next iteration. Following is a more correct way of expressing your intentions with a computer...

## ...
            if guess == 'help':
                if hints == 0:
                    print("Sorry, you don't have anymore hints")
                    continue

                guess = random.choice(itWord) 
                while guess in newIt:
                    guess = random.choice(itWord)
## ...

... with a little editing other places that the code is using continue like this, the amount of tabbing in that's required (AKA cyclomatic complexity) could be significantly reduced.

remove_spaces = lambda word: word.replace(' ', '')


def show_it(word): 
    """
    The function creates dashes format like _ _ _
    """
    newIt = ' '.join('_' for _ in word)
    return newIt.rstrip(' ')
```

remove_spaces = lambda word: word.replace(' ', '')


def show_it(word): 
    """
    The function creates dashes format like _ _ _
    """
    newIt = ' '.join('_' for _ in word)
    return newIt.rstrip(' ')

I don't understand what lambda does. Can you explain me ?

I can try to explain lambda, when programming their a handy way of writing one-line functions. Borrowing a few examples from a past iteration...

edge_cost = lambda base_cost, drivers: base_cost * drivers

edge_cost(base_cost = 0.7, drivers = 2)
## -> 1.4

• lambda base_cost, drivers declares arguments names that maybe used on the other side of the : (colon)

• what ever is done on the other side of the colon (:) should return something as part of the operations, in this case base_cost * drivers

• and the edge_cost = ... is defining the name that this operation can be called up with

I'll encourage you to try'em out in an active terminal session...

user@host ~ $ python

>>> remove_spaces = lambda word: word.replace(' ', '')
>>> remove_spaces(word = 'lamb spam and ham')
'lambspamandham'

>>> Enter

>>> first_class = lambda base_cost: base_cost + 0.5
>>> business_class = lambda base_cost: base_cost + 0.2
>>> first_class(0.4)
0.9
>>> business_class(0.4)
0.6

One thing to keep in mind when using'em is that their intended to be functional in the programming since, so please do not ever do...

bad_idea = lambda d: [d.update({k: v * 2}) for k, v in d.items()]

some_data = {'first': 1, 'second': 2, 'third': 3}
worse_idea = bad_idea(some_data)

... because worse_idea will then equal [None, None, None], nearly useless output, and some_data will have mutated into something like {'second': 4, 'third': 6, 'first': 2}. This type of usage of lambda will only lead to loss of time (if not hair) during the eventual debugging process.

Other than that though their supper useful for simple things that get reused elsewhere, as well as for prototyping because it's less key-strokes to some kind of result... Oh and ya may run across lambda being used in Math (if I remember correctly this is where such ideas originated), and in most cases they'll operate very much the same, however, they're not equivalent so that can sometimes cause troubles when translating from one to the other.

Updates

Some other bits that sorta stood out to me...

# ... Things such as
elif guess != 'help' and guess != 'exit' and guess != 'guess' and guess != 'list':

# ... look _neater_ with
elif guess not in ['help', 'exit', 'guess', 'list']:

And things like...

def show_it(word1): 
    # The function creates dashes format like _ _ _
    newIt = ''
    for x in word1:
        newIt = newIt + x + ' '
    newIt = newIt.rstrip(' ')
    return newIt

def remove_spaces(word):
    string = ''
    for x in word:
        if x != ' ':
            string += x
    return string

... should be assigned prior to being used, and they may be written in a more shorthand way via...

remove_spaces = lambda word: word.replace(' ', '')


def show_it(word): 
    """
    The function creates dashes format like _ _ _
    """
    newIt = ' '.join('_' for _ in word)
    return newIt.rstrip(' ')
```