Les générateurs sont un moyen simple mais puissant de créer des itérateurs. Les générateurs sont écrits comme des fonctions normales, mais utilisent le rendement pour retourner les données. A chaque appel suivant(), le générateur continue au point où il a été arrêté pour la dernière fois (le générateur mémorise les valeurs de toutes les variables et quelle instruction a été exécutée pour la dernière fois). L'exemple suivant montre à quel point il est facile de créer des générateurs :
def reverse (données) :
pour les index dans la plage (données)-1, -1, -1, -1, -1, -1, -1) :
données de performance[index]
>>> pour l'omble inversé ('golf') :
... print (char)
...
f
l
o
g
Tout ce qui peut être fait avec les générateurs peut être fait avec les itérateurs de classe (comme montré dans la section précédente). Cependant, les générateurs permettent une notation plus compacte, puisque les méthodes __iter__((() et __next__() sont créées automatiquement.
De plus, les variables locales et l'état d'exécution sont automatiquement stockés entre les appels. Cela rend l'écriture de la fonction plus facile et plus compréhensible que l'utilisation de variables d'instance telles que l'auto-index ou les données personnelles.
Les générateurs démarrent automatiquement StopIteration lorsqu'ils se terminent. Toutes ces fonctionnalités permettent de créer des itérateurs avec un effort qui se limite à la création d'une fonction normale.
Expressions du générateur
Certains générateurs simples peuvent être écrits synthétiquement sous forme d'expressions en utilisant une syntaxe similaire à celle de List Comprehensions, mais avec des crochets ronds plutôt que carrés. Ces expressions sont destinées aux situations où le générateur est immédiatement utilisé par la fonction environnante. Les expressions de générateur sont plus compactes, mais pas aussi flexibles que les définitions de générateur, et ont tendance à être plus efficaces en mémoire que la compréhension correspondante de la liste.
Exemples
>>>>> somme(s*i) pour i dans la plage(10) # Somme des carrés
285
>>> Sous-titres par MemoryOnSmells ;
>>> Sous-titres par MemoryOnSmells ;
>>> somme (x*y pour x,y dans zip(xvec, yvec)) # produit scalaire.
260
>>>>> de l'importation mathématique de pi, le péché
sine_table = {x : sin(x*pi/180) for x in range(0, 91)}}.
>>> unique_words = set(word per line on page per word on line.split()))
>>>>> major de promotion = max((studente.gpa, studente.nome) pour les étudiants diplômés)
>>>> données ='golf'.
>>> list(data(s) for the range (len(data)-1, -1, -1, -1, -1, -1, -1, -1))))
('f','I','o','g')
Une brève introduction à la bibliothèque standard
Interface avec le système d'exploitation
Le module os contient des dizaines de fonctions pour interagir avec le système d'exploitation :
>>> Importer Os
>>>>> os.getcwd() # le répertoire de travail courant
"C:_
>>> os.chdir('/server/accesslogs') # Modifier le classeur
>>>>> os.system('mkdir aujourd'hui') # Exécuter la commande dans le shell système
>>> 0
Il est important d'utiliser os import au lieu de os import *, sinon os.open() remplace la fonction intégrée open(), qui se comporte d'une manière complètement différente.
Les fonctions intégrées dir() et help() sont particulièrement utiles lors de l'utilisation de l'interpréteur de commandes interactif Python lors de l'utilisation de grands modules tels que os :
>>> Importer Os
# You(os)
une liste de toutes les fonctions du module> < une liste de toutes les fonctions du module
Aide >>> Aide
<une instruction détaillée, créée à partir de la documentation du module>.
Le module shutil, qui fournit une interface plus simple, facilite le travail typique avec les fichiers et répertoires :
>>>>>>> importer shutil
>>>>> shutil.copyfile('data.db','archive.db')
>>>> shutil.move('/build/executables','installdir')
Caractères de remplissage dans les noms de fichiers
Avec le module glob, des espaces réservés peuvent être utilisés pour rechercher des noms de fichiers ou de dossiers :
importer globe >>>>>>>> importer globe
>>> glob.glob('*.py')
('prime.py','random.py','quote.py')]
Arguments en ligne de commande
La plupart des scripts doivent traiter les arguments de la ligne de commande. Ces arguments sont stockés sous forme de liste dans l'attribut argv du module sys. Avec le script suivant enregistré sous le nom demo.py :
importation
sys.argv print
vous obtenez le résultat suivant si vous tapez python demo.py un deux trois dans la ligne de commande de votre système d'exploitation :
('demo.py','un','deux','trois')
Le module getopt traite sys.argv selon les conventions habituelles de la fonction getopt() d'Unix. Le module argparse offre des possibilités plus larges et plus flexibles.
Redirection des messages d'erreur et arrêt du programme
Le module sys a aussi des attributs pour stdin, stdout et stderr. Ce dernier est particulièrement utile lorsque des alertes et des messages d'erreur sont émis, par exemple lorsque stdout a été redirigé :
>>>> sys.stderr.write('Attention, le fichier journal n'a pas été trouvé\n')
Attention, le fichier journal n'a pas été trouvé
La façon la plus directe de quitter un script est via sys.exit().
