Une introduction à Python 3

Image non disponible


précédentsommairesuivant

Glossaire

>>>

  • Invite Python par défaut dans un shell interactif. Souvent utilisée dans les exemples de code extraits de sessions de l'interpréteur Python.

  • Invite Python par défaut dans un shell interactif, utilisée lorsqu'il faut entrer le code d'un bloc indenté ou à l'intérieur d'une paire de parenthèses, crochets ou accolades.

2to3

  • Un outil qui essaye de convertir le code Python 2.x en code Python 3.x en gérant la plupart des incompatibilités qu'il peut détecter.
    2to3 est disponible dans la bibliothèque standard lib2to2 ; un point d'entrée autonome est Tool/scipts/2to3.
    Voir 2to3 - Automated Python 2 to 3 code translation.

abstract base class ABC (classe de base abstraite)

  • Complète le duck-typing en fournissant un moyen de définir des interfaces alors que d'autres techniques (comme hasattr()) sont plus lourdes. Python fournit de base plusieurs ABC pour les structures de données (module collections), les nombres (module numbers) et les flux (module io). Vous pouvez créer votre propre ABC en utilisant le module abc.

argument (argument) [cf. chapitre 5.2Passage des arguments]

  • Valeur passée à une fonction ou une méthode, affectée à une variable nommée locale au corps de la fonction. Une fonction ou une méthode peut avoir à la fois des arguments par position et avec des valeurs par défaut. Ces arguments peuvent être de multiplicité variable : * accepte ou fournit plusieurs arguments par position dans une liste, tandis que ** joue le même rôle en utilisant les valeurs par défaut dans un dictionnaire.
    On peut passer toute expression dans la liste d'arguments, et la valeur évaluée est transmise à la variable locale.

attribute (attribut) [cf. chapitre 7.1Terminologie]

  • Valeur associée à un objet référencé par un nom et une expression pointée. Par exemple, l'attribut a d'un objet o peut être référencé o.a.

BDFL Benevolent Dictator For Life (Dictateur Bienveillant à Vie) [cf. chapitre 1Introduction]

  • Amical surnom de Guido van Rossum, le créateur de Python.

bytecode (bytecode ou langage intermédiaire) [cf. chapitre 1.4.1Deux techniques de production des programmes]

  • Le code source Python est compilé en bytecode, représentation interne d'un programme Python dans l'interpréteur. Le bytecode est également rangé dans des fichiers .pyc et .pyo, ainsi l'exécution d'un même fichier est plus rapide les fois ultérieures (la compilation du source en bytecode peut être évitée). On dit que le bytecode tourne sur une machine virtuelle qui, essentiellement, se réduit à une collection d'appels des routines correspondant à chaque code du bytecode.

class (classe) [cf. chapitre 7.1Terminologie]

  • Modèle permettant de créer ses propres objets. Les définitions de classes contiennent normalement des définitions de méthodes qui opèrent sur les instances de classes.

coercion (coercition ou transtypage) [cf. chapitre 2.9.1Les entrées]

  • Conversion implicite d'une instance d'un type dans un autre type dans une opération concernant deux arguments de types compatibles. Par exemple, int(3.15) convertit le nombre flottant 3.15 en l'entier 3, mais dans 3+4.5, chaque argument est d'un type différent (l'un int et l'autre float) et tous deux doivent être convertis dans le même type avant d'être additionnés, sinon une exception TypeError sera lancée. Sans coercition, tous les arguments, même de types compatibles, doivent être normalisés à la même valeur par le programmeur, par exemple, float(3)+4.5 au lieu de simplement 3+4.5.

complex number (nombre complexe) [cf. chapitre 2.5.2Le type complex]

  • Une extension du système familier des nombres réels dans laquelle tous les nombres sont exprimés comme la somme d'une partie réelle et une partie imaginaire. Les nombres imaginaires sont des multiples réels de l'unité imaginaire (la racine carrée de -1), souvent écrite i par les mathématiciens et j par les ingénieurs. Python a un traitement incorporé des nombres complexes, qui sont écrits avec cette deuxième notation ; la partie imaginaire est écrite avec un suffixe j , par exemple 3+1j. Pour avoir accès aux équivalents complexes des éléments du module math utilisez le module cmath.
    L'utilisation des nombres complexes est une possibilité mathématique assez avancée. Si vous n'êtes pas certain d'en avoir besoin, vous pouvez les ignorer sans risque.

context manager (gestionnaire de contexte) [cf. chapitre 9.1.2Gestionnaire de contexte (ou bloc gardé)]

  • Objet qui contrôle l'environnement indiqué par l'instruction with et qui définit les méthodes __enter__() et __exit__(). Voir la PEP 343.

CPython (Python classique) [cf. chapitre 1.6Implémentations de Python]

  • Implémentation canonique du langage de programmation Python. Le terme CPython est utilisé dans les cas où il est nécessaire de distinguer cette implémentation d'autres comme Jython ou IronPython.

decorator (décorateur) [cf. chapitre 9.1.10Les décorateurs]

  • Fonction retournant une autre fonction habituellement appliquée comme une transformation utilisant la syntaxe @wrapper.
    classmethod() et staticmethod() sont des exemples classiques de décorateurs.
    Les deux définitions de fonctions suivantes sont sémantiquement équivalentes :
 
Sélectionnez
def f(…) :
    …
f = staticmethod(f)
 
Sélectionnez
@staticmethod
def f(…) :
    …

Un concept identique existe pour les classes, mais est moins utilisé. Voir la documentation function definition et class definition pour plus de détails sur les décorateurs.

descriptor (descripteur)

  • Tout objet qui définit les méthodes __get__(), __set__() ou __delete__(). Lorsqu'un attribut d'une classe est un descripteur, un comportement spécifique est déclenché lors de la consultation de l'attribut. Normalement, écrire a.b consulte l'objet b dans le dictionnaire de la classe de a, mais si b est un descripteur, la méthode __get__() est appelée. Comprendre les descripteurs est fondamental pour la compréhension profonde de Python, car ils sont à la base de nombreuses caractéristiques, comme les fonctions, les méthodes, les propriétés, les méthodes de classe, les méthodes statiques et les références aux super-classes.
    Pour plus d'informations sur les méthodes des descripteurs, voir Implementing Descriptors.

dictionary (dictionnaire) [cf. chapitre 4.5.1Dictionnaires (dict)]

  • Une table associative, dans laquelle des clés arbitraires sont associées à des valeurs. L'utilisation des objets dict ressemble beaucoup à celle des objets list, mais les clés peuvent être n'importe quels objets ayant une fonction __hash__(), non seulement des entiers. Ces tables sont appelées hash en Perl.

docstring (chaîne de documentation) [cf. chapitre 5.1Définition et syntaxe]

  • Chaîne littérale apparaissant comme première expression d'une classe, d'une fonction ou d'un module. Bien qu'ignorée à l'exécution, elle est reconnue par le compilateur et incluse dans l'attribut __doc__ de la classe, de la fonction ou du module qui la contient. Depuis qu'elle est disponible via l'introspection, c'est l'endroit canonique pour documenter un objet.

duck-typing (typage « comme un canard ») [cf. chapitre 9.2.3Le duck typing et les annotations]

  • Style de programmation pythonique dans lequel on détermine le type d'un objet par inspection de ses méthodes et attributs plutôt que par des relations explicites à des types (« s'il ressemble à un canard et fait coin-coin comme un canard alors ce doit être un canard »). En mettant l'accent sur des interfaces plutôt que sur des types spécifiques, on améliore la flexibilité du code en permettant la substitution polymorphe. Le duck-typing évite les tests qui utilisent type() ou isinstance() (notez cependant que le duck-typing doit être complété par l'emploi des classes de base abstraites). À la place, il emploie des tests comme hasattr() et le style de programmation EAFP.

EAFP (Easier to ask for forgiveness than permission, ou « plus facile de demander pardon que la permission »)

  • Ce style courant de programmation en Python consiste à supposer l'existence des clés et des attributs nécessaires à l'exécution d'un code et à attraper les exceptions qui se produisent lorsque de telles hypothèses se révèlent fausses. C'est un style propre et rapide, caractérisé par la présence de nombreuses instructions try et except. Cette technique contraste avec le style LBYL, courant dans d'autres langages comme le C.

expression (expression) [cf. chapitre 2.3Notion d'expression]

  • Fragment de syntaxe qui peut être évalué. Autrement dit, une expression est une accumulation d'éléments d'expression comme des littéraux, des noms, des accès aux attributs, des opérateurs ou des appels à des fonctions retournant une valeur. À l'inverse de beaucoup d'autres langages, toutes les constructions de Python ne sont pas des expressions. Les instructions ne peuvent pas être utilisées comme des expressions (par exemple if). Les affectations sont aussi des instructions, pas des expressions.

extension module (module d'extension)

  • Module écrit en C ou en C++, utilisant l'API C de Python, qui interagit avec le cœur du langage et avec le code de l'utilisateur.

finder

  • Objet qui essaye de trouver le loader (chargeur) d'un module. Il doit implémenter une méthode nommée find_module(). Voir la PEP 302 pour des détails et importlib.abc.Finder pour une classe de base abstraite.

floor division (division entière) [cf. chapitre 2.4.1Le type int]

  • Division mathématique qui laisse tomber le reste. L'opérateur de division entière est //. Par exemple, l'expression 11//4 est évaluée à 2, par opposition à la division flottante qui retourne 2.75.

function (fonction) [cf. chapitre 5.1Définition et syntaxe]

  • Suite d'instructions qui retourne une valeur à l'appelant. On peut lui passer zéro ou plusieurs arguments qui peuvent être utilisés dans le corps de la fonction. Voir aussi argument et method.

__future__

  • Un pseudomodule que les programmeurs peuvent utiliser pour permettre les nouvelles fonctionnalités du langage qui ne sont pas compatibles avec l'interpréteur couramment employé.
    En important __future__ et en évaluant ses variables, vous pouvez voir à quel moment une caractéristique nouvelle a été ajoutée au langage et quand elle est devenue la fonctionnalité par défaut :
 
Sélectionnez
>>> import __future__
>>> __future__.division
_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

garbage collection (gestion automatique de la mémoire)

  • Processus de libération de la mémoire quand elle n'est plus utilisée. Python exécute cette gestion en comptant les références et en détectant et en cassant les références cycliques.

generator (fonction générateur) [cf. chapitre 9.1.8Les générateurs et les expressions génératrices]

  • Une fonction qui renvoie un itérateur. Elle ressemble à une fonction normale, excepté que la valeur de la fonction est rendue à l'appelant en utilisant une instruction yield au lieu d'une instruction return. Les fonctions générateurs contiennent souvent une ou plusieurs boucles for ou while qui « cèdent » des éléments à l'appelant. L'exécution de la fonction est stoppée au niveau du mot clé yield, en renvoyant un résultat, et elle est reprise lorsque l'élément suivant est requis par un appel de la méthode next() de l'itérateur.

generator expression (expression générateur) [cf. chapitre 9-1-8-bLes expressions génératrices]

  • Une expression qui renvoie un générateur. Elle ressemble à une expression normale suivie d'une expression for définissant une variable de contrôle, un intervalle et une expression if facultative.
    Toute cette expression combinée produit des valeurs pour une fonction englobante :
 
Sélectionnez
>>> sum(i*i for i in range(10)) # somme des carrés 0+1+4+ ... 81 = 285
285

GIL

  • cf. global interpreter lock.

global interpreter lock (verrou global de l'interpréteur)

  • Le verrou utilisé par les threads Python pour assurer qu'un seul thread tourne dans la machine virtuelle CPython à un instant donné. Il simplifie Python en garantissant que deux processus ne peuvent pas accéder en même temps à une même mémoire. Bloquer l'interpréteur tout entier lui permet d'être multithread aux frais du parallélisme du système environnant. Des efforts ont été faits par le passé pour créer un interpréteur free-threaded (où les données partagées sont verrouillées avec une granularité fine), mais les performances des programmes en souffraient considérablement, y compris dans le cas des programmes monothread.

hashable (hachable)

  • Un objet est hachable s'il a une valeur de hachage constante au cours de sa vie (il a besoin d'une méthode __hash__()) et s'il peut être comparé à d'autres objets (il a besoin d'une méthode __eq__()).
    Les objets hachables comparés égaux doivent avoir la même valeur de hachage.
    L'« hachabilité » rend un objet propre à être utilisé en tant que clé d'un dictionnaire ou membre d'un ensemble (set), car ces structures de données utilisent la valeur de hachage de façon interne.
    Tous les objets de base Python non modifiables (immutable) sont hachables, alors que certains conteneurs comme les listes ou les dictionnaires sont modifiables. Les objets instances des classes définies par l'utilisateur sont hachables par défaut ; ils sont tous inégaux (différents) et leur valeur de hachage est leur id().

IDLE [cf. chapitre 8.3.3IDLE, un exemple avec menu]

  • Un environnement de développement intégré pour Python. IDLE est un éditeur basique et un environnement d'interprétation ; il est donné avec la distribution standard de Python. Excellent pour les débutants, il peut aussi servir d'exemple pas trop sophistiqué pour tous ceux qui doivent implémenter une application avec interface utilisateur graphique multiplate-forme.

immutable (immuable) [cf. p. 11]

  • Un objet avec une valeur fixe. Par exemple, les nombres, les chaînes, les tuples. De tels objets ne peuvent pas être altérés ; pour changer de valeur, un nouvel objet doit être créé. Les objets immuables jouent un rôle important aux endroits où une valeur de hash constante est requise, par exemple pour les clés des dictionnaires.

importer [cf. chapitre 6.1.1Import]

  • Objet qui à la fois trouve et charge un module. C'est à la fois un objet finder et un objet loader.

interactive (interactif) [cf. chapitre 2.1.1Les deux modes d'exécution d'un code Python]

  • Python possède un interpréteur interactif, ce qui signifie que vous pouvez essayer vos idées et voir immédiatement les résultats. Il suffit de lancer python sans argument (éventuellement en le sélectionnant dans un certain menu principal de votre ordinateur). C'est vraiment un moyen puissant pour tester les idées nouvelles ou pour inspecter les modules et les paquetages (pensez à help(x)).

interpreted (interprété) [cf. chapitre 1.4.1Deux techniques de production des programmes]

  • Python est un langage interprété, par opposition aux langages compilés, bien que cette distinction puisse être floue à cause de la présence du compilateur de bytecode. Cela signifie que les fichiers source peuvent être directement exécutés sans avoir besoin de créer préalablement un fichier binaire exécuté ensuite. Typiquement, les langages interprétés ont un cycle de développement et de mise au point plus court que les langages compilés, mais leurs programmes s'exécutent plus lentement. Voir aussi interactive.

iterable (itérable) [cf. chapitre 3.3Boucles]

  • Un objet conteneur capable de renvoyer ses membres un par un. Des exemples d'iterable sont les types séquences (comme les list, les str, et les tuple) et quelques types qui ne sont pas des séquences, comme les objets dict, les objets file et les objets de n'importe quelle classe que vous définissez avec une méthode __iter__() ou une méthode __getitem__(). Les iterables peuvent être utilisés dans les boucles for et dans beaucoup d'autres endroits où une séquence est requise (zip(), map()…). Lorsqu'un objet iterable est passé comme argument à la fonction incorporée iter() il renvoie un itérateur. Cet itérateur est un bon moyen pour effectuer un parcours d'un ensemble de valeurs. Lorsqu'on utilise des iterables, il n'est généralement pas nécessaire d'appeler la fonction iter() ni de manipuler directement les valeurs en question. L'instruction for fait cela automatiquement pour vous, en créant une variable temporaire sans nom pour gérer l'itérateur pendant la durée de l'itération. Voir aussi iterator, sequence, et generator.

iterator (itérateur)

  • Un objet représentant un flot de données. Des appels répétés à la méthode __next__() de l'itérateur (ou à la fonction de base next()) renvoient des éléments successifs du flot. Lorsqu'il n'y a plus de données disponibles dans le flot, une exception StopIteration est lancée. À ce moment-là, l'objet itérateur est épuisé et tout appel ultérieur de la méthode next() ne fait que lancer encore une exception StopIteration. Les itérateurs doivent avoir une méthode __iter__() qui renvoie l'objet itérateur lui-même. Ainsi un itérateur est itératif et peut être utilisé dans beaucoup d'endroits où les iterables sont acceptés ; une exception notable est un code qui tenterait des itérations multiples.
    Un objet conteneur (comme un objet list) produit un nouvel itérateur à chaque fois qu'il est passé à la fonction iter() ou bien utilisé dans une boucle for. Si on fait cela avec un itérateur on ne récupérera que le même itérateur épuisé utilisé dans le parcours précédent, ce qui fera apparaître le conteneur comme s'il était vide.

keyword argument (argument avec valeur par défaut) [cf. chapitre 5.2.5Paramètres avec valeur par défaut]

  • Argument précédé par variable_name= dans l'appel. Le nom de la variable désigne le nom local dans la fonction auquel la valeur est affectée. ** est utilisé pour accepter ou passer un dictionnaire d'arguments avec ses valeurs. Voir argument.

lambda [cf. chapitre 9.3.1Directive lambda]

  • Fonction anonyme en ligne ne comprenant qu'une unique expression évaluée à l'appel. Syntaxe de création d'une fonction lambda :
 
Sélectionnez
lambda[arguments]: expression

LBYL (Look before you leap ou « regarder avant d'y aller »)

  • Ce style de code teste explicitement les préconditions avant d'effectuer un appel ou une recherche.
    Ce style s'oppose à l'approche EAFP et est caractérisé par la présence de nombreuses instructions if.

list (liste) [cf. chapitre 4.2Listes]

  • Séquence Python de base. En dépit de son nom, elle ressemble plus au tableau d'autres langages qu'à une liste chaînée puisque l'accès à ses éléments est en O(1).

list comprehension (liste en compréhension) [cf. chapitre 9.1.5Les listes définies en compréhension]

  • Une manière compacte d'effectuer un traitement sur un sous-ensemble d'éléments d'une séquence en renvoyant une liste avec les résultats. Par exemple :
 
Sélectionnez
result = ["0x x" % x for x in range(256) if x % 2 == 0]

engendre une liste de chaînes contenant les écritures hexadécimales des nombres pairs de l'intervalle de 0 à 255. La clause if est facultative. Si elle est omise, tous les éléments de l'intervalle range(256) seront traités.

loader (chargeur)

  • Objet qui charge un module. Il doit posséder une méthode load_module(). un loader est typiquement fourni par un finder. Voir la PEP 302 pour les détails et voir importlib.abc.Loader pour une classe de base abstraite.

mapping (liste associative) [cf. chapitre 4.5Tableaux associatifs]

  • Un objet conteneur (comme dict) qui supporte les recherches par des clés arbitraires en utilisant la méthode spéciale __getitem__().

metaclass

  • La classe d'une classe. La définition d'une classe crée un nom de classe, un dictionnaire et une liste de classes de base. La métaclasse est responsable de la création de la classe à partir de ces trois éléments. Beaucoup de langages de programmation orientés objets fournissent une implémentation par défaut. Une originalité de Python est qu'il est possible de créer des métaclasses personnalisées. Beaucoup d'utilisateurs n'auront jamais besoin de cela, mais, lorsque le besoin apparaît, les métaclasses fournissent des solutions puissantes et élégantes. Elles sont utilisées pour enregistrer les accès aux attributs, pour ajouter des threads sécurisés, pour détecter la création d'objets, pour implémenter des singletons et pour bien d'autres tâches.
    Plus d'informations peuvent être trouvées dans Customizing class creation.

method (méthode) [cf. chapitre 7.3Méthodes]

  • Fonction définie dans le corps d'une classe. Appelée comme un attribut d'une instance de classe, la méthode prend l'instance d'objet en tant que premier argument (habituellement nommé self).
    Voir function et nested scope.

mutable (modifiable)

  • Les objets modifiables peuvent changer leur valeur tout en conservant leur id() . Voir aussi immutable.

named tuple (tuple nommé) [cf. chapitre 6.2.4Algorithmes et types de données collection]

  • Toute classe de pseudotuples dont les éléments indexables sont également accessibles par des attributs nommés (par exemple time.localtime() retourne un objet pseudotuple où l'année est accessible soit par un index comme t[0] soit par un attribut nommé comme t.tm_year.
    Un tuple nommé peut être un type de base comme time.struct_time ou il peut être créé par une définition de classe ordinaire. Un tuple nommé peut aussi être créé par la fonction fabrique collections.nametuple(). Cette dernière approche fournit automatiquement des caractéristiques supplémentaires comme une représentation autodocumentée, par exemple :
 
Sélectionnez
>>> Employee(name='jones', title='programmer')

namespace (espace de noms) [cf. chapitre 5.3Espaces de noms]

  • L'endroit où une variable est conservée. Les espaces de noms sont implémentés comme des dictionnaires. Il y a des espaces de noms locaux, globaux et intégrés et également imbriqués dans les objets. Les espaces de noms contribuent à la modularité en prévenant les conflits de noms. Par exemple, les fonctions __builtin__.open() et os.open() se distinguent par leur espace de noms. Les espaces de noms contribuent aussi à la lisibilité et la maintenabilité en clarifiant quel module implémente une fonction. Par exemple, en écrivant random.seed() ou itertools.izip() on rend évident que ces fonctions sont implémentées dans les modules random et itertools respectivement.

nested scope (portée imbriquée) [cf. chapitre 5.3.2Résolution des noms : règle LGI]

  • La possibilité de faire référence à une variable d'une définition englobante. Par exemple, une fonction définie à l'intérieur d'une autre fonction peut faire référence à une variable de la fonction extérieure. Notez que le portées imbriquées fonctionnent uniquement pour la référence aux variables et non pour leur affectation, qui concerne toujours la portée imbriquée. Les variables locales sont lues et écrites dans la portée la plus intérieure ; les variables globales sont lues et écrites dans l'espace de noms global. L'instruction nonlocal permet d'écrire dans la portée globale.

new-style class (style de classe nouveau)

  • Vieille dénomination pour le style de programmation de classe actuellement utilisé. Dans les versions précédentes de Python, seul le style de classe nouveau pouvait bénéficier des nouvelles caractéristiques de Python, comme __slots__, les descripteurs, les propriétés, __getattribute__(), les méthodes de classe et les méthodes statiques.

object (objet) [cf. chapitre 7La Programmation Orientée Objet]

  • Toute donnée comprenant un état (attribut ou valeur) et un comportement défini (méthodes). Également la classe de base ultime du new-style class.

positional argument (argument de position)

  • Arguments affectés aux noms locaux internes à une fonction ou à une méthode, déterminés par l'ordre donné dans l'appel. La syntaxe * accepte plusieurs arguments de position ou fournit une liste de plusieurs arguments à une fonction. Voir argument.

property (propriété) [cf. chapitre 9.2.2-bLa solution property]

  • Attribut d'instance permettant d'implémenter les principes de l'encapsulation.

Python3000

  • Surnom de la version 3 de Python (forgé il y a longtemps, quand la version 3 était un projet lointain). Aussi abrégé « Py3k ».

Pythonic (pythonique)

  • Idée ou fragment de code plus proche des idiomes du langage Python que des concepts fréquemment utilisés dans d'autres langages. Par exemple, un idiome fréquent en Python est de boucler sur les éléments d'un iterable en utilisant l'instruction for. Beaucoup d'autres langages n'ont pas ce type de construction et donc les utilisateurs non familiers avec Python utilisent parfois un compteur numérique :
 
Sélectionnez
for i in range( len(food)) :
    print(food[i])

au lieu d'utiliser la méthode claire et pythonique :

 
Sélectionnez
for piece in food :
    print(piece)

reference count (nombre de références) [cf. chapitre 2.6.1Les variables]

  • Nombre de références d'un objet. Quand le nombre de références d'un objet tombe à zéro, l'objet est désalloué. Le comptage de références n'est généralement pas visible dans le code Python, mais c'est un élément clé de l'implémentation de CPython. Le module sys définit la fonction getrefcount() que les programmeurs peuvent appeler pour récupérer le nombre de références d'un objet donné.

__slots__

  • Une déclaration à l'intérieur d'une classe de style nouveau qui économise la mémoire en prédéclarant l'espace pour les attributs et en éliminant en conséquence les dictionnaires d'instance. Bien que populaire, cette technique est quelque peu difficile à mettre en place et doit être réservée aux rares cas où il y a un nombre important d'instances dans une application où la mémoire est réduite.

sequence (séquence) [cf. chapitre 4.1Séquences]

  • Un iterable qui offre un accès efficace aux éléments en utilisant des index entiers et les méthodes spéciales __getitem__() et __len__(). Des types séquences incorporés sont list, str, tuple et unicode. Notez que le type dict comporte aussi les méthodes __getitem__() et __len__(), mais est considéré comme une table associative plutôt que comme une séquence, car la recherche se fait à l'aide de clés arbitraires immuables au lieu d'index.

slice (tranche) [cf. chapitre 4.2.4Manipulation des tranches (ou sous-chaînes)]

  • Objet contenant normalement une partie d'une séquence. Une tranche est créée par une notation indexée utilisant des « : » entre les index quand plusieurs sont donnés, comme dans variable_name[1:3:5]. La notation crochet utilise les objets slice de façon interne.

special method (méthode spéciale) [cf. chapitre 7.4Méthodes spéciales]

  • Méthode appelée implicitement par Python pour exécuter une certaine opération sur un type, par exemple une addition. Ces méthodes ont des noms commençant et finissant par deux caractères soulignés. Les méthodes spéciales sont documentées dans Special method names.

statement (instruction) [cf. chapitre 3.1Instructions composées]

  • Une instruction est une partie d'une suite, d'un « bloc » de code. Une instruction est soit une expression soit une ou plusieurs constructions utilisant un mot clé comme if, while ou for.

triple-quoted string (chaîne multiligne) [cf. chapitre 2.7.1Présentation]

  • Une chaîne délimitée par trois guillemets (") ou trois apostrophes ('). Bien qu'elles ne fournissent pas de fonctionnalités différentes de celles des chaînes simplement délimitées, elles sont utiles pour nombre de raisons. Elles permettent d'inclure des guillemets ou des apostrophes non protégés et elles peuvent s'étendre sur plusieurs lignes sans utiliser de caractère de continuation, et sont donc spécialement utiles pour rédiger des chaînes de documentation.

type (type) [cf. chapitre 2.4Les types de données entiers]

  • Le type d'un objet Python détermine de quelle sorte d'objet il s'agit ; chaque objet possède un type. Le type d'un objet est accessible grâce à son attribut __class__ ou peut être retourné par la fonction type(obj).

view (vue)

  • Les objets retournés par dict.keys(), dict.values() et dict.items() sont appelés des dictionary views. ce sont des « séquences paresseuses(57) » qui laisseront voir les modifications du dictionnaire sous-jacent. Pour forcer le dictionary view à être une liste complète, utiliser list(dictview). Voir Dictionary view objects.

virtual machine (machine virtuelle) [cf. chapitre 1.4.2Technique de production de Python]

  • Ordinateur entièrement défini par un programme. La machine virtuelle Python exécute le bytecode généré par le compilateur.

Zen of Python [cf. chapitre 10.1Le Zen de Python]

  • Une liste de principes méthodologiques et philosophiques utiles pour la compréhension et l'utilisation du langage Python. Cette liste peut être obtenue en tapant import this dans l'interpréteur Python.

précédentsommairesuivant
L'évaluation paresseuse est une technique de programmation où le programme n'exécute pas de code avant que les résultats de ce code ne soient réellement nécessaires. Le terme « paresseux » (en anglais lazzy evaluation) étant connoté négativement en français on parle aussi d'évaluation « retardée ».

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2015 Kordeo. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.