File editing class

Question

I was making this file editing class (writing to a file, reading a file etc.) in Python and was just looking for any feedback.

Note: I've been thinking about removing the file_name property and requiring file name on each method call.

import os
class EditFile:
 """
 format: <object_name> = EditFile(<file_name>)
 """
 # constructor
 def __init__(self, file_name):
 self.file_name = file_name # can be changed at any time
 # string version
 def __repr__(self):
 return "<object_name> = EditFile(<file_name>)"
 # methods
 def write(self, text): # writes text in a file
 try:
 f = open(self.file_name, "w") # opens file & selects WRITE mode also creates a new file if it doesnt exist
 f.write(str(text))
 finally:
 f.close()
 def append(self, text): # appends text to a file
 try:
 f = open(self.file_name, "a") # opens file & selects APPEND mode
 f.write(text)
 finally:
 f.close()
 @property
 def read(self): # reads the file
 try:
 f = open(self.file_name, "r") # opens file & selects READ mode
 content = f.read() # saves content of the file into content variable
 finally:
 f.close()
 return content # returns content of the file
 def read_bytes(self, number_of_bytes = 0): # reads certain amount of bytes
 try:
 int(number_of_bytes)
 if number_of_bytes == 0: # checks if its default
 f = open(self.file_name, "rb")
 content = f.read()
 return content
 elif number_of_bytes >= 1: # checks if number of bytes is a valid number
 f = open(self.file_name, "rb")
 content = f.read(number_of_bytes)
 return content
 else:
 return "error" # returns "error" if input is invalid
 except ValueError:
 return "value error"
 finally:
 f.close()
 def write_bytes(self, text): # writes in bytes
 try:
 f = open(self.file_name, "wb") # selects WRITE BYTES mode
 f.write(str(text))
 finally:
 f.close()
 @property
 def clear(self): # clears a file
 try:
 f = open(self.file_name, "w") # opens file and selects WRITE mode
 f.write("") # sets file content to none
 finally:
 f.close()
 @property
 def delete(self): # deletes current file
 try:
 os.remove(self.file_name) # tries to delete file
 except OSError:
 return "error" # returns "error" if an error occurs (eg file doesnt exist)
# example program using most of the methods
file = EditFile("editme.txt")
file.write(str(input("Text:\n")))
print(file.read)
file.clear
file.delete
# editing file: editme2.txt
file.file_name = "editme2.txt"
file.write(str(input("Text:\n")))
print(file.read_bytes(5))
file.delete

Answer 1

"<object_name> = EditFile(<file_name>)"

is not a particularly useful __repr__. Note the guidance in the data model documentation:

If at all possible, this should look like a valid Python expression that could be used to recreate an object with the same value (given an appropriate environment). If this is not possible, a string of the form <...some useful description...> should be returned.

In this case, that could be:

"EditFile({!r})".format(self.file_name)

---

For all of your file access, you should use the context manager provided by open, e.g.:

@property
def read(self): # reads the file
 with open(self.file_name) as f:
 return f.read()

This will handle closing the file for you after the method ends.

---

It seems weird that read is a property but read_bytes is a method - as the latter requires an argument, and both names describe actions, perhaps they should both be methods? If you still wanted the property then a name describing a thing, like content, would be better for it.

---

I would generally expect attribute access not to change state, so it seems even weirder for clear and delete, again actions rather than things, to be properties. Just make them methods. Also the fact that they return either None (if successful) or a string (if there was an error) is a really strange interface for a consumer of the class to deal with.

---

Your error handling in general is a bit odd. Why take a useful exception and squash it down to a meaningless string? You're giving the users of your class less information. If you can't add to them or usefully handle them, let the errors continue through your code to the caller. And rather than:

return "error" # returns "error" if input is invalid

raise an error with a useful message yourself, in this case e.g.:

raise ValueError("cannot read a negative number of bytes")

This actually tells the user something useful.

Also note that:

int(number_of_bytes)

although it checks that number_of_bytes could be made an integer, doesn't actually change what's assigned to the name; if it was '1', for example, weird things will happen next. Instead, use the result:

number_of_bytes = int(number_of_bytes)

---

Rather than using simple comments to describe your methods, use docstrings:

def write_bytes(self, text):
 """Writes in bytes."""
 ...

Unlike comments these can be used by other tools, e.g. the built-in help function, to make that information available in other forms.

---

self.file_name = file_name # can be changed at any time

Here is a good use for a @property; you could use it to make the filename read-only by convention:

self._file_name = file_name

The leading underscore indicates that this should be considered private, then you can write a getter:

@property
def file_name(self):
 return self.file_name

Your other idea, requiring the filename every time a method is called, would turn this into a class without any instance state, in which case it probably shouldn't be a class at all.