They are not the same; using difflib.ndiff() shows how these two values differ very clearly:

>>> import difflib
>>> print '\n'.join(difflib.ndiff([x1], [x2]))
- N C Soft - NCSOFT_Guild Wars 2 December 2013 :: BNLX_AD_Parallax_160x600
?                                                      ^^             ^

+ N C Soft - NCSOFT_Guild Wars 2 December 2013 :: BNLX_CT_Parallax_160X600
?                                                      ^^             ^

In general, when in doubt use repr() to look at the representation. Python 2 will use escapes for any non-printable or non-ASCII character in the string, any 'funny' characters will stand out like a sore thumb. In Python 3, use the ascii() function for the same result as repr() there is less conservative and Unicode is rife with character combinations that look the same at first glance.

For strings where you still cannot see what changes between the two, the above difflib tool can also help point out what exactly changed.

The last element includes a newline. Let's take this input file as an example:

$ cat file.txt
Sweden-Sweden

Now, let's read it in:

>>> a, b = open('file.txt').readline().split('-')
>>> a,b
('Sweden', 'Sweden\n')
>>> a == b
False

The solution is to strip the newline:

>>> a, b = open('file.txt').readline().rstrip('\n').split('-')
>>> a == b
True

Just taking a stab here, but based on your output it looks like there might be a trailing '\n' in your stored password list thus the blank line in the output after

print "stored", self.users[user]

You could try

print "equal", self.users[user].strip() == sha1_encode(password)

to see if that takes care of your problem. The call will remove trailing characters.

is is identity testing, and == is equality testing. What happens in your code would be emulated in the interpreter like this:

>>> a = 'pub'
>>> b = ''.join(['p', 'u', 'b'])
>>> a == b
True
>>> a is b
False

So, no wonder they're not the same, right?

In other words: a is b is the equivalent of id(a) == id(b)

It turns out that two of the characters in the key in question had "unusual" ASCII values. When I have a string 'c', python assumes I'm referring to the character with ASCII value of 99, whereas the 'c' character in the data structure created by mutagen used ASCII value 169.

I had simply to determine the ASCII values of the individual characters of the string with ord and use them to build the correct string for the key 'cnam' using chr.

>>> the_key == 'cnam'
False
>>> ord(the_key[0])
169
>>> ord(the_key[3])
109
>>> new_key = chr(169)+'na'+chr(109)
>>> new_key
'cnam'
>>> new_key == the_key
True

I did not have to check the ASCII values of the characters 'n' and 'a' because it was shown in the question that the "default" ASCII values for 'n' and 'a' already matched those of the string in question.

It's likely that extra spacing is your culprit. You may also try downcasing the string.

SentenceIMLookingfor='blha blha blah'
with open('textfile.lua','r') as my_file:
    for line in my_file:
        if line.lower().strip() == SentenceIMLookingfor:
            #DO_SOMETHING

If, however, you are not checking for a line that is exactly equal to the Sentence you're looking for, you'll want to use the in operator to check for equality, so replace the if above with

        if SentenceIMLookingfor in line.lower(): # you may not want .lower()

Since there is no need to read the entire file into memory, you can iterate over the lines of the file with for line in my_file. .lower() converts a string to all lower-case letters, .strip() cuts off any preceding or trailing whitespace

As suggested by @SethMMorton in the comments, you can use enumerate to iterate with the line numbers for i, line in enumerate(my_file)

If you are trying to collect the line numbers that this string appears on (which seems likely) you can accomplish that with a list comprehension

with open('textfile.lua','r') as my_file:
    line_nos = [i for i, line in enumerate(my_file) if line.lower().strip() == SentenceIMLookingfor]

You have whitespaces at the end of each line, so they end up in pwd. Get rid of them using:

pwd.strip()

Note that it might not work well if it's possible any password contains leading or trailing whitespaces, but you shouldn't have plain text passwords anyways, right?

There may be a chance of getting spaces around the letters. So it's better to do stripping the space characters before checking the condition.

if x.strip() == 'PLANT':

Copy paste the ệ of the first "liệu" in the second "liệu" or vice versa. That should make sure both are the exact replicas of each other. That should definitely give you this output:

b'li\xe1\xbb\x87u'
b'li\xe1\xbb\x87u'
True

Hope this helps!

.readlines() includes the newline character at the end of every line in the text file. This is most likely the cause of your problem. You can remove the newline character (and any whitespace characters from the left and right of the string) by using .strip().

gg = lines[x].lower().strip()

Reference

• https://www.tutorialspoint.com/python/file_readlines.htm

When you print 'L-Air1993\n' it will look like it has just the name. The newline just adds a newline at the end but it's hard to see if nothing comes after it.

To remove all the new lines from your list, try this:

sellers_no_newlines = [x.strip() for x in sellers]

And then compare the online sellers list to sellers_no_newlines. Hopefully that solves your problem.

You are comparing ccn to the password - not the password arg with the user's stored password...

if ccn == self.data[ccn]['Password']:

should be

if password == self.data[ccn]['Password']:

Hard to say without seeing the actual strings. When you read from a file, be sure to strip the line you're comparing to get rid of potential \ns at the end:

with open("input.txt") as f:
  for line in f:
    print line == "asd"
    print line.strip() == "asd"

prints

False
True

for input.txt:

asd

is will only yield True for strings that are the same object, i.e. strings known for certain are initialized to the same value before runtime.