Question

This is a style conventions question.

PEP8 convention for a class definition would be something like

class MyClass(object):
    def __init__(self, attri):
        self.attri = attri

So say I want to write a module-scoped function which takes some data, processes it, and then creates an instance of MyClass.

PEP8 says that my function definitions should have lowercase_underscore style names, like

def get_my_class(arg1, arg2, arg3):
    pass

But my inclination would be to make it clear that I’m talking about MyClass instances like so

def get_MyClass(arg1, arg2, arg3):
    pass

For this case, it looks trivially obvious that my_class and MyClass are related, but there are some cases where it’s not so obvious. For example, I’m pulling data from a spreadsheet and have a SpreadsheetColumn class that takes the form of a heading attribute and a data list attribute. Yet, if you didn’t know I was talking about an instance of the SpreadsheetColumn class, you might think that I’m talking about a raw column of cells as they might appear in an Excel sheet.

I’m wondering if it’s reasonable to violate PEP8 to use get_MyClass. Being new to Python, I don’t want to create a habit for a bad naming convention.

I’ve searched PEP8 and Stack Overflow and didn’t see anything that addressed the issue.

Answer 1

Depending on the usage of the function, it might be more appropriate to turn it into a classmethod or staticmethod. Then it’s association with the class is clear, but you don’t violate any naming conventions.

e.g.:

class MyClass(object):
     def __init__(self,arg):
         self.arg = arg

     @classmethod
     def from_sum(cls,*args):
         return cls(sum(args))

inst = MyClass.from_sum(1,2,3,4)
print inst.arg  #10