As it turns out, your string has new-lines (\n\n) at the end.

You can use

text = text.strip()

to remove any surrounding whitespace from your string.

For future cases, to check if your string has the content you think it has:

print(repr(text))

You are testing for object identity:

UserArray[i] is userinput:

you really want to use equality instead:

UserArray[i] == userinput:

is tests if two object references are pointing to the same object. == tests if the values of two objects is equivalent.

Two strings that have the same contents (are equal), are not necessarily one and the same object:

>>> spam = 'foo bar baz'
>>> ham = 'foo bar baz'
>>> spam is ham
False
>>> spam == ham
True
>>> eggs = ham
>>> eggs is ham
True

CPython does use some tricks to save memory and improve performance, where small integers and some strings are interned; every time you try to create a new string or integer that is interned, instead of a new object, you get an already cached value. In those cases is tests return True only because you indeed have the same object, reused for you by the interpreter.

Note that the equality test can still be incorrect. There could be extra whitespace around the values, or other characters that are not immediately obvious when printed to the screen:

>>> val1 = 'frogeyedpeas'
>>> val2 = 'frogeyedpeas\t'
>>> val1 == val2
False
>>> print val1, val2
frogeyedpeas frogeyedpeas
>>> print repr(val1), repr(val2)
'frogeyedpeas' 'frogeyedpeas\t'

Because 12.04 is a float and not a string, add quotes to it, like so:

print ReleaseNum == '12.04'

Since ReleaseNum is a string, when you compare it with 12.04 it returns false, because they're of different types, so when you convert 12.04 to a string by putting quotes, it works...

I suspect line ends with a newline character, and it remains there throughout all of your replace operations. Then your comparison fails because "ExecutionOptimizer\n" doesn't equal "ExecutionOptimizer". You can discard the newline using strip:

line_no_spaces = line.strip().replace(" ","")

It would help even more if you would have provided an actual example.

In any way, your problem is the different string encoding in Python 2. entry.title is apparently a unicode string (denoted by a u before the quotes), while line is a normal str (or vice-versa).

For all characters that are equally represented in both formats (ASCII characters and probably a few more), the equality comparison will be successful. For other characters it won’t:

>>> 'Ä' == u'Ä'
False

When doing the comparison in the reversed order, IDLE actually gives a warning here:

>>> u'Ä' == 'Ä'
Warning (from warnings module):
  File "__main__", line 1
UnicodeWarning: Unicode equal comparison failed to convert both arguments to Unicode - interpreting them as being unequal
False

You can get a unicode string from a normal string by using str.decode and supplying the original encoding. For example latin1 in my IDLE:

>>> 'Ä'.decode('latin1')
u'\xc4'
>>> 'Ä'.decode('latin1') == u'Ä'
True

If you know it’s utf-8, you could also specify that. For example the following file saved with utf-8 will also print True:

# -*- coding: utf-8 -*-
print('Ä'.decode('utf-8') == u'Ä')

You seem to have a string processing error. PlayerId seems to be a C-String being stored in a unicode String.

Background: C uses a nullbyte (\x00) to mark the end of a string. Since this nullbyte is in your string it ends up in the string representation of the object.

You can take a look here, for some reference. But without more code I am not sure about the cause/fix.

Have you tried type(playerId)?

edit: I don't know what python implementation you are using, for cpython look here

Unfortunately I am not to firm in interfacing c and python, however you could try to use PyString_FromString to convert it on the c side to a python string or use some handcrafted function (eg split with regex at the first unescaped 0).

Some interfacing libs are listed in this awnser

Your gfirmware and ghardware objects are large character buffers. When you convert them to strings with str(gfirmware,'utf-8') you get large strings:

>>> len(str(gfirmware, 'utf-8'))
100

because you still have all the padding.

You can use the value property on the buffers before converting to a string:

>> firmware = str(gfirmware.value,'utf-8')
>> hardware = str(ghardware.value,'utf-8')
>> firmware != "firmware", hardware != "hardware"
(False, False)

Do not type " when inputting:

>>> Insert a string "mango"
>>> "mango"
>>> False

>>> Insert a string mango
>>> mango
>>> True