到目前为止缺乏答案只是促使我简单地写下我这样做的方式：

class thing(object):
        
    info = 'someinfo'
    # this can be useful to provide information about the class,
    # either as text or otherwise, in case you have multiple similar
    # but different classes.
    # It's also useful if there are some fixed numbers defining
    # the class' behaviour but you don't want to bury them somewhere
    # in the code (and haven't gotten around to putting them into
    # a separate file or look-up table, as you probably should)

    @staticmethod
    def stat(arg1, arg2):
        '''similarly, static methods are for stuff that is specific
        to the class but still useful without an instance'''
        pass
        # e.g.: some preprocessor for input needed to instantiate the
        # class, or a computation specific to the type of thing
        # represented by the class
        return(arg1 + arg2)

    @classmethod
    def classy(cls, str1)
        '''class methods get access to other class stuff. So, basically,
        they can do less-trivial things'''
        return(cls.stat(str1, cls.info)

    def __init__(self, arg):
        ''' ...and here starts the regular instance-internal stuff'''
        self.arg = arg

    def simplething(self, arg):
        '''I like to put the simple/basic things first which don't
        call other instance methods...'''
        return(arg * self.arg)

    def complicated(self, arg1, arg2):
        '''...before the methods which call the other methods above them'''
        return(self.simplething(arg1) / simplething(arg2))

简而言之：在类创建之前，任何有用的东西都在__init__()定义之上，首先是类全局定义，然后是静态方法，然后是类方法，在__init__()之后，所有方法都按层次顺序排列。
好处（对我来说）这样做的原因是，当我滚动代码并找到某个调用类中其他方法的方法时，我已经看到了这些方法。我认为没有客观上的“最佳”方法来做到这一点，因为你可以反过来安排事情，并且仍然知道先看哪里。对我来说，这种方式对我来说更直观，它还有一个好处，在开发过程中的某个时候，我更有可能在底部添加更高级的方法，而不是在顶部挤出低级的方法。
另一种方法可能是按“相关性”对事物进行排序。即：类的用户期望最经常需要的东西可能在顶部。如果你有很多人使用你的代码但不修改它（很多），这可能是好的。我确实看到有些人不是这样组织他们的类，而是这样组织函数的模块：你最有可能直接调用的函数在最上面，它调用的函数在下面。但是对于一个类的内部函数来说，它的方法很少按顺序执行，这种顺序可能很难确定，并且可能更难找到静态或类方法的明确列表。
...绝对不是一个标准，但也许对那些寻找它的人来说是一个小方向，或者至少是一个起点，来解释为什么你的订单比我的好：）

我认为在python上声明@staticmethod和@classmethod的方法是在函数的正上方添加方法语句（@staticmethod或@classmethod）。
@classmethod的用法类似于示例函数，它需要一些参数，如class或cls（u可以更改参数名称，因此由u决定）。
无论是@static method，它都不需要像示例方法或类方法那样的self或class参数。这两个方法绑定到类而不是类的对象，因此@staticmethod无法访问或修改，因为@staticmethod不知道类的状态。但是对于@classmethod可以访问或修改类状态，因为它可以访问它（在调用@classmethod时查看cls参数）但请记住，如果你通过@classmethod更改了一些状态，它将更改类的所有示例的所有状态。
你可以在下面的例子中看到差异。
示例：

@classmethod
def something(cls, arg1, arg2, ....): #this is class method

@staticmethod
def something2(arg1, arg2, ...):   #this is static method

更多的解释，也许你可以看到这个链接：
静态和类方法解释：link
类或静态变量说明：link

• 我编辑了我的答案，因为我似乎没有回答你的问题

没有任何严格的规则/标准来安排它，幸运的是在python中，你不必指定你想要定义什么类型的方法（在java中，比如public void...或private int...等）。
1.班级名称
第一个顺序是类的名称，然后你可以像java一样拥有属性引用和示例化。你也可以指定属性的范围（比如private等）。
1.示例化
然后你可以像java一样声明示例化，通过声明def __init__(self, ...)。如果你声明了示例化，那么当你声明新的类示例时，它会自动调用__init__。如果你没有声明，python会继续调用这个函数，因为它会自动从基类继承，不会做任何事情
1.功能/方法
之后，u可以声明函数。U可以定义instance method或@classmethod或@staticmethod并做一些事情。其方法有其自身的优点，因此取决于你如何需要它。
Python也支持继承和多重继承。更多的解释你可以看这个链接link。
希望能帮上忙。