python - framework - tutorial django

Cómo especificar que un parámetro es una lista de objetos específicos en cadenas de Python

Question

Me gusta usar docstrings en Python para especificar parámetros de tipo cuando los proyectos superan un determinado tamaño.

Tengo problemas para encontrar un estándar para especificar que un parámetro es una lista de objetos específicos, por ejemplo, en los tipos de Haskell usaría [String] o [A].

Estándar actual (reconocible por el editor PyCharm):

def stringify(listOfObjects):
    """
    :type listOfObjects: list
    """
    return ", ".join(map(str, listOfObjects))

Lo que preferiría:

OPCIÓN 1

def stringify(listOfObjects):
    """
    :type listOfObjects: list<Object>  
    """
    return ", ".join(map(str, listOfObjects))

OPCION 2

def stringify(listOfObjects):
    """
    :type listOfObjects: [Object]
    """
    return ", ".join(map(str, listOfObjects))

Supongo que no fue un gran ejemplo; el caso de uso más relevante sería aquel en el que los objetos de la lista deben ser de un tipo específico.

MEJOR EJEMPLO

class Food(Object):
    def __init__(self, calories):
        self.calories = calories

class Apple(Food):
    def __init__(self):
        super(self, 200)

class Person(Object):
    energy = 0
    def eat(foods):
        """
        :type foods: [Food]  # is NOT recognised by editor
        """
        for food in foods:
            energy += food.calories

Entonces, aparte del hecho de que tengo hambre, este ejemplo ilustra que si se llama con una lista del tipo equivocado de objeto, el código se rompería. De ahí la importancia de documentar no solo que necesita una lista, sino que necesita una lista de alimentos.

PREGUNTA RELACIONADA ¿Cómo puedo decirle a PyCharm qué tipo de parámetro se espera que sea? Tenga en cuenta que estoy buscando una respuesta más específica que la anterior.

Answer 1

Al escribir docstrings en el estilo de google puedes hacer:

class ToDocument(object):
    """This is my Documentation.

    Args:
        typed_list (:obj:`list` of :obj:`str`): Description of typed list

    """
    ...

Esto también funciona bastante bien en sphinx, cuando se combina con la extensión napoleón. Consulte el documento de la extensión para obtener más ejemplos sobre la documentación.

Answer 2

En la sección de comentarios del manual de PyCharm hay una buena sugerencia del desarrollador:

#: :type: dict of (str, C)
#: :type: list of str

Me funciona bastante bien. Ahora me pregunto cuál es la mejor manera de documentar las clases parametrizadas en Python :).

Answer 3

en python

type([1,2,3]) == type([''a'', ''b'', ''c''])

también puede agregar una cadena a la lista de entradas.

Entonces, para lo que está tratando de lograr, PyCharm tendría que verificar mágicamente todo el código de lo que está agregando a la lista antes de pasarlo como argumento.

Puedes echarle un vistazo a esta pregunta Python: define una lista de un tipo específico de objeto

Sin embargo, el módulo de matriz solo permite ''valores básicos''.

La única solución que puedo pensar aquí es crear tu propia clase que extienda la lista de pitones "FoodsList" que puede verificar el tipo antes de agregar el elemento.

class Food():
    def __init__(self, calories):
        self.calories = calories

class FoodsList(list):
    #you can optionally extend append method here to validate type
    pass

def eat(foods):
    """
    :type foods: FoodsList
    """
    energy = 0
    for food in foods:
        energy += food.calories
    return energy


list = FoodsList()
list.append(Food(3))
list.append(Food(4))
print eat(list)