Syntaxe de contrôle Python, fonctions (mémo d'apprentissage Python ②)

Cette fois, c'est un mémo d'apprentissage sur la syntaxe et les fonctions de contrôle.

si déclaration

point

Il n'y a pas de swhich (utilisez if, elif, else à la place)

#Vous pouvez attendre une entrée comme celle-ci
x = int(input("Veuillez saisir un entier: "))

if x < 0:
    x = 0
    print ("Le nombre négatif est zéro")
elif x == 0:
    print("zéro")
elif x == 1:
    print("Un")
else:
    print("Plus")

pour déclaration

point

Pour les éléments de n'importe quelle séquence (liste ou chaîne), vous pouvez itérer x dans l'ordre dans cette séquence.
Si vous devez modifier la séquence pendant l'itération, il est recommandé de faire une copie et de la répéter. Il est pratique d'utiliser la notation de tranche pour cela.


#Mesurer la longueur d'une chaîne
words = ['cat', 'window', 'defenstrate']
for w in words:
    print(w, len(w))

#production
# cat 3
# window 6
# defenstrate 11

#Boucle à travers une copie de tranche de la liste entière
words = ['cat', 'window', 'defenstrate']
#Faire une copie superficielle de la liste
for w in words[:]:
    if len(w) > 6:
        words.insert(0, w)
print(words)

#production
# ['defenstrate', 'cat', 'window', 'defenstrate']

fonction range ()

point

Pratique pour répéter une série de nombres
N'inclut pas le point de terminaison donné
Les 10 valeurs générées par «range (10)» sont exactement les index pour chaque élément dans une séquence de longueur 10 (la séquence peut être indexée à plusieurs reprises).
Cependant, dans de nombreux cas, il est pratique d'utiliser la fonction ʻenumerate () `
L'objet renvoyé par range se comporte comme une liste, mais n'est pas une liste (objet ʻiterable`)
Économisez vraiment des ressources en n'utilisant pas de listes


#Répéter par plage
for i in range(5):
    print(i)

#production
# 0
# 1
# 2
# 3
# 4

#Itération à l'aide d'un index de séquence
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
    print(i, a[i])

#production
# 0 Mary
# 1 had
# 2 a
# 3 little
# 4 lamb

instructions break et continue, clause else dans la boucle

point

L'instruction break rompt la boucle for ou while comme en langage C.
Comme le langage C, l'instruction continue ignore le reste de la boucle et passe à l'itération suivante.
Vous pouvez également spécifier une clause else pour for ou while
Pour for, else est appelé lorsque la liste est épuisée
Dans le cas de while, else est appelé lorsque l'expression conditionnelle n'est pas satisfaite


for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
    else:
        #Cela dépend de pour
        #Si vous ne trouvez pas la fraction dans la boucle
        print(n, 'is a prime number')

#production
# 2 is a prime number
# 3 is a prime number
# 4 equals 2 * 2
# 5 is a prime number
# 6 equals 2 * 3
# 7 is a prime number
# 8 equals 2 * 4
# 9 equals 3 * 3

déclaration de réussite

point

La déclaration pass ne fait rien
À utiliser lorsque vous avez besoin d'une instruction syntaxiquement mais que vous n'avez rien à faire par programme
Également souvent utilisé pour générer la plus petite classe
Lorsque vous écrivez un nouveau code, vous pouvez le placer comme espace réservé dans le corps d'une fonction ou d'une condition pour vous aider à réfléchir à un niveau plus abstrait.

while True:
    pass #Ne rien faire Ctrl+Attendez de terminer avec C

#Générez la plus petite classe
class MyEmptyClass
    pass

#Définition des fonctions
def initLog(*args):
    pass #Effacer après la mise en œuvre

Définition des fonctions

point

Vous pouvez utiliser un littéral de chaîne dans la première instruction du corps de la fonction (ce sera la chaîne de documentation de la fonction). C'est une bonne action, alors faites-en une habitude.
Il est pratique d'écrire une docstring afin que le document puisse être généré automatiquement.
Les variables globales ne peuvent être référencées que dans les fonctions
Vous ne pouvez pas attribuer directement une valeur (sauf si spécifié dans l'instruction global)
Les arguments réels passés lors de l'appel d'une fonction sont ajoutés à la table de symboles locale de la fonction au moment de l'appel.
Pour les objets, une référence à l'objet est passée
Les fonctions sans instruction return renvoient None

def fib(n):
    """Afficher les séries Fibonacci jusqu'à n"""
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

fib(2000)

#production
# 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

En savoir plus sur la définition des fonctions

Valeur par défaut de l'argument

point

La valeur par défaut peut être définie pour l'argument
L'évaluation de la valeur par défaut est effectuée dans le périmètre où la définition est écrite lorsque la fonction est définie (Exemple ①).
Notez que l'évaluation de la valeur par défaut n'a lieu qu'une seule fois
Si la valeur par défaut est un objet variable tel qu'une liste ou un dictionnaire, cela l'affectera (Exemple 2).

#Exemple ①
i = 5

def f(arg=i):
    print(arg)

i = 6
f()

#production
# 5

#Exemple ②
def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

#production
# [1]
# [1, 2]
# [1, 2, 3]

Argument de mot-clé

point

Les fonctions peuvent prendre des arguments de mots-clés
Chaque fois que vous appelez une fonction, l'argument positionnel doit venir en premier et l'argument mot-clé doit venir après.
Tous les arguments de mot-clé doivent correspondre à ceux écrits dans les arguments formels de la définition de fonction, mais l'ordre n'a pas d'importance.
L'argument ne peut prendre la valeur qu'une seule fois (la spécification d'argument en double n'est pas valide)

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print("-- This parrot wouldn't", action, end=' ');

#Vous pouvez appeler de l'une des manières suivantes
parrot(1000)                                         #1 argument positionnel
parrot(voltage=1000)                                 #1 argument de mot-clé
parrot(voltage=100000000, action='VOOOOOM')          #2 arguments de mots clés
parrot(action='VOOOOOOOM', voltage=1000000)          #2 arguments de mots clés
parrot('a million', 'bereft of life', 'jump')        #3 arguments de position
parrot('a tousand', state='pushing up the daisies')  #1 argument de position 1 argument de mot-clé

#L'appel suivant n'est pas valide
# parrot()                     #Arguments requis manquants
# parrot(voltage=5.0, 'dead')  #Argument non-mot-clé après l'argument mot-clé
# parrot(110, voltage=220)     #Étant donné le même argument deux fois
# parrot(actor='John Cleese')  #Argument de mot clé inconnu

Si l'argument formel se termine sous la forme ** nom, cet argument recevra un dictionnaire
Ce dictionnaire contient tous les arguments de mot-clé à l'exception des mots-clés qui correspondent aux arguments formels (c'est-à-dire que vous pouvez utiliser des mots-clés qui ne sont pas dans les arguments formels).
Peut également être combiné avec le format * name
Dans l'exemple ci-dessous, le résultat de la méthode key () est utilisé lors de l'affichage du contenu du dictionnaire de mots-clés. Cela corrige l'ordre d'affichage des arguments.

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
        print("-" * 40)
        keys = sorted(keywords.keys())
        for kw in keys:
            print(kw, ":", keywords[kw])
            
cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

#production
# -- Do you have any Limburger ?
# -- I'm sorry, we're all out of Limburger
# It's very runny, sir.
# ----------------------------------------
# client : John Cleese
# shopkeeper : Michael Palin
# sketch : Cheese Shop Sketch
# It's really very, VERY runny, sir.
# ----------------------------------------
# client : John Cleese
# shopkeeper : Michael Palin
# sketch : Cheese Shop Sketch

Liste des arguments facultatifs

point

Peut accepter un nombre variable d'arguments
Les arguments sont regroupés en taples
Les arguments normaux peuvent être placés avant le nombre variable d'arguments
Mettre un nombre variable d'arguments à la fin de la liste d'arguments formels (car il aspire tout le reste des arguments passés à la fonction)
Dans le cas du format * args, tous les arguments formels après cela ne peuvent être utilisés que comme arguments de mot-clé, pas comme arguments de position.

def concat(*args, sep="/"):
    return sep.join(args)

print(concat("earth", "mars", "venus"))

#production
# earth/mars/venus

print(concat("earth", "mars", "venus", sep="."))

#production
# earth.mars.venus

Déballage de la liste d'arguments

point

Il existe un moyen pratique dans les situations où ce que vous voulez être un argument est déjà une liste ou un tapple et vous devez le décompresser pour une fonction qui nécessite un argument positionné. Vous pouvez facilement décompresser des listes et des taples en utilisant la fonction * range et le format * args

>>> list(range(3, 6))
[3, 4, 5]

>>> args = [3, 6]
>>> list(range(*args))
[3, 4, 5]

De même, le dictionnaire peut être passé comme argument de mot-clé en utilisant l'opérateur **.

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

expression lambda

point

Vous pouvez écrire une petite fonction anonyme en utilisant le mot-clé lambda
Il existe une limitation syntaxique selon laquelle ce format ne peut avoir qu'une seule expression

def make_incrementor(n):
    return lambda x: x + n #Renvoie une fonction anonyme

f = make_incrementor(42)

f(0) # 42
f(1) # 43

Chaîne de document (docstring)

point

La première ligne doit toujours être un résumé court et concis de l'objectif de l'objet
Cette ligne commence par une majuscule et se termine par un point
S'il y a une suite, laissez la deuxième ligne de la chaîne de documentation vide et séparez visuellement le résumé des autres descriptions.
La ligne de transition doit utiliser des paragraphes pour décrire comment l'appeler et ses effets secondaires.
L'analyseur Python ne supprime pas l'indentation des littéraux de chaîne multiligne, donc si vous souhaitez le supprimer, utilisez l'outil de documentation.

def my_function():
    """Do nothing, but document it.
    
    No, really, it doesn't do anything.
    """
    pass

print(my_function.__doc__)

#production
# Do nothing, but document it.
# 
#     No, really, it doesn't do anything.

Annotation de fonction (annotation de fonction)

point

Les informations de métadonnées de type peuvent être ajoutées
Stocké sous forme de dictionnaire dans l'attribut __annotations__ de la fonction et n'a aucun effet sur le reste de la fonction
Les annotations d'argument peuvent être définies en suivant le nom de l'argument avec deux points et une expression.
L'annotation de la valeur de retour est définie en insérant un littéral -> avant les deux points à la fin de l'instruction def et entre la liste d'arguments formels.

def f(ham: str, eggs: str = 'eggs') -> str:
    print("Annotations:", f.__annotations__)
    print("Arguments:", ham, eggs)
    return ham + ' and ' + eggs

f('spam')

#production
# Annotations: {'ham': <class 'str'>, 'eggs': <class 'str'>, 'return': <class 'str'>}
# Arguments: spam eggs
# 'spam and eggs'

Style de codage

point

Retrait de 4 espaces, sans tabulations
Enveloppez les lignes de 79 caractères ou moins
Utilisez des lignes vides pour séparer les fonctions, les classes et les grands blocs au sein des fonctions
Rendre les lignes de commentaires indépendantes si possible
Utilisez docstring
Mettez un espace autour de l'opérateur et après la virgule, mais pas seulement à l'intérieur des parenthèses Exemple: a = f (1, 2) + g (3, 4)
Utilisez CamelCase pour les classes et lower_case_with_underscores pour les fonctions et méthodes
Toujours utiliser self comme premier argument de la méthode
Utilisez l'UTF-8 ou ASCII par défaut pour l'encodage