nomenclatura - pep8 python 3

Defina funciones con demasiados argumentos para cumplir con el estándar PEP8

Question

He definido una función con una larga lista de argumentos. El total de caracteres en la definición está por encima de 80 y no cumple con PEP8.

def my_function(argument_one, argument_two, argument_three, argument_four, argument_five):

¿Cuál puede ser el mejor enfoque para evitar el desplazamiento horizontal?

Answer 1

Me encuentro de esta manera para ser bastante interesante:

def my_function(
        argument_one, argument_two, argument_three,
        argument_four, argument_five
):
    ...

permite que el plegado de código revele las firmas de funciones con bastante facilidad, por ejemplo, considere el siguiente fragmento:

def my_function(
        argument_one, argument_two, argument_three,
        argument_four, argument_five
):
    s1 = 1
    s2 = 2
    if s1 + s2:
        s3 = 3


def my_other_function(argument_one, argument_two, argument_three):
    s1 = 1
    s2 = 2
    if s1 + s2:
        s3 = 3

De esta forma, se puede codificar el archivo completo y ver todas las funciones / firmas al mismo tiempo, es decir:

Answer 2

Para el código de Python que utiliza el verificador de tipo "typing" , sugiero esto:

def some_func(
    foo: str,
    bar: str = ''default_string'',
    qux: Optional[str] = None,
    qui: Optional[int] = None,
) -> List[str]:
    """
    This is an example function.
    """
    print(foo)
    ...

Las variantes con múltiples parámetros en una sola línea se ven realmente caóticas cuando se usan anotaciones tipo, en mi humilde opinión. Así que creo que es mejor tener a cada uno de ellos en su propia línea.

Si usa "yapf" puede usar estas opciones en .style.yapf :

[style]
dedent_closing_brackets = true
split_arguments_when_comma_terminated = true

Answer 3

Personalmente, me gusta alinear los params uno por línea comenzando con los paréntesis abiertos y manteniendo esa sangría. flake8 parece feliz con eso también.

def guess_device_type(device_name: str,
                      username: str=app.config[''KEY_TACACS_USER''],
                      password: str=app.config[''KEY_TACACS_PASS''],
                      command: str=''show version'') -> str:
    """Get a device_type string for netmiko"""

Answer 4

Personalmente, también solía encontrar la misma solución que el segundo estilo de @BrenBarn. Me gusta su forma de representar correctamente la sangría de los parámetros de la función Y su implementación, aunque esa "cara infeliz" es algo inusual para otras personas.

Hoy en día, PEP8 brinda específicamente un ejemplo para este caso, por lo que quizás la corriente principal adapte ese estilo:

# More indentation included to distinguish this from the rest.
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

Answer 5

Un ejemplo se da en PEP 8:

class Rectangle(Blob):

    def __init__(self, width, height,
                 color=''black'', emphasis=None, highlight=0):

Esa es la respuesta oficial. Personalmente detesto este enfoque, en el que las líneas de continuación tienen espacios en blanco que no corresponden a ningún nivel real de sangría. Mi enfoque sería:

class Rectangle(Blob):

    def __init__(
        self, width, height,
        color=''black'', emphasis=None, highlight=0
    ):

. . . o simplemente deje que la línea ejecute más de 80 caracteres.

Answer 6

def my_function(argument_one, argument_two, argument_three, 
                argument_four, argument_five):