web-dev-qa-db-fra.com

Définir des fonctions avec trop d'arguments pour respecter la norme PEP8

J'ai défini une fonction avec une longue liste d'arguments. Le nombre total de caractères dans la définition est supérieur à 80 et ne respecte pas PEP8.

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

Quelle peut être la meilleure approche pour éviter le défilement horizontal?.

pythonpep8
40
Sudip Kafle

Un exemple est donné dans le PEP 8:

class Rectangle(Blob):

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

Voilà donc la réponse officielle. Personnellement, je déteste cette approche dans laquelle les lignes de continuation ont des espaces qui ne correspondent à aucun niveau d'indentation réel. Mon approche serait:

class Rectangle(Blob):

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

. . . ou simplement laisser la ligne dépasser 80 caractères.

54
BrenBarn
def my_function(argument_one, argument_two, argument_three, 
                argument_four, argument_five):
10
kylie.a

Pour le code Python qui utilise le vérificateur "typing" type, je suggère ceci:

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)
    ...

Les variantes avec plusieurs paramètres sur une seule ligne semblent vraiment chaotiques lorsque des annotations de type sont utilisées, à mon humble avis. Donc, je pense qu'il est préférable d'avoir chacun d'eux sur sa propre ligne.

Si vous utilisez "yapf" vous pouvez utiliser ces options dans .style.yapf:

[style]
dedent_closing_brackets = true
split_arguments_when_comma_terminated = true
7
Rotareti

Personnellement, j'aime bien aligner les paramètres une par ligne en commençant par les parenthèses ouvertes et en conservant cet alinéa. flake8 semble en être satisfait aussi.

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"""
2
Ben

Personnellement, j’avais aussi la même solution que le second style de @BrenBarn. J'aime sa façon de représenter correctement l'indentation des paramètres de fonction ET sa mise en œuvre, bien que ce "visage malheureux" soit quelque peu inhabituel pour certaines autres personnes.

De nos jours, PEP8 donne précisément un exemple pour ce type de cas, le grand public va peut-être adapter ce style:

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

Je me trouve de cette façon très intéressant:

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

cela permet au pliage de code de révéler assez facilement les signatures des fonctions, par exemple, considérons l'extrait ci-dessous:

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

Cette méthode permet de plier le fichier en entier et d’afficher toutes les fonctions/signatures en même temps, c’est-à-dire:

 enter image description here

0
BPL