Strings in Python are immutable (meaning that their data cannot be modified) so the replace method doesn't modify the string - it returns a new string. You could fix your code as follows:

for i in hello:
    j = i.replace(' ','')
    k.append(j)

However a better way to achieve your aim is to use a list comprehension. For example the following code removes leading and trailing spaces from every string in the list using strip:

hello = [x.strip(' ') for x in hello]

You could use a list comprehension:

 new_list = [elem for elem in mylist if elem.strip()]

Using strip() guarantees that even strings containing only multiple spaces will be removed.

I think you are conflating the list and the representation of the list. The list itself doesn't have spaces, or even commas, it just has the items (in your case, the numbers). The representation of the list is just that - a way to represent the data inside of it in a normal, standard way. That standard includes commas and spaces.

If you want a new thing that represents the list and its items in the way you are saying, you can do that by making a new string just like that.

str(numbers).replace(' ','')

This has two functions in it, chained together. First, we do str(numbers) to get a string that is the string-representation of the list. This will be the string '[1, 2, 3, 4, 5]'. Then you replace any blank space-bar ' ' with nothing ''.

Edit:

I think I read your question too quickly and see that you did the exact same as what I have in my code here and said it isn't doing exactly what you want to do. I think the answer here is: no.

As I say in my first paragraph, there is the list and there is the lists representation. The function for the list's representation is a python built-in that can not be trivially overridden. I'm not saying it can't be done, but I don't think you'll get it done without defining some new things.

In your for loop, change f to f.replace(' ',''). That will remove spaces.

This code should work:

val = []

for c in f.replace(' ',''):

    val.append(ord(c))

val = [w - 5 if w > 20 else w for w in val]

The strip() method will strip all the characters from the end of the string. In your case, strip starts at the end of your string, encounters a '\n' character, and exits.

It seems a little unclear what you are trying to do, but I will assume that you are looking to clear out any white space between the last non-whitespace character of your string and the newline. Correct me if I'm wrong.

There are many ways to do this, and this may not be the best, but here is what I came up with:

m = ['This, is a string. \n', 'another string!    \n', 'final example\n    ']

m = map(lambda(x): x.rstrip() + '\n' if x[-1] == '\n' else x.rstrip(' '), m)

print(m)

['This, is a string.\n', 'another string!\n', 'final example\n']

Here I use the built in map function iterate over each list element and remove all white space from the end (rstrip() instead of strip() which does both the start and end) of the string, and add in a new line if there was one present in the original string.

Some suggestions

1. Follow pep8
2. Use duck-typing. So, for example, use elt.strip() if hasattr(elt, 'strip')
3. It will be much more efficient to filter items in another list comprehension, since it only requires one search through the list rather than many.
4. The simplest approach would probably be to change the first list comprehension to a generator expression, then feed that to a list comprehension that filters out empty strings.
5. This could conceivably be a single list comprehension, but I think it would be too verbose. Further, it would require stripping twice.

So I would do something like this:

def strip_list_noempty(mylist):
    newlist = (item.strip() if hasattr(item, 'strip') else item for item in mylist)
    return [item for item in newlist if item != '']

You could also duck-type the filtering, like so:

def strip_list_noempty(mylist):
    newlist = (item.strip() if hasattr(item, 'strip') else item for item in mylist)
    return [item for item in newlist if item or not hasattr(item, 'strip')]

Your output is fine. You have the correct list. The required output only appears without spaces because whoever typed it was too lazy to hit the spacebar (I'm guilty of that from time to time, as well). You could get that output with str(result).replace(' ', ''), but, again, it is not necessary. The Python interpreter's default representation of a list object simply includes spaces for readability.

Nothing is wrong.

You could use a list comprehension here with rstrip():

items = [' apple ', 'banana ', 'orange ']
output = [x.rstrip() for x in items]
print(output)  # [' apple', 'banana', 'orange']