Métodos estáticos de la clase Python

Quiero crear un tipo de clase de utilidad que contenga solo métodos estáticos que puedan llamarse con el prefijo de clase de nombre. Parece que estoy haciendo algo mal 🙂

Aquí está mi pequeña clase:

class FileUtility(): @staticmethod def GetFileSize(self, fullName): fileSize = os.path.getsize(fullName) return fileSize @staticmethod def GetFilePath(self, fullName): filePath = os.path.abspath(fullName) return filePath 

Ahora mi método “principal”:

 from FileUtility import * def main(): path = 'C:\config_file_list.txt' dir = FileUtility.GetFilePath(path) print dir 

y recibí un error: se unbound method GetFilePath() must be called with FileUtility instance as first argument (got str instance instead) .

Tengo algunas preguntas aquí:

  1. ¿Qué estoy haciendo mal? ¿No debería ser invocable el método estático por nombre de clase?
  2. ¿Realmente necesito una clase de utilidad, o hay otras formas de lograr lo mismo en Python?
  3. Si bash cambiar el código principal, TypeError: GetFilePath() takes exactly 1 argument (2 given) : TypeError: GetFilePath() takes exactly 1 argument (2 given)

El nuevo main :

 from FileUtility import * def main(): objFile = FileUtility() path = 'H:\config_file_list.txt' dir = objFile.GetFilePath(path) print dir 

Recibes el error porque estás tomando un argumento self en cada una de esas funciones. Son estáticos, no los necesitas.

Sin embargo, la forma “pirónica” de hacer esto no es tener una clase llena de métodos estáticos, sino simplemente hacerlos funciones libres en un módulo.

 #fileutility.py: def get_file_size(fullName): fileSize = os.path.getsize(fullName) return fileSize def get_file_path(fullName): filePath = os.path.abspath(fullName) return filePath 

Ahora, en tus otros archivos de Python (asumiendo que fileutility.py está en el mismo directorio o en PYTHONPATH )

 import fileutility fileutility.get_file_size("myfile.txt") fileutility.get_file_path("that.txt") 

No menciona métodos estáticos específicamente, pero si viene de un lenguaje diferente, PEP 8 , la guía de estilo de Python es una buena lectura y una introducción a cómo piensan los progtwigdores de Python.

Realmente no deberías estar creando métodos estáticos en Python. Lo que debería hacer es colocarlos en el nivel de función global y luego acceder al módulo en el que están cuando los llama.

foo.py:

 def bar(): return 42 

baz.py:

 import foo print foo.bar() 

Los métodos estáticos no hacen pasar el objeto como primer parámetro (sin objeto)

eliminar el parámetro self y las llamadas deberían funcionar. El problema de importación es relevante también. Y el comentario estático relevante también.

En Python, static métodos static java (o lo que sea) no se usan ampliamente, ya que realmente no tienen un propósito.

En su lugar, simplemente debe definir sus “métodos” como funciones en un módulo:

 #module1.py def fun1(): return do_stuff() def fun2(arg): return do_stuff_with_arg(arg) #main.py import module1 if __name__ == '__main__': a = module1.fun() print module1.fun2(a) 

Simplemente elimine self en la definición de métodos Tu intención es usarlo como estático. El yo es trabajar con la instancia de esa clase.

Si desea usar sus funciones definidas en la clase, solo tiene que crear una instancia de su clase y aplicar la función.

Entonces el resultado es:

 dir = FileUtility().GetFilePath(path) 

Solo agrega () después del nombre de tu clase.

No se necesita @staticmethod ya que está utilizando una función estándar, no estática. Pero en tu caso el resultado es el mismo.

Solo remueve el yo en la definición de la función. Ya que estás usando las funciones estáticas, no necesitas pasarte a ti mismo como un argumento para las funciones. Entonces tu clase y función deberían ser así:

 class FileUtility(): @staticmethod def GetFileSize(fullName): fileSize = os.path.getsize(fullName) return fileSize @staticmethod def GetFilePath(fullName): filePath = os.path.abspath(fullName) return filePath