Section courante

A propos

Section administrative du site

Les premiers pas

Élégant est un adjectif souvent utilisé pour décrire le langage de programmation Python. Le mot élégant est défini comme «agréablement gracieux et élégant dans son apparence ou sa manière». Simple et puissant pourraient également être de bons mots pour aider à décrire ce langage. C'est un fait que Python est un langage élégant permettant de créer des applications puissantes de manière simple. La capacité de faciliter la lecture et l'écriture de logiciels complexes est l'objectif de tous les langages de programmation, et Python fait exactement cela.

Bien que l'on a facilement défini l'objectif des langages de programmation au sens large dans le premier paragraphe, nous avons laissé de côté un avantage principal de l'apprentissage du langage de programmation Python : Python a été étendu pour fonctionner sur la plate-forme Java, et il peut donc fonctionner n'importe où avec une JVM. Il existe également des versions C et .NET (IronPython) de Python avec prise en charge multiplateforme. Python peut donc fonctionner presque partout. Dans cette page, nous nous concentrons sur Jython, l'implémentation du langage de programmation prenant l'élégance, la puissance et la facilité de Python et l'exécute sur la JVM.

La plate-forme Java est un atout pour le langage de programmation Jython, tout comme les bibliothèques C le sont pour Python. Jython peut fonctionner à peu près partout, ce qui offre une grande flexibilité au moment de décider comment implémenter une application. Non seulement la plateforme Java permet une certaine flexibilité en ce qui concerne le déploiement des applications, mais elle offre également une vaste bibliothèque contenant des milliers d'API pouvant être utilisées par Jython. Ajoutez à cela la maturité de la plateforme Java et il devient facile de comprendre pourquoi Jython est un langage de programmation si attrayant. L'objectif, si vous voulez, de tout langage de programmation est d'offrir à ses développeurs la même expérience que Jython. En termes simples, apprendre Jython sera un atout pour tout développeur.

Comme précédemment mentionné, l'implémentation du langage de programmation Jython prend Python et l'exécute sur la JVM, mais elle fait bien plus que cela. Une fois que vous aurez expérimenté la puissance de la programmation sur la plateforme Java, il sera difficile de vous en éloigner. Apprendre Jython vous permet non seulement d'exécuter sur la JVM, mais aussi d'apprendre une nouvelle façon d'exploiter la puissance de la plateforme. Le langage de programmation augmente la productivité car il possède une syntaxe facile à comprendre se lisant presque comme s'il s'agissait d'un pseudo-code. Il ajoute également des capacités dynamiques n'étant pas disponibles dans le langage de programmation Java lui-même.

Dans cette page, vous apprendrez à installer et configurer votre environnement, et vous aurez également un aperçu des fonctionnalités que le langage Python a à offrir. Cette page n'a pas pour but de vous plonger dans les concepts de syntaxe au point de vous ennuyer, mais plutôt de vous donner une introduction rapide et informative à la syntaxe afin que vous connaissiez les bases et appreniez le langage au fur et à mesure que vous avancez dans les pages. Il vous permettra également de comparer certains exemples Java avec ceux étant écrits en Python afin que vous puissiez voir certains des avantages que ce langage a à offrir.

Au moment où vous aurez terminé cette page, vous devriez connaître la structure et l'organisation de base que le code Python doit suivre. Vous saurez comment utiliser les concepts de base du langage tels que la définition de variables, l'utilisation de mots réservés et l'exécution de tâches de base. Il vous donnera un avant-goût de l'utilisation d'instructions et d'expressions. Comme tout bon programme contient des commentaires, vous apprendrez à documenter des lignes de code individuelles ainsi que des blocs de code entiers. Au fur et à mesure que vous avancerez dans les pages, vous utiliserez cette page comme référence pour les bases. Cette page ne couvrira pas toutes les fonctionnalités dans leur intégralité, mais il vous donnera suffisamment de connaissances de base pour commencer à utiliser le langage de programmation Python.

La différence entre Jython et Python

Jython est une implémentation du langage de programmation Python pour la plateforme Java. Tout au long des pages, vous apprendrez à utiliser le langage de programmation Python et on vous montrera en quoi l'implémentation Jython diffère de CPython, étant est l'implémentation canonique de Python écrite en langage de programmation C. Il est important de noter que la syntaxe du langage de programmation Python reste cohérente dans les différentes implémentations. Essentiellement, il existe 3 implémentations de Python : CPython, Jython pour la plateforme Java et IronPython pour la plateforme .NET. Par son ancienneté, le CPython est la plus répandue des implémentations. Par conséquent, si vous voyez le mot Python quelque part, il pourrait bien faire référence à cette implémentation.

Installation et configuration de Jython

Avant de nous plonger dans les bases du langage de programmation, vous devez apprendre comment obtenir Jython et le configurer pour votre environnement. Pour commencer, vous devrez obtenir une copie de Jython sur le site Web officiel www.jython.org.

L'implémentation de Jython conserve des fonctionnalités cohérentes correspondant à celles du langage de programmation Python pour chaque version. Par exemple, si vous téléchargez la version 2.2.1 de Jython, elle inclura toutes les fonctionnalités que contient la version 2.2 de Python. De même, lorsque vous utilisez la version 2.5, vous aurez accès aux mêmes fonctionnalités que celles incluses dans Python 2.5. La version 2.5 contient également des éléments supplémentaires spécifiques à Jython.

Veuillez vous procurer une copie de la version la plus récente de la version 2.5 de Jython. Vous verrez que la version est conditionnée sous forme de fichier JAR exécutable multiplateforme. Vous pouvez tout de suite voir l'avantage évident de l'exécution sur la plate-forme Java, un installateur fonctionnant pour différentes plates-formes. Pour installer le langage de programmation Jython, vous devez avoir Java 5 ou une version supérieure installée sur votre machine. Si vous n'avez pas Java 5 ou une version supérieure, vous feriez mieux d'aller le récupérer sur www.java.com et de l'installer avant d'essayer de lancer l'installateur Jython.

Vous pouvez lancer l'installateur Jython en double-cliquant simplement sur le fichier JAR. Il vous posera une série de questions d'installation standard. À un moment donné, vous devrez déterminer les fonctionnalités que vous souhaitez installer. Si vous souhaitez parcourir le code source de Jython, ou éventuellement développer du code pour le projet, vous devez choisir l'option «Tout» pour tout installer, y compris la source. Cependant, pour la plupart des développeurs Jython et en particulier pour ceux qui commencent tout juste à apprendre le langage de programmation, il est recommandé de choisir l'option d'installation «Standard». Une fois que vous avez choisi vos options et fourni un chemin d'installation, vous serez prêt à démarrer.

Pour exécuter Jython, vous devrez appeler le fichier exécutable jython.bat sur Windows ou le fichier jython.sh sur les machines Linux et Mac OS X. Cela étant dit, vous devrez parcourir le répertoire dans lequel vous avez installé Jython où vous trouverez le fichier. Il serait préférable de placer ce répertoire dans votre variable d'environnement PATH sur les machines Windows, Linux ou Mac OS X afin de pouvoir lancer Jython à partir de n'importe quel répertoire de votre machine. Une fois que vous avez fait cela, vous devriez pouvoir ouvrir un terminal ou un prompt de commande et taper «jython» puis appuyer sur Enter pour appeler l'interpréteur interactif. L'interpréteur interactif Jython est un excellent moyen d'évaluer le code et d'apprendre le langage de programmation. Il s'agit d'un environnement de test en temps réel qui vous permet de saisir du code et de voir instantanément le résultat.

Identificateurs et déclaration de variables

Chaque langage de programmation doit contenir la capacité de capturer ou de calculer des valeurs et de les entreposer. Python ne fait pas exception, et cela est assez facile. La définition de variables en Python est très similaire à celle d'autres langages de programmation tels que Java, mais il existe quelques différences que vous devez noter.

Pour définir une variable dans le langage de programmation Python, il suffit de la nommer à l'aide d'un identificateur. Un identificateur est un nom utilisé pour identifier un objet. Le langage de programmation traite le nom de la variable comme une étiquette pointant vers une valeur. Il ne donne aucun type pour la valeur. Par conséquent, cela permet à n'importe quelle variable de contenir n'importe quel type de données. Cela permet également d'avoir une variable contenant différents types de données tout au long du cycle de vie d'un programme. Ainsi, une variable à laquelle est initialement attribué un entier peut ensuite contenir une chaîne de caractères. Les identificateurs en Python peuvent être constitués de n'importe quel ordre de lettres, de chiffres ou de traits de soulignement. Cependant, un identifiant doit toujours commencer par une valeur de caractère non numérique. Vous pouvez utiliser des identificateurs pour nommer n'importe quel type de variable, de bloc ou d'objet en Python. Comme dans la plupart des autres langages de programmation, une fois qu'un identificateur est défini, il peut être référencé ailleurs dans le programme.

Une fois déclarée, une variable n'est pas typée et peut prendre n'importe quelle valeur. C'est l'une des différences entre l'utilisation d'un langage typé statiquement comme Java et l'utilisation de langages dynamiques comme Python. En Java, vous devez déclarer le type de variable que vous créez, ce qui n'est pas le cas en Python. Cela peut sembler peu de chose au premier abord, mais cette capacité peut conduire à des résultats extraordinaires. Considérons les deux listes suivantes, définissons une valeur «x» ci-dessous et donnons-lui une valeur de zéro.

Voici un exemple d'une déclaration de variable en Java :

  1. int x = 0;

Voici un exemple d'une déclaration de variable en Python :

  1. x = 0

Comme vous pouvez le constater, nous n'avons pas eu à donner de type à cette variable. Nous avons simplement choisi un nom et lui avons attribué une valeur. Comme nous n'avons pas besoin de déclarer de type pour la variable, nous pouvons la modifier en une valeur et un type différents plus tard dans le programme.

  1. x = 'Bonjour Jython'

Vous verrez que changer la valeur de la variable «x» d'une valeur numérique à une chaîne de caractères est sans aucune conséquence. Ce qui s'est réellement passé, c'est que nous avons créé une nouvelle variable «Bonjour Jython» et que nous l'avons affectée à l'identificateur «x», qui à son tour a perdu sa référence à 0. C'est une clef de la philosophie du langage dynamique, le changement ne devrait pas être difficile.

Prenons ce que nous savons jusqu'à présent et appliquons-le à quelques calculs simples. Sur la base de la définition d'une variable en Python, nous pouvons attribuer une valeur entière à une variable et la changer en valeur flottante ultérieurement. Par exemple :

>>> x = 6
>>> y = 3.14
>>> x = x * y
>>> print x

Dans l'exemple précédent, nous avons démontré que nous pouvons modifier dynamiquement le type de n'importe quelle variable donnée en effectuant simplement un calcul sur celle-ci. Dans d'autres langages de programmation tels que Java, nous aurions dû commencer par attribuer un type float à la variable «x» afin de pouvoir ensuite changer sa valeur en float. Pas ici, Jython tout comme Python, nous permet de contourner la restriction de type et nous donne un moyen simple de le faire.

Les mots réservés

Il existe quelques règles supplémentaires pour créer des identifiants que nous devons suivre afin de respecter la norme du langage de programmation Jython. Certains mots ne doivent pas être utilisés comme identificateurs car le langage de programmation Jython, tous comme le langage de programmation Python, les réserve pour jouer un rôle spécifique dans nos programmes. Ces mots qui ne peuvent pas être utilisés sont connus sous le nom de mots réservés. Si nous essayons d'utiliser l'un de ces mots réservés comme identificateur, nous verrons une SyntaxError générée car Jython veut que ces mots réservés soient les siens.

Aucun symbole n'est autorisé dans les identificateurs. Oui, cela signifie que les développeurs Perl devront s'habituer à définir des variables sans le $.

Le tableau suivant répertorie tous les mots réservés du langage de programmationJython :

Il est important de faire attention lors de la dénomination des variables afin de ne pas choisir un nom correspondant à l'un des noms de module de la bibliothèque standard.

Structure de codage

Un autre facteur clef différenciant Jython et Python des autres langages de programmation est sa structure de codage. Dans les années 1980 à 1990, nous devions développer des programmes basés sur une structure très stricte, de sorte que certains éléments devaient commencer et se terminer par certaines ponctuations. Jython, tout comme Python, utilise l'indentation plutôt que la ponctuation pour définir la structure du code. Contrairement à des langages de programmation tels que Java utilisant des crochets pour ouvrir ou fermer un bloc de code, Jython, tout comme Python, utilise l'espacement pour rendre le code plus facile à lire et également limiter les symboles inutiles dans votre code. Il applique strictement le code ordonné et organisé, mais il permet au programmeur de définir les règles d'indentation, bien qu'une norme de quatre caractères existe.

Par exemple, passons à une simple instruction «if». Bien que vous ne soyez peut-être pas encore familier avec cette construction, nous pensons que vous conviendrez qu'il est facile de déterminer le résultat. Jetez d'abord un oeil au bloc de code suivant écrit en Java, puis nous le comparerons à l'équivalent Jython.

  1. x = 100;
  2. if (x > 0) {
  3.     System.out.println("C'est du Java");
  4. } else {
  5.     System.out.println("Java aime les accolades");
  6. }

Maintenant, regardons un bloc de code similaire écrit en Jython :

  1. x = 100
  2. if x > 0:
  3.     print 'Du Jython'
  4. else:
  5.     print 'La simplicité'

C'est un peu ringard, mais nous allons quand même le passer en revue car cela démontre quelques points clefs du langage de programmation Jython. Comme vous le voyez, le programme Jython évalue si la valeur de la variable «x» est supérieure à zéro. Si c'est le cas, il affichera «Du Jython». Sinon, il affichera «La simplicité». Regardez l'indentation utilisée dans le bloc «if». Ce bloc de code particulier utilise quatre espaces pour indenter l'instruction «print» à partir de la ligne initiale du bloc. De même, le «else» revient au premier espace de la ligne et son implémentation correspondante est également indentée de quatre espaces. Cette technique doit être respectée tout au long d'une application Jython. Ce faisant, nous obtenons deux avantages majeurs : un code facile à lire et pas besoin d'utiliser des accolades. La plupart des autres langages de programmation tels que Java utilisent un crochet «[», une accolade «{» ou le mot réservé BEGIN pour ouvrir et fermer un bloc de code. Il n'est pas nécessaire de le faire lorsque vous utilisez Jython, car l'espacement s'en charge pour vous. Moins de code = plus facile à lire et à maintenir. Il convient également de noter que le code Java de l'exemple aurait pu être écrit sur une seule ligne, ou pire, mais nous avons choisi de le formater correctement.

Jython garantit que chaque bloc de code adhère à sa stratégie d'espacement définie de manière cohérente. Quelle est la stratégie d'espacement définie ? C'est vous qui décidez. Tant que la première ligne d'un bloc de code est décalée d'au moins un espace, le reste du bloc peut conserver une indentation cohérente, ce qui rend le code facile à lire. Beaucoup soutiennent que c'est la technique de structuration à laquelle Jython adhère qui les rend si faciles à lire. Il ne fait aucun doute que le respect d'un espacement standard dans toute une application facilite l'organisation. Comme mentionné précédemment, la technique d'espacement standard de Jython, tout comme Python, consiste à utiliser quatre caractères pour l'indentation. Si vous respectez ces normes, votre code sera facile à lire et à maintenir à l'avenir. Votre cerveau semble programmé pour adhérer à une certaine forme d'indentation, donc Jython et votre cerveau sont connectés de la même manière.

Les opérateurs

Les opérateurs utilisés par Jython sont très similaires à ceux utilisés dans d'autres langages, simples et faciles à utiliser. Comme dans tout autre langage de programmation, vous disposez de vos opérateurs habituels tels que +, -, * et /, étant disponibles pour effectuer des calculs. Comme vous pouvez le constater à partir des exemples suivants, il n'existe aucune astuce particulière pour utiliser l'un de ces opérateurs.

Exécution d'opérations basées sur des entiers :

>>> x = 9
>>> y = 2
>>> x + y
11
>>> x - y
7
>>> x * y
18
>>> x / y
4

Le point le plus important à noter avec les calculs est peut-être que si vous effectuez des calculs basés sur des valeurs entières, vous obtiendrez un résultat arrondi. Si vous effectuez des calculs basés sur des nombres flottants, vous obtiendrez des résultats flottants, et ainsi de suite.

Voici l'exécution d'opérations basées sur des nombres flottants :

>>> x = 9.0
>>> y = 2.0
>>> x + y
11.0
>>> x - y
7.0
>>> x * y
18.0
>>> x / y
4.5

Il est important de noter cette distinction car, comme vous pouvez le voir à partir des différences dans les résultats des opérations de division (/) dans les deux exemples de prompt Jython précédent, nous avons un arrondi sur les valeurs entières et non sur les valeurs flottantes. Une bonne règle de base est que si votre application nécessite la définition de calculs précis, il est préférable d'utiliser des valeurs flottantes pour toutes vos variables numériques, sinon vous rencontrerez un problème d'arrondi. Dans Python 2.5 et les versions antérieures, la division entière arrondit toujours vers le bas, produisant le plancher comme résultat. Dans Python 2.2, l'opérateur // a été introduit, étant un autre moyen d'obtenir le résultat du plancher lors de la division d'entiers ou de flottants. Cet opérateur a été introduit comme moyen de transition pour modifier la division entière dans les versions futures afin que le résultat soit une véritable division.

Les expressions

Les expressions sont exactement ce qu'elles semblent être. Il s'agit d'un morceau de code Python pouvant être évalué et produit une valeur. Les expressions ne sont pas des instructions à l'interprète, mais plutôt une combinaison de valeurs et d'opérateurs étant évalués. Si nous souhaitons effectuer un calcul basé sur deux variables ou valeurs numériques, nous produisons une expression.

Voici des exemples d'expressions :

>>> x + y
>>> x - y
>>> x * y
>>> x / y

Les exemples d'expressions présentés ci-dessus sont très simplistes. Les expressions peuvent être rendues très complexes et effectuer des calculs puissants. Elles peuvent être combinées pour produire des résultats complexes.

Les fonctions

Il est souvent intéressant de prendre des suites de code exécutant des tâches spécifiques et de les extraire dans leur propre unité de fonctionnalité afin que le code puisse être réutilisé à de nombreux endroits sans avoir à le retaper à chaque fois. Une façon courante de définir un morceau de code réutilisable est de créer une fonction. Les fonctions sont des portions nommées de code qui exécutent généralement une ou plusieurs tâches et renvoient une valeur. Pour définir une fonction, nous utilisons l'instruction def.

L'instruction def deviendra une seconde nature pour l'utilisation tout au long de la vie de tout programmeur Jython. L'instruction def est utilisée pour définir une fonction. Voici un simple morceau de pseudo-code montrant comment l'utiliser :

  1. def mon_nom_de_fonction(liste_de_parametre):
  2.     implementation

Le pseudo-code ci-dessus montre comment utiliser l'instruction def et comment construire une fonction simple. Comme vous pouvez le voir, def précède le nom de la fonction et la liste des paramètres lors de la définition d'une fonction.

>>> def ma_simple_fonction():
... print 'Simple fonction'
...
>>> ma_simple_fonction()

Il s'agit d'une fonction vraiment simple.

Cet exemple concerne la forme de fonction la plus simple puissant être créée. Comme vous pouvez le voir, la fonction contient une ligne de code étant une instruction print. Dans ce cas, nous affichons un message simple chaque fois que la fonction est appelée.

Les fonctions peuvent accepter des paramètres, ou d'autres variables de programme, pouvant être utilisés dans le contexte de la fonction pour effectuer une tâche et renvoyer une valeur.

>>> def multiplier_nombres(x, y):
... return x * y
...
>>> multiplier_nombres(25, 7)
175

Comme nous l'avons vu ci-dessus, les paramètres sont simplement des variables étant affectées lorsque la fonction est appelée. Plus précisément, nous affectons 25 à x et 7 à y dans l'exemple. La fonction prend ensuite x et y, effectue un calcul et renvoie le résultat.

Les fonctions en Jython, tous comme Python, sont comme d'autres variables et peuvent être transmises en tant que paramètres à d'autres fonctions si nécessaire. Nous montrons ici un exemple de base de transmission d'une fonction à une autre fonction. Nous allons transmettre la fonction multiplier_nombres à la fonction ci-dessous, puis l'utiliser pour effectuer certains calculs.

>>> def effectuer_math(oper):
... return oper(5, 6)
...
>>> effectuer_math(multiplier_nombres)
30

Bien que cet exemple soit très simple, vous pouvez voir qu'une autre fonction peut être passée en tant que paramètre puis utilisée dans une autre fonction.

Les classes

Le Jython, tout comme Python, est un langage de programmation orienté objet. ce qui signifie que tout dans le langage est un objet d'un certain type. Tout comme les blocs de construction sont utilisés pour construire des bâtiments, chaque objet en Jython peut être assemblé pour construire des morceaux de programmes ou des programmes entiers. Cette section vous donnera une brève introduction aux classes Jython, étant l'une des clefs de l'orientation objet dans ce langage de programmation.

Les classes sont définies à l'aide du mot-clef class. Les classes peuvent contenir des fonctions, des méthodes et des variables. Les méthodes sont comme des fonctions dans le sens où le mot-clef def est utilisé pour les créer et elles acceptent des paramètres. La seule différence est que les méthodes prennent un paramètre appelé self faisant référence à l'objet auquel appartient la méthode. Les classes contiennent ce que l'on appelle une méthode d'initialisation, et elle est appelée automatiquement lorsqu'une classe est instanciée. Prenons un exemple simple et expliquons-le :

>>> class mon_objet:
...     def __init__(self, x, y):
...         self.x = x
...         self.y = y
...
...     def mult(self):
...         print self.x * self.y
...
...     def add(self):
...         print self.x + self.y
...
>>> obj1 = mon_objet(7, 8)
>>> obj1.mult()
56
>>> obj1.add()
15

Dans cet exemple de classe, nous définissons une classe nommée mon_objet. La classe accepte deux paramètres, x et y. Une méthode d'initialisation de classe est nommée __init__() et est utilisée pour initialiser toutes les valeurs pouvant être utilisées dans la classe. Un initialiseur définit également les valeurs pouvant être transmises à une classe afin de créer un objet. Vous pouvez voir que chaque méthode et fonction de la classe accepte le paramètre self. Le paramètre self est utilisé pour faire référence à l'objet lui-même, c'est ainsi que la classe partage des variables et autres. Le mot-clef self est similaire à celui-ci dans le code Java. Les variables x et y de l'exemple sont nommées self.x et self.y dans l'initialiseur, ce qui signifie qu'elles seront disponibles pour une utilisation dans toute la classe. Lorsque vous travaillez avec du code dans l'objet, vous pouvez faire référence à ces variables comme self.x et self.y. Si vous créez l'objet et lui attribuez un nom tel que obj1, vous pouvez faire référence à ces mêmes variables comme obj1.x et obj1.y.

Comme vous pouvez le voir, la classe est appelée en lui passant les valeurs 7 et 8. Ces valeurs sont ensuite attribuées à x et y dans la méthode d'initialisation de classe. Nous attribuons l'objet de classe à un identifiant que nous appelons obj1. L'identifiant obj1 contient désormais une référence à mon_objet() avec les valeurs que nous lui avons transmises. L'identificateur obj1 peut désormais être utilisé pour appeler des méthodes et des fonctions définies dans la classe.

Les instructions

Lorsque nous faisons référence à des instructions, nous faisons en réalité référence à une ligne de code contenant une instruction faisant quelque chose. Une instruction indique à l'interpréteur Jython d'effectuer une tâche. En fin de compte, les programmes sont constitués d'une combinaison d'expressions et d'instructions. Dans cette section, nous allons faire le tour des mots-clefs d'instruction et apprendre comment ils peuvent être utilisés.

Commençons par lister chacun de ces différents mots-clefs d'instruction, puis nous entrerons plus en détail sur la façon d'utiliser chacun d'eux avec différents exemples.

Les mots clefs d'instruction

Maintenant que nous avons examiné chacun de ces mots-clefs, il est temps de les examiner en détail. Il est important de se rappeler que vous ne pouvez utiliser aucun de ces mots-clefs pour les noms de variables.

Instruction if-elif-else

L'instruction if effectue simplement une évaluation sur une expression et fait différentes choses selon qu'elle est vraie ou fausse. Si l'expression est évaluée à True, un ensemble d'instructions sera exécuté, et si elle est évaluée à False, un autre ensemble d'instructions sera exécuté. Les instructions if sont assez souvent utilisées pour ramifier le code dans une direction ou une autre en fonction de certaines valeurs qui ont été calculées ou fournies dans le code.

Le pseudo-code serait le suivant :

if <une expression à tester>:
    effectuer une action
else:
    effectuer une action différente

N'importe quel nombre d'instructions if/else peuvent être liées ensemble afin de créer une branche de code logique. Lorsqu'il y a plusieurs expressions à évaluer dans la même instruction, l'instruction elif peut être utilisée pour lier ces expressions ensemble*. Notez que chaque ensemble d'instructions dans une instruction *if-elif-*else doit être indenté, l'instruction conditionnelle étant en retrait et l'ensemble d'instructions résultant étant indenté. N'oubliez pas qu'une indentation cohérente doit être suivie tout au long du programme. L'instruction *if est un bon exemple de la façon dont l'utilisation cohérente de l'indentation contribue à la lisibilité d'un programme. Si vous codez en Java par exemple, vous pouvez espacer le code comme vous le souhaitez tant que vous utilisez les accolades pour encadrer l'instruction. Cela peut conduire à un code très difficile à lire, l'indentation requise par Jython transparaît vraiment ici.

Exemple d'instruction if :

>>> x = 3
>>> y = 2
>>> if x == y:
... print 'x est égal à y'
... elif x > y:
... print 'x est supérieur à y'
... else:
... print 'x est inférieur à y'
...
x est supérieur à y

Bien que le code soit simple, il démontre que l'utilisation d'une instruction if peut entraîner une logique de code de branchement.

Instruction print

L'instruction print est utilisée pour afficher la sortie du programme sur l'écran (vous l'avez déjà vue en action plusieurs fois). Elle peut être utilisée pour afficher des messages, étant affichés à partir d'un programme, et également pour afficher des valeurs, pouvant avoir été calculées. Afin d'afficher des valeurs de variables dans une instruction print, nous devons apprendre à utiliser certaines des options de formatage disponibles pour Jython. Cette section couvrira les bases de l'utilisation de l'instruction print ainsi que la façon d'afficher des valeurs en formatant vos chaînes de texte.

Dans le langage de programmation Java, nous devons faire un appel à la bibliothèque System afin d'afficher quelque chose sur la ligne de commande. En Jython, cela peut être fait avec l'utilisation de l'instruction print. L'utilisation la plus simple de l'instruction print est d'afficher une ligne de texte. Pour ce faire, il vous suffit d'entourer le texte que vous souhaitez afficher entre des guillemets simples ou doubles. Jetez un oil à l'exemple suivant écrit en Java et comparez-le à l'exemple suivant immédiatement et étant réécrit en Jython. Vous comprendrez pourquoi l'instruction print en Jython rend la vie un peu plus facile.

Voici un exemple de sortie d'affichage Java :

  1. System.out.println("Ce texte sera affiché sur la ligne de commande");

Voici un exemple de sortie d'afficher en Jython :

  1. print 'Ce texte sera afficher sur la ligne de commande'

Comme vous pouvez le constater à partir de cet exemple, l'affichage d'une ligne de texte en Jython est très simple. Nous pouvons également afficher les valeurs des variables à l'écran à l'aide de l'instruction print :

>>> ma_valeur = 'Programmer en Jython'
>>> print ma_valeur
Programmer en Jython

Encore une fois, c'est très simple en termes d'affichage des valeurs des variables. Il suffit de placer la variable dans une instruction d'affichage. Nous pouvons également utiliser cette technique pour ajouter les valeurs des variables à une ligne de texte. Pour ce faire, placez simplement l'opérateur de concaténation (+) entre la chaîne de texte à laquelle vous souhaitez ajouter du texte et la variable à laquelle vous souhaitez ajouter du texte.

>>> print 'Programmer en Java ou ' + my_value
Programmer en Java ou Programmer en Jython

C'est très bien et tout, mais vraiment pas utile si vous souhaitez formater correctement votre texte ou travailler avec des valeurs int. Après tout, l'analyseur Jython traite l'opérateur (+) comme un opérateur de concaténation dans ce cas... pas comme un opérateur d'addition. Jython base le résultat de l'opérateur (+) sur le type du premier opérande. Si vous essayez d'ajouter une valeur numérique à une chaîne de caractères, vous obtiendrez une erreur :

>>> z = 10
>>> print 'Je suis fan du numéro :' + z
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects

Comme vous pouvez le voir dans cet exemple, Jython n'aime pas beaucoup cette astuce. Donc, pour effectuer cette tâche correctement, nous devrons utiliser certaines des options de formatage Jython mentionnées ci-dessus. C'est facile et puissant à faire, et cela permet de placer n'importe quel contenu ou valeur dans une instruction d'affichage. Avant de voir un exemple, examinons certains des opérateurs de formatage et comment choisir celui dont vous avez besoin :

Format Description
%s Chaîne de caractères
%d Décimal
%f Virgule flottante

Si vous souhaitez inclure le contenu d'une variable ou le résultat d'une expression dans votre instruction d'affichage, vous utiliserez la syntaxe suivante :

  1. print 'La chaîne de caractères de texte va ici %d %s %f' % (decimalValue, stringValue, floatValue)

Dans le pseudo-code ci-dessus (si nous pouvons vraiment avoir un pseudo-code pour les instructions d'affichage), nous souhaitons afficher la chaîne de texte, étant contenue entre les guillemets simples, mais aussi avoir les valeurs des variables contenues là où se trouvent les opérateurs de formatage. Chacun des opérateurs de formatage, étant inclus dans la chaîne de texte, sera remplacé par les valeurs correspondantes de ces variables à la fin de l'instruction d'affichage. Le symbole % entre la ligne de texte et la liste des variables indique à Jython qu'il doit s'attendre à ce que les variables suivent, et que la valeur de ces variables doit être placée dans la chaîne de texte à leurs positions correspondantes.

>>> string_value = 'Bonjour le monde'
>>> float_value = 3.998
>>> decimal_value = 5
>>> print 'Voici un test de l\'instruction d\'affichage utilisant les valeurs: %d, %s, et %f' % (decimal_value, string_value, float_value)
Voici un test de l'instruction d'affichage utilisant les valeurs: 5, Bonjour le monde, et 3.998000

Comme vous pouvez le constater, cette méthode est très simple à utiliser et très flexible. L'exemple suivant montre que nous avons également la possibilité d'utiliser des expressions plutôt que des variables dans notre instruction.

>>> x = 1
>>> y = 2
>>> print 'La valeur de x + y est: %d' % (x + y)
La valeur de x + y est: 3

L'opérateur de formatage utilisé détermine l'apparence de la sortie, peu importe le type d'entrée transmis à l'opérateur. Par exemple, nous pourrions transmettre un entier ou un flottant à %s et il s'afficherait correctement, mais il serait en fait transformé en une chaîne de caractères dans son format exact. Si nous transmettons un entier ou un flottant à %d ou %f, il sera formaté correctement pour représenter respectivement une décimale ou un flottant. Jetez un oil à l'exemple suivant pour voir la sortie pour chacun des différents opérateurs de formatage :

>>> x = 2.3456
>>> print '%s' % x
2.3456
>>> print '%d' % x
2
>>> print '%f' % x
2.345600

Une autre fonctionnalité utile de l'instruction print est qu'elle peut être utilisée à des fins de débogage. Si nous avons simplement besoin de connaître la valeur d'une variable pendant le traitement, il est facile de l'afficher à l'aide de l'instruction print. L'utilisation de cette technique peut souvent être très utile pour déboguer et écrire votre code.

try-except-finally

La méthode try-except-finally est prise en charge pour effectuer la gestion des erreurs dans une application Jython. L'idée est que nous essayons d'exécuter un morceau de code et s'il échoue, il est intercepté et l'erreur est gérée de manière appropriée. Nous savons tous que si quelqu'un utilise un programme affichant un long message d'erreur laid, cela n'est généralement pas apprécié. L'utilisation de l'instruction try-except-finally pour intercepter et gérer correctement nos erreurs peut atténuer un vidage de programme laid.

Cette approche est le même concept que celui utilisé dans de nombreux langages de programmation, y compris Java. Il existe un certain nombre de types d'erreur définis dans le langage de programmation Jython et nous pouvons exploiter ces types d'erreur afin de faciliter le processus try-except-finally. Lorsqu'un des types d'erreur définis est intercepté, une suite de code peut être codée pour gérer l'erreur, ou peut simplement être enregistrée, ignorée,... L'idée principale est d'éviter ces messages d'erreur laids et de les gérer proprement en affichant un message d'erreur formaté ou en exécutant un autre processus.

>>> # Supposons que nous ayons calculé une valeur et l'avons attribuée à x
>>> x
8.97
>>> y = 0
>>> try:
...     print 'La trajectoire de la fusée est :%f' % (x/y)
... except:
...     print 'Houston, nous avons un problème.
...
Houston, nous avons un problème.

Si une exception est interceptée dans le bloc de code et que nous avons besoin d'un moyen d'effectuer certaines tâches de nettoyage, nous placerons le code de nettoyage dans la clause finally du bloc. Tout le code dans la clause finally est toujours invoqué avant que l'exception ne soit levée. Dans la section suivante, nous examinerons l'instruction raise, que nous pouvons utiliser pour lever des exceptions à tout moment dans notre programme.

Instruction raise

Comme mentionné dans la section précédente, l'instruction raise est utilisée pour lever ou «lever» une exception en Jython. Nous savons qu'une clause try-except est nécessaire si Jython décide de lever une exception, mais que faire si vous souhaitez lever votre propre exception ? Vous pouvez placer une instruction raise à n'importe quel endroit où vous souhaitez lever une exception spécifiée. Il existe un certain nombre d'exceptions définies dans le langage de programmation pouvant être levées. Par exemple, NameError est levée lorsqu'un morceau de code spécifique n'est pas défini ou n'a pas de nom.

Voici un exemple :

>>> raise NameError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError

Si vous souhaitez spécifier votre propre message dans une augmentation, vous pouvez le faire en déclenchant une exception générique, puis en spécifiant votre message sur l'instruction comme suit.

>>> raise Exception('Custom Exception')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Exception: Custom Exception

Instruction import

Un programme peut être constitué d'une ou plusieurs suites de code. Afin de sauvegarder un programme afin de pouvoir l'utiliser ultérieurement, nous plaçons le code dans des fichiers sur notre ordinateur. Les fichiers contenant du code Jython, tout comme Python, doivent contenir un suffixe .py tel que my_code.py et ainsi de suite. Ces fichiers sont connus sous le nom de modules dans le monde Python. L'instruction import est utilisée de la même manière que dans d'autres langages, elle introduit des modules ou du code externes dans un programme afin qu'il puisse être utilisé. Cette instruction est en fin de compte responsable de la réutilisation du code dans plusieurs emplacements. L'instruction import nous permet d'enregistrer du code dans un fichier plat ou un script, puis de l'utiliser ultérieurement dans une application.

Si une classe est entreposée dans un module externe portant le même nom que la classe elle-même, l'instruction import peut être utilisée pour intégrer explicitement cette classe dans une application. De même, si vous souhaitez importer uniquement un identifiant spécifique d'un autre module dans votre module actuel, le code spécifique peut être nommé à l'intérieur en utilisant la syntaxe de <<module>> import <<specific code>>. Il est temps de voir quelques exemples :

  1. # Importer un module nommé TipCalculator
  2. import TipCalculator
  3. # Importer une fonction tipCalculator depuis un module appelé ExternalModule.py
  4. from ExternalModule import tipCalculator

Lors de l'importation de modules dans votre programme, vous devez vous assurer que le module importé n'entre pas en conflit avec un autre nom dans votre programme actuel. Pour importer un module portant le même nom qu'un autre identifiant dans votre programme actuel, vous pouvez utiliser la syntaxe as. Dans l'exemple suivant, supposons que nous ayons défini un module externe portant le nom de tipCalculator.py et que nous souhaitions utiliser sa fonctionnalité dans notre programme actuel. Cependant, nous avons déjà une fonction nommée tipCalculator() dans le programme actuel. Par conséquent, nous utilisons la syntaxe as pour faire référence au module tipCalculator :

  1. import tipCalculator as tip

Cette section ne fait qu'effleurer la surface de l'importation et de l'utilisation de modules externes.

Itération

Le langage de programmation Jython possède plusieurs structures d'itération étant utilisées pour parcourir une série d'éléments dans une liste, des enregistrements de base de données ou tout autre type de collection. Une liste en Jython est un conteneur contenant des objets ou des valeurs et peut être indexé. Par exemple, nous créons une liste de nombres dans l'exemple suivant. Nous obtenons ensuite le deuxième élément de la liste en utilisant la valeur d'index de 1 (l'indexation commence à zéro, donc le premier élément de la liste est my_numbers[0]) :

>>> mes_nombres = [1, 2, 3, 4, 5]
>>> mes_nombres
[1, 2, 3, 4, 5]
>>> mes_nombres[1]
2

La structure d'itération la plus couramment utilisée dans le langage est probablement la boucle for, connue pour sa syntaxe simple et son utilisation pratique :

>>> for value in mes_nombres:
...     print value
...
1
2
3
4
5

Cependant, la boucle while joue toujours un rôle important dans l'itération, en particulier lorsque vous ne traitez pas de collections de données, mais plutôt d'expressions conditionnelles. Dans cet exemple simple, nous utilisons une boucle while pour parcourir le contenu de mes_nombres. Notez que la fonction len() renvoie simplement le nombre d'éléments contenus dans la liste.

>>> x = 0
>>> while x < len(my_numbers):
...     print my_numbers[x]
...     x = x + 1
...
1
2
3
4
5

Cette section vous guidera à travers chacune de ces deux structures d'itération et abordera les bases de leur utilisation. La boucle while est relativement basique dans son utilisation, alors qu'il existe de nombreuses implémentations et choix différents lors de l'utilisation de la boucle for.

Boucle while

La construction de boucle while est utilisée pour parcourir le code en fonction d'une instruction conditionnelle fournie. Tant que la condition est vraie, la boucle continue de s'exécuter. Une fois que la condition est évaluée à false, la boucle se termine. Le pseudo-code de la logique de boucle while se lit comme suit :

while True
    effectuer une opération

La boucle commence par la déclaration de l'expression while et conditionnelle, et se termine une fois que la condition est remplie et que l'expression est True. L'expression est vérifiée au début de chaque séquence de boucle, donc normalement une valeur contenue dans l'expression est modifiée dans la suite d'instructions à l'intérieur de la boucle. Finalement, la valeur est modifiée de telle manière qu'elle fait que l'expression est évaluée à False, sinon une boucle infinie se produirait. Gardez à l'esprit que nous devons indenter chacune des lignes de code qui existent dans la boucle while. Cela permet non seulement au code de maintenir la lisibilité, mais cela permet également à Jython de se débarrasser des accolades !

Voici un exemple d'une boucle While en Java :

  1. int x = 9;
  2. int y = 2;
  3. while (y < x) {
  4.     System.out.println("y est " + (x-y) + " inférieur à x");
  5.     y += 1;
  6. }

Voyons maintenant le même code écrit en Jython :

>>> x = 9
>>> y = 2
>>> while y < x:
...     print 'y est %d inférieur à x' % (x-y)
...     y += 1
...
y est 7 inférieur à x
y est 6 inférieur à x
y est 5 inférieur à x
y est 4 inférieur à x
y est 3 inférieur à x
y est 2 inférieur à x
y est 1 inférieur à x

Dans cet exemple, vous pouvez voir que la condition y < x est évaluée à chaque fois que la boucle passe. En cours de route, nous incrémentons la valeur de y d'une unité à chaque itération, de sorte qu'à terme, y ne soit plus inférieur à x et que la boucle se termine.

Boucle for

Nous aborderons brièvement les boucles for dans cette page, mais vous pourrez approfondir le sujet dans les chapitres deux ou trois lorsque les listes, les dictionnaires, les tuples et les plages seront abordés. Pour l'instant, vous devez savoir qu'une boucle for est utilisée pour parcourir un ensemble défini de valeurs. La boucle for est très utile pour effectuer une itération sur des valeurs, car il s'agit d'un concept utilisé dans presque toutes les applications. Par exemple, si vous récupérez une liste de valeurs de base de données, vous pouvez utiliser une boucle for pour les parcourir et afficher chacune d'elles.

Le pseudo-code de la logique de boucle for est le suivant :

for each value in ceci définie set:
    effectuer une suite d'opérations

Comme vous pouvez le voir avec le pseudo-code, j'ai indenté de la même manière que les autres constructions d'expression. Cette pratique d'indentation uniforme est cohérente dans tout le langage de programmation Jython. Nous allons comparer la boucle for en Java à la syntaxe Jython ci-dessous afin que vous puissiez voir comment cette dernière rend le code plus concis.

Exemple de boucle for en Java :

  1. for (int x = 0; x <= 10; x++) {
  2.     System.out.println(x);
  3. }

Maintenant, le même code implémenté en Jython :

>>> for x in range(10):
...     print x
...
0
1
2
3
4
5
6
7
8
9

Dans cet exemple, nous utilisons une construction n'ayant pas encore été abordée. Un intervalle est une fonction intégrée pour Jython fournissant simplement un intervalle d'une valeur particulière à une autre. Dans l'exemple, nous passons la valeur 10 dans la plage qui nous donne toutes les valeurs entre 0 et 10, y compris le zéro au début et exclusif à la fin. Nous le voyons dans l'impression résultante après l'expression.

Saisie au clavier de base

Le langage de programmation Jython dispose de quelques fonctions intégrées pour prendre la saisie au clavier afin de faciliter le processus d'écriture d'applications permettant la saisie utilisateur. À savoir, raw_input() et input() peuvent être utilisés pour demander et accepter la saisie utilisateur à partir de la ligne de commande. Non seulement cela est utile pour créer des applications et des scripts en ligne de commande, mais cela est également pratique pour écrire de petits tests dans vos applications.

La fonction raw_input() accepte la saisie au clavier et la convertit en chaîne de caractères, en supprimant le caractère de nouvelle ligne de fin. De même, la fonction input() accepte la saisie au clavier comme raw_input(), mais elle l'évalue ensuite comme une expression. La fonction input() doit être utilisée avec précaution car elle s'attend à ce qu'une expression Jython valide soit saisie. Elle génèrera une erreur SyntaxError si ce n'est pas le cas. L'utilisation de input() peut entraîner un problème de sécurité car elle permet à votre utilisateur d'exécuter du code Jython arbitraire à volonté. Il est préférable d'éviter d'utiliser input() dans la plupart des cas et de s'en tenir à l'utilisation de raw_input. Examinons l'utilisation de chacune de ces fonctions dans quelques exemples de base :

# Le texte dans la fonction est facultatif et il est utilisé comme invite à l'utilisateur
>>> name = raw_input("Entrez votre nom :")
Entrez votre nom : Sylvain
>>> print name
Sylvain
# Utilisez la fonction d'entrée pour évaluer une expression saisie par l'utilisateur
>>> val = input ('Veuillez fournir une expression :')
Veuillez fournir une expression : 9 * 3
>>> val
27
# La fonction d'entrée génère une erreur si une expression n'est pas fournie
>>> val = input ('Veuillez fournir une expression :')
Veuillez fournir une expression : Mon nom est Sylvain
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
Mon nom est Sylvain
^
SyntaxError: invalid syntax

Examinons maintenant certaines des autres instructions Python n'ayant pas encore été abordées dans cette page.

Autres instructions Jython

Il existe d'autres instructions Jython pouvant également être utilisées dans les applications, mais il est probablement préférable de les aborder dans une page ultérieur car elles offrent des fonctionnalités plus avancées. Voici une liste d'autres instructions Jython sur lesquelles vous en apprendrez davantage plus tard :

Instruction Description
exec Exécuter du code Jython de manière dynamique
global Références à une variable globale
with Nouvelle fonctionnalité dans la version 2.5 utilisant __future__
class Créer ou définir un nouvel objet de classe
yield Utilisé avec des générateurs, renvoie une valeur

Documentation du code

Documentation du code : une partie extrêmement importante de la vie de tout développeur d'applications. Bien que beaucoup d'entre nous méprisent la documentation du code, elle doit exister pour toute application allant être utilisée à des fins de production. Non seulement une documentation de code appropriée est indispensable pour la gestion et la compréhension à long terme des fragments de code Jython, mais elle joue également un rôle important dans le débogage de certains codes, comme nous le verrons dans certains exemples ci-dessous.

Parfois, nous souhaitons documenter une fonction ou une classe entière, et d'autres fois, nous souhaitons documenter seulement une ou deux lignes. Quel que soit le cas, Jython offre un moyen de le faire de manière plutôt discrète. Tout comme de nombreux autres langages de programmation existant aujourd'hui, nous pouvons commencer un commentaire sur n'importe quelle partie de n'importe quelle ligne de code. Nous pouvons également commenter sur plusieurs lignes si nous le souhaitons. Sur une note personnelle, nous aimons plutôt le symbole de documentation Jython (#) ou le dièse, car il offre une lisibilité claire. Il n'y a pas beaucoup d'endroits dans le code où vous utiliserez le symbole (#) à moins que vous n'essayiez d'effectuer une documentation. De nombreux autres langages utilisent des symboles tels que (/) pouvant rendre le code plus difficile à lire car ces symboles sont évidents dans de nombreux autres morceaux de code non documentés. Bon, il est temps de descendre de la tribune sur Jython et de passer aux choses sérieuses.

Pour documenter une ligne de code, il suffit de démarrer le document ou le commentaire avec un symbole (#). Ce symbole peut être placé n'importe où sur la ligne et tout ce qui le suit est ignoré par le compilateur Jython et traité comme un commentaire ou une documentation. Tout ce qui précède le symbole sera analysé comme prévu.

>>> # Ceci est une ligne de documentation
>>> x = 0 # Ceci est également une documentation
>>> y = 20
>>> print x + y
20

Comme vous pouvez le voir, l'analyseur Jython ignore tout ce qui se trouve après le #, ce qui nous permet de documenter ou de commenter facilement selon les besoins.

On peut facilement documenter plusieurs lignes de code en utilisant le symbole # en plaçant le dièse au début de chaque ligne. Il marque joliment un bloc particulier comme documentation. Cependant, Jython fournit également un commentaire multiligne en utilisant la désignation de guillemets triples (''') au début et à la fin d'un commentaire. Ce type de commentaire multiligne est également appelé chaîne de documentation et ne doit être utilisé qu'au début d'un module, d'une classe ou d'une fonction. Bien que les littéraux de chaîne puissent être placés ailleurs dans le code, ils ne seront pas traités comme des chaînes de documentation à moins d'être utilisés au début du code. Examinons ces deux instances de documentation multiligne dans les exemples suivant.

# Cette fonction est utilisée pour fournir le carré
# de toute valeur transmise. Le résultat sera
# renvoyé au code appelant.
def valeur_carre(value):
    return value * value
...
>>> print valeur_carre(3)
9

Plusieurs lignes de documentation **Entrées entre guillemets triples (''') :

def tip_calc(value, pct):
    ''' Cette fonction est utilisée comme calculateur de pourboire basé
        sur un pourcentage qui est transmis ainsi que la valeur du montant
        total. Dans cette fonction, le premier paramètre doit être le
        montant total d'une facture pour laquelle nous calculerons le pourboire
        en fonction du deuxième paramètre sous forme de pourcentage '''
return value * (pct * .01)
...
>>> print tip_calc(75,15)
11.25

D'accord, comme nous pouvons le voir, ces deux méthodes de documentation peuvent être utilisées pour effectuer la tâche de documentation ou de commentaire du code. Dans l'exemple suivant, nous avons utilisé plusieurs lignes de documentation commençant par le symbole # afin de documenter la fonction valeur_carre. Dans le code source suivant, nous utilisons la méthode des guillemets triples afin de couvrir plusieurs lignes de documentation. Les deux semblent fonctionner comme défini. Cependant, la deuxième option offre un objectif plus important car elle permet de documenter des blocs de code nommés spécifiques et de récupérer cette documentation en appelant la fonction help(function). Par exemple, si nous souhaitons découvrir ce que fait le code square_val, nous devons visiter le code et soit lire le commentaire multiligne, soit simplement analyser le code. Cependant, si nous souhaitons découvrir ce que fait la fonction tip_calc, nous pouvons appeler la fonction help(tip_calc) et le commentaire multiligne nous sera renvoyé. Cela fournit un excellent outil à utiliser pour découvrir ce que fait le code sans réellement visiter le code lui-même.

Voici un exemple d'affichage de la documentation de la fonction tip_calc :

>>> help(tip_calc)
Help on function tip_calc in module __main__:

tip_calc(value, pct)
    Cette fonction est utilisée comme calculateur de pourboire basé
    sur un pourcentage qui est transmis ainsi que la valeur du montant
    total. Dans cette fonction, le premier paramètre doit être le
    montant total d'une facture pour laquelle nous calculerons le pourboire
    en fonction du deuxième paramètre sous forme de pourcentage

Ces exemples et ces brèves explications devraient vous donner une assez bonne idée de la puissance de la documentation fournie par le langage de programmation Jython. Comme vous pouvez le constater, l'utilisation de la méthode des guillemets triples sur plusieurs lignes est très adaptée à la documentation des classes ou des fonctions. Les commentaires avec le symbole # constituent un excellent moyen d'organiser les commentaires dans la source et également de documenter les lignes de code pouvant être «pas si faciles» à comprendre.

Aide Jython

Obtenir de l'aide lors de l'utilisation de l'interpréteur Jython est assez simple. L'interpréteur interactif intègre une excellente option help() fournissant des informations sur tout module, mot-clef ou sujet disponible pour le langage de programmation Jython. En appelant la fonction help() sans passer le nom d'une fonction, le système d'aide Jython est appelé. Lorsque vous utilisez le système help(), vous pouvez soit utiliser l'aide interactive étant appelée dans l'interpréteur en tapant simplement help(), soit, comme nous l'avons vu précédemment, obtenir la docstring d'un objet spécifique en tapant help(object).

Il convient de noter que lorsque vous utilisez le système d'aide en mode interactif, une multitude d'informations sont disponibles à portée de main. Si vous souhaitez voir par vous-même, démarrez simplement l'interpréteur interactif Jython et tapez help(). Une fois dans l'aide interactive, vous pouvez la quitter à tout moment en tapant quit. Pour obtenir une liste de modules, de mots-clefs ou de sujets, tapez simplement «modules», «keywords» ou «topics» et vous obtiendrez une liste complète. Vous recevrez également de l'aide pour utiliser le système d'aide interactif... ou peut-être que cela devrait être appelé méta-aide !



Dernière mise à jour : Vendredi, le 20 septembre 2024