introduction

Il s'agit d'une tentative de lire la 3e édition du didacticiel Python et de noter ce que vous avez appris.

Et quand j'aurai fini de lire, j'aimerais passer cet examen À la fin, le test a commencé ...!

** Commençons! ** **

Examen de base pour la certification d'ingénieur Python 3

J'espère que ça continue, j'espère que ça continue

Outil de structure de contrôle

if déclaration

>>> x = int(input("Veuillez saisir un entier: "))
Veuillez saisir un entier: 42
>>> 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')
...
Plus

pour déclaration

Répéter les éléments dans n'importe quelle séquence (liste ou chaîne) dans l'ordre dans cette séquence

>>> #Mesurez la longueur d'une chaîne:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

--Il est recommandé de faire une copie et de la répéter lorsque la séquence en cours de répétition doit être modifiée.

Aucune copie implicite n'est effectuée en répétant la séquence

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

fonction range ()

La fonction intégrée «range ()» est utile lors d'une itération sur une série de nombres. --Générer un nombre égal d'étages

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

--La valeur de terminaison donnée n'est pas incluse

La valeur de 10 générée par range (10) est juste un index pour chaque élément dans une séquence de longueur 10. --range () peut commencer par un nombre autre que 0
Vous pouvez également spécifier un incrément (étape)

range(5, 10)
→ 5 à 9
range(0, 10, 3)
→ 0, 3, 6, 9
range(-10, -100, -30)
→ -10, -40, -70

--Si vous voulez répéter à l'index de la séquence, vous pouvez combiner range () et len () comme suit.

Dans un tel cas, il est pratique d'utiliser la fonction ʻenumerate () `.

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

--L'objet renvoyé par la fonction range () se comporte comme une liste à bien des égards, mais pas comme une liste.

Un objet qui renvoie en permanence des éléments dans la séquence souhaitée en le répétant, économisant ainsi de l'espace. --Un tel objet est appelé ** itérable ** ―― Cela signifie quelque chose qui fournit des articles en continu jusqu'à ce qu'il devienne, et quelque chose qui convient comme cible pour les fonctions et les structures qui attendent de telles choses.
La fonction ou la structure qui attend un corps répétable est appelée ** itérateur **.
La fonction list (), qui crée une liste à partir d'un corps répétable, est également un itérateur.

>>> list(range(5))
[0, 1, 2, 3, 4]

instructions break et continue, clause else dans la boucle

L'instruction break traverse la boucle for ou while
Une clause ʻelse est ajoutée à ces instructions de boucle La clause --ʻElse est exécutée lorsque la boucle se termine en raison de l'épuisement de la liste ou de l'expression conditionnelle devient "false", et n'est pas exécutée lorsque la boucle se termine par l'instruction "break".

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         #Si vous ne trouvez pas la fraction dans la boucle
...         print(n, 'is a prime number')
...
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

L'instruction continue ignore le reste de la boucle et passe à l'itération suivante

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found a number", num)
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9

déclaration de réussite

À utiliser lorsque vous n'avez rien à faire par programme

>>> while True:
...     pass #Interruption du clavier avec un poids occupé(Ctrl+C)Attendre
...

Souvent utilisé pour générer la plus petite classe

>>> class MyEmptyClass:
...     pass
...

Une autre utilisation de l'instruction pass est de la placer comme espace réservé dans le corps d'une fonction ou d'une condition lors de l'écriture d'un nouveau code pour vous aider à réfléchir au niveau abstrait.

>>> def initlog(*args):
...     pass #N'oubliez pas de mettre en œuvre!
...

Définition des fonctions

Le mot-clé def est le début de la définition de la fonction, et vous devez écrire le nom de la fonction et la liste des arguments formels entre parenthèses.
Ecrire l'instruction du corps de la fonction en retrait de la ligne suivante

`Une fonction qui écrit la série de Fibonacci jusqu'à une limite supérieure arbitraire`


>>> def fib(n): #Exporter des séries de Fibonacci jusqu'à n
...     """Afficher les séries Fibonacci jusqu'à n"""
...     a, b = 0, 1
...     while a < n:
...     print(a, end=' ')
...     a, b = b, a+b
...     print()
...
>>> #Appelons cette fonction
... fib(2000)
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

--Il est également possible de définir une fonction avec un nombre variable d'arguments ――Il existe trois formes et vous pouvez les combiner.

Valeur par défaut de l'argument

――La forme la plus utilisée --Les fonctions suivantes peuvent être appelées de différentes manières

Ne donnez que les arguments requis
- ask_ok('Do you really want to quit?')
Donner un argument facultatif
- ask_ok('OK to overwrite the file?', 2)
Donner tous les arguments
- ask_ok('OK to overwrite the file?', 2, 'Come on, only yes or no!')

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
    while True:
        ok = input(prompt)
        if ok in ('y', 'ye', 'yes'):
            return True
        if ok in ('n', 'no', 'nop', 'nope'):
            return False
        retries = retries - 1
        if retries < 0:
            raise OSError('Utilisateur non coopératif')
        print(complaint)

** L'évaluation de la valeur par défaut n'a lieu qu'une seule fois. ** ** Cela a un effet si la valeur par défaut est un objet mutable, à savoir une instance d'une liste, d'un dictionnaire et de la plupart des classes.

Par exemple, la fonction suivante accumule les arguments passés dans l'appel

>>> def f(a, L=[]):
...     L.append(a)
...     return L
...
>>> print(f(1))
[1]
>>> print(f(2))
[1, 2]
>>> print(f(3))
[1, 2, 3]
>>>

Si vous ne voulez pas que les valeurs par défaut soient partagées entre les appels, vous pouvez écrire cette fonction comme ceci:

>>> def f(a, L=None):
...     if L is None:
...             L = []
...     L.append(a)
...     return L
...
>>> print(f(1))
[1]
>>> print(f(2))
[2]
>>> print(f(3))
[3]

Argument de mot-clé

La fonction peut également prendre ** argument mot-clé ** sous la forme de "mot-clé = valeur"

>>> def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.")
...     print("-- It's", state, "!")
...

Cette fonction prend un argument obligatoire (tension), prend trois arguments optionnels (état, action, type) et peut être appelée sous l'une des formes suivantes:

>>> #Un argument de position
>>> parrot(1000)
-- This parrot wouldn't voom if you put 1000 volts through it.
-- It's a stiff !
>>> #Un argument de mot-clé
>>> parrot(voltage=1000)
-- This parrot wouldn't voom if you put 1000 volts through it.
-- It's a stiff !
>>> #Deux arguments de mots clés
>>> parrot(voltage=1000000, action='VOOOOOM')
-- This parrot wouldn't VOOOOOM if you put 1000000 volts through it.
-- It's a stiff !
>>> #Trois arguments de mots clés
>>> parrot(action='VOOOOOM', voltage=1000000)
-- This parrot wouldn't VOOOOOM if you put 1000000 volts through it.
-- It's a stiff !
>>> #3 arguments de position
>>> parrot('a million', 'bereft of life', 'jump')
-- This parrot wouldn't jump if you put a million volts through it.
-- It's bereft of life !
>>> #1 argument positionnel, 1 argument mot-clé
>>> parrot('a thousand', state='pushing up the daisies')
-- This parrot wouldn't voom if you put a thousand volts through it.
-- It's pushing up the daisies !

Mais l'appel suivant est invalide

>>> #Arguments requis manquants
>>> parrot()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: parrot() missing 1 required positional argument: 'voltage'
>>> #Argument non-mot-clé après l'argument mot-clé
>>> parrot(voltage=5.0, 'dead')
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument
>>> #Étant donné le même argument deux fois
>>> parrot(110, voltage=220)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: parrot() got multiple values for argument 'voltage'
>>> #Argument de mot clé inconnu
>>> parrot(actor='John Cleese')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: parrot() got an unexpected keyword argument 'actor'

Chaque fois que vous appelez une fonction, ** les arguments de position doivent venir en premier et les arguments de mots-clés viennent après **

Tous les arguments de mot-clé doivent correspondre à ce qui est écrit dans l'argument formel de la définition de fonction (l'argument acteur n'est pas valide dans la fonction perroquet), mais l'ordre n'a pas d'importance.

Ceci est également vrai pour les arguments non optionnels (par exemple, parrot (voltage = 1000) est également valide)

L'argument ne peut prendre une valeur qu'une seule fois. Voici un exemple d'échec dû à cette limitation. Une erreur de type s'est produite car l'argument de mot clé "a" de function () a plusieurs valeurs.

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function() got multiple values for argument 'a'

Si l'argument formel se termine sous la forme d'un nom «**», cet argument reçoit un dictionnaire. Ce dictionnaire contient tous les arguments de mot-clé à l'exception des mots-clés qui correspondent aux arguments formels. En d'autres termes, sous cette forme, des mots-clés qui ne sont pas dans l'argument formel peuvent être utilisés.

Il peut également être utilisé en combinaison avec le format de nom «». (Le nom «» doit précéder le nom «**».)

Dans ce format, un taple contenant tous les arguments spécifiques à la position qui ne sont pas dans l'argument formel est passé à la fonction. Par conséquent, si vous définissez la fonction suivante

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

Vous pouvez l'appeler comme ceci et la sortie sera:

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

Notez que lors de l'affichage du contenu du dictionnaire keywords, nous trions d'abord les résultats de la méthode key () et générons une liste d'arguments de mots-clés. Si cela n'est pas fait, l'ordre d'affichage des arguments sera indéfini.

Liste des arguments facultatifs

Une méthode d'écriture d'une fonction afin qu'elle puisse être appelée avec un nombre arbitraire d'arguments --Pas souvent utilisé --Les arguments de ceci sont rassemblés dans un taple
Un argument normal peut être placé avant ce nombre variable d'arguments.

>>> def write_multiple_items(file, separator, *args):
...     file.write(separator.join(args))

Les arguments de longueur variable sont placés à la fin de la liste d'arguments formels. C'est parce qu'il aspire tous les autres arguments passés à la fonction. Dans le format * args, tous les arguments formels après ceci sont des arguments "mot clé uniquement". En d'autres termes, il ne peut être utilisé que comme argument de mot-clé, pas comme argument de position.

>>> def concat(*args, sep="/"):
...     return sep.join(args)
...
>>> concat("earth", "mars", "venus")
'earth/mars/venus'
>>> concat("earth", "mars", "venus", sep=".")
'earth.mars.venus'

Déballage de la liste d'arguments

La situation inverse est que 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é.

Par exemple, la fonction intégrée range () attend des arguments séparés pour start et stop.

Si vous ne les avez pas individuellement, vous pouvez passer des arguments décompressés à partir d'une liste ou d'un tapple en appelant la fonction avec l'opérateur *.

>>> #Appel ordinaire avec arguments individuels
>>> list(range(3, 6))
[3, 4, 5]
>>> args = [3, 6]
>>> #Appel avec des arguments décompressés de la liste
>>> list(range(*args))
[3, 4, 5]

De même, vous pouvez utiliser l'opérateur ** pour passer un dictionnaire comme argument de mot-clé.

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

--Utilisez le mot-clé lambda pour multiplier une petite fonction anonyme --lambda a, b: a + b est une fonction qui renvoie la somme de deux arguments

Les fonctions Lambda peuvent être utilisées partout où un objet fonction est nécessaire --Cependant, ce format a une limitation syntaxique selon laquelle une seule expression est populaire. En termes de sémantique, cette forme n'est qu'un enrobage de sucre syntaxique sur une définition de fonction ordinaire.
Tout comme la définition de fonction imbriquée, la fonction lambda peut également faire référence aux variables de la portée qui l'entoure.

>>> def make_incrementor(n):
...     return lambda x: x + n
...
>>> f = make_incrementor(42)
>>> f(0)
42
>>> f(1)
43

Ce qui précède est un exemple de retour d'une fonction à l'aide d'une expression lambda. Une autre utilisation est lors du passage d'une petite fonction comme argument

>>> pairs = [(1, 'one'), (2, 'tow'), (3, 'three'), (4, 'four')]
>>> pairs.sort(key=lambda pair: pair[1])
>>> pairs
[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'tow')]

Chaîne de document (docstring)

La première ligne doit toujours être un résumé court et concis de l'objectif de l'objet --Ne spécifiez rien d'autre comme le nom ou le type de l'objet
(sauf si le nom de la fonction est déjà un verbe qui décrit son comportement) --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 pour séparer visuellement le résumé des autres descriptions. --Dans les lignes suivantes, utilisez des paragraphes pour décrire ** comment appeler ** et ** les effets secondaires ** de l'objet.
L'analyseur Python ne supprime pas l'indentation des littéraux de chaîne multiligne, donc si vous souhaitez le supprimer, vous devez le faire dans l'outil de traitement de document.
Premièrement, la ligne non vierge après la première ligne est utilisée comme standard pour l'indentation de la chaîne entière du document.
(La première ligne ne peut pas être utilisée. C'est généralement juste après le guillemet. , La quantité de retrait n'est pas reflétée dans le corps littéral de la chaîne de caractères) --Supprimez les espaces "équivalents" de ce montant de retrait depuis le début de chaque entreprise dans la chaîne.

Voici un exemple de docstring multiligne (notez la partie appelée par __doc__)

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

        No, really, it doesn't do anything.

Annotation de fonction (annotation de fonction)

L'annotation de fonction est l'option d'une personne
Saisissez les informations de métadonnées utilisées dans les fonctions définies par l'utilisateur
Les annotations sont stockées sous forme de dictionnaires dans l'attribut __annotations__ de la fonction.
N'affecte pas les autres parties de la fonction
L'annotation d'argument peut être définie en suivant le nom de l'argument avec deux points et une expression, et cette expression est évaluée et devient la valeur de l'annotation.
L'annotation de la valeur de retour est définie en insérant un littéral "->" et une expression avant le dernier deux-points pendant les minutes 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')
Annotations: {'ham': <class 'str'>, 'eggs': <class 'str'>, 'return': <class 'str'>}
Arguments: spam eggs
'spam and eggs'

Style de codage (uniquement les principaux points de PEP8)

--Indent avec 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 des blocs encore plus grands au sein des fonctions
Lignes de commentaires indépendantes si possible --Utiliser docstring --Mettez un espace autour de l'opérateur ou après la virgule, mais pas seulement à l'intérieur des parenthèses
a = f(1, 2) + g(3, 4)
Dénomination cohérente des classes et des fonctions --Camel Case en classe --SnakeCase pour les fonctions et méthodes
L'encodage doit être UTF-8 ou ASCII brut
N'utilisez pas de caractères non ASCII dans les identifiants d'un code pouvant être lu ou conservé par des personnes qui parlent des mots différents

le terme

séquence

Un type de séquence est une collection d'éléments ordonnés tels qu'une chaîne de caractères ou une liste. --Il existe 6 types de séquence dans le type intégré. --Chaîne de caractères
Chaîne unicode --Liste --Taple --Tampon --xrange objet

Itérable

La structure qui peut être itérée est appelée itérable.
L'itération est "répétée" et "accès à l'élément suivant"
À titre d'exemple, un objet qui peut être tourné avec une instruction for
Strictement parlant, un objet qui peut être un itérateur

Itérateur

Objet itérable qui se souvient de l'état (où il était en italique) --Iterator est l'un des objets itérables
Vous pouvez créer un itérateur à partir d'un objet itérable à l'aide de la fonction iter.
L'itérateur peut avancer l'état par la méthode suivante, et lorsqu'il devient impossible d'itérer (dans ce cas, le dernier élément est atteint), il déclenche une exception appelée StopIteration.
Ce n'est pas seulement la fonction suivante qui peut faire avancer l'itérateur

Espace réservé

--Mesures pour sécuriser temporairement une place jusqu'à ce que la valeur officielle soit saisie

http://wa3.i-3-i.info/word118.html

Déballer

Lorsque le côté droit est un tapple, vous pouvez développer le contenu en plaçant plusieurs variables sur le côté gauche. C'est ce qu'on appelle unpackage de séquence, mais je ne comprends pas tout à fait l'usage et la signification du mot "unpack" ... \ (^ o ^) /

Nombre égal d'étages

Je ne suis pas sûr ... \ (^ o ^) /

Informations de référence

http://note.crohaco.net/2016/python-iterator-generator-and-tshirt-me/

[Tutoriel Python] Outil de structure de contrôle