Python - Object writing data that is unreadable

Question

Python is the first langauge I'm learning and currently I'm studying file input/output systems for storing simple data. I've briefly done an exercise regarding simple writing and pickling. For my purposes, I would like to use simple writing, as I would like to edit my "save files".

I have been successful in storing and retrieving data when the data is a STRING. The problem is when I store my object, it stores it as this unreadable format:

<__main__.Character object at 0x0078FE10>

How can I turn this unreadable format above back in to my object? Does Python have a built-in function that allows this?

Or will I have to convert my object to a string, containing all important variables BEFORE writing in to my data file?

Edit: Oops, forgot the code!

class Character(object):
    def __init__(self,name,exp,atk):
        self.name = name
        self.exp = exp
        self.lvl = int(self.exp/100)
        self.health = 10
        self.atk = atk
        if atk == None:
            self.atk = lvl*1.5

    def stats(self):
        print(self.name, end=" is level ")
        print(self.lvl)
        print("with", self.health, "health")

And here's the reading part of the I/O system. You can see it reads the data > converts the string to a list > splits arguments in list > use arguments for object creation.

with open('charData', 'r') as data:
    data = data.read()  # Read the contents of the file into memory.
    print (data)

    my_list = data.splitlines()
    print (my_list[0])  # Print the list.
    char_data = ast.literal_eval(my_list[0])

new_character = Character(*char_data)

Then I have my own function to display object stats:

new_character.stats()

spits out

Harley is level 3
with 10 health

so as you can see, it works fine. but if I use "newFile.write(new_character)" which is essentially the string of the object, which is "<main.Character object at 0x0215FE10>" from above.

I've been messing with str in the object for the past hour, but haven't found a way to use that function to find a solution and looking for guidance from a more experienced person.

Edit for Matt Habel:

def __str__(self):
    print ("[\"", end="")
    print (self.name, end="")
    print ("\"", end=", ")
    print (self.exp, end="")
    print (",", end=" ")
    print (self.atk, end="")
    print ("]")

This outputs this:

["Harley", 300, 3]
    print(new_character)
TypeError: __str__ returned non-string (type NoneType)

My reasoning for making my own "list" is so I can use the "AST" module to define the list arguments. I would later convert the list above to "new_character2", and write it using this:

newFile = open("charData","w")
newFile.write(new_character2)

Now I use:

Instead of that complicated parsing from above, I'm using the return function.

    def export(self):
        self.name = str(self.name)
        self.exp = str(self.exp)
        self.atk = str(self.atk)
        matt_data = "[\"%s\", %s, %s]" % (self.name, self.exp, self.atk)
        return matt_data

matt_export = new_character.export()
print(matt_export)

spits out:

["Harley", 600, 3]

and get no error code!

Answer 1

That format is the default string representation that python gives to objects. You can check this by calling str(object) on an instance of one of your classes. If you want a readable string of your object, you can provide a custom __str__(self) method on your class. This will change your objects string representation that is output to your file.

As to your actual question about turning the default representation back into one of your objects: it's impossible. That's because all that the default representation tells you is the name of the object and the memory location where it is currently stored. Because memory is transient (it isn't available to your program across different times you run it), you can't take that memory address and turn it back into one of your objects.

If you want to do this, there are a few ways to go about it:

1. You could provide a human readable __str__ method. This will output data that you can read and hopefully make it easy to parse back into an object. You'll have to do that by reading the object's string representation from the file, extracting the data necessary to create a new object, and then creating the object.
2. You can look into serialization methods. This will output the object in a form that is easy for the computer to read and write, but you'll probably be unable to read it. There are lots of serialization libraries, but python provides the pickle library to do this out of the box.
3. You can look into some human readable data formats like json, yaml, etc. Using one of these will provide you with both a human readable file and some great libraries for working with those files.

Answer 2

To save the object you must serialize it. Depending on whether you're in Python 2.7.x or 3.x, you have different specific options, but here is the version of pickle docs that will help for 2.7.x.