Skip to content

POO – TP4 : Interfaces graphiques avec Swing

Voici la fiche de TP N°4 de Programmation Orientée Objet de 2e année de licence informatique pour l’année 2014-2015 :

SpaceGames : Décollage de l’Astronef


SpaceGames

Billet du 26 novembre 2012.
Édité le 15 décembre 2014 pour ajouter la version Python.

Je viens de retomber sur un livre de jeux en BASIC de mon enfance qui traînait avec mes vieux bouquins. C’est avec ce genre de petits programmes recopiés de livres ou de magazines que j’ai commencé mon apprentissage de la programmation sur ZX81.

Je me suis dit qu’il pourrait être intéressant de faire revivre ces petits programmes. Les débutants en programmation sont souvent plus intéressés quand on leur propose de créer des jeux plutôt que de résoudre des problèmes mathématiques ennuyeux.

C’est pourquoi j’ai repris le premier programme de ce livre, qui est très simple et s’appelle « Décollage d’astronef ». Après avoir examiné le programme en BASIC, je l’ai réécrit en C puis en Pascal puis (2 ans après :-) en Python.

Présentation

Voici la présentation donnée dans le livre :

Décollage d’astronef

Vous êtes le commandant d’un astronef qui s’est écrasé sur une planète étrangère et vous devez repartir au plus vite dans l’engin extra-terrestre que vous venez de capturer.
L’ordinateur de bord du vaisseau vous indique la gravité de la planète. Il vous reste à deviner la poussée nécessaire au décollage. Si vous l’avez sous-estimée, le mécanisme de sécurité du vaisseau empêchera que vous ne soyez réduit en cendres. Si, après dix essais, vous êtes toujours sur la planète, les extra-terrestres vous captureront.

Elle pourra être affichée à l’utilisateur au début de l’exécution.

Organigramme

Observez l’organigramme de ce jeu :

organigramme

Simple, non ? Essayez de le programmer avant de voir la solution.

Programme en Pascal

Program Astronef ;
(* Décollage de l'Astronef
 * =======================
 * Par Amine "nh2" Brikci-N, d'après D. Isaaman et J. Tyler
 * "Jeux électroniques Spacegames pour ZX Spectrum, ZX81, BBC, TRS-80,
 * Apple, VIC et PET" éd. Hachette Jeunesse 1983.
 *)
 
Const
    GRAVITE_MAX = 20 ;
    MASSE_MAX = 40 ;
    CHANCES = 10 ;
Var
    gravite,        (* gravité de la planète *)
    masse,          (* masse du vaisseau *) 
    poids, poussee, essai : integer;
    rep   : char;

Procedure Explications;
begin
 writeln('Vous êtes commandant d''un astronef qui s''est écrasé sur  ');
 writeln('une planète étrangère et vous devez repartir au plus vite  ');
 writeln('dans l''engin extra-terrestre que vous venez de capturer.  ');
 writeln('L''ordinateur de bord du vaisseau indique la gravité de    ');
 writeln('la planète. Il vous reste à deviner la poussée nécessaire  '); 
 writeln('au décollage. Si vous l''avez sous-estimée, le mécanisme de');
 writeln('sécurité du vaisseau empêchera que vous ne soyez réduit en ');
 writeln('cendres. Si, après dix essais, vous êtes toujours sur la   '); 
 writeln('planète, les extra-terrestres vous captureront.            ');
end;

Begin
    writeln('DÉCOLLAGE DE L''ASTRONEF');
    write('Des explications [O/n] ? ');
    readln(rep);
    if not((rep='n') or (rep='N')) then Explications;
    randomize;
    gravite := random(GRAVITE_MAX)+1 ;
    masse := random(MASSE_MAX)+1 ;
    poids := masse * gravite ;
    writeln('Gravité = ',gravite);
    write('Tapez la poussée : ');
    for essai := 1 to CHANCES do
    begin
        readln(poussee);
        if poussee = poids then
        begin
            writeln('C''est bon, decollez.');
            break
        end;
        if poussee > poids then
            writeln('Trop grand !')
        else
            writeln('Trop petit !');
        if essai < CHANCES then
            write('Essayez à nouveau : ')
        else
        begin
            writeln('Vous avez echoué.');
            writeln('Les extra-terrestres vous ont eu !')
        end
    end;
    writeln('La poussée nécessaire était ', poids);
End.

Des instructions if … then … else, une boucle for, rien de bien compliqué.

Les seules instructions particulières sont celles qui utilisent la procédure système Randomize et la fonction Random. Elles sont nécessaires pour générer des nombres « au hasard » (pseudo-aléatoires). Randomize initialise le générateur avec une « graine aléatoire » donnée par l’horloge système, pour que Random(n) puisse retourner un nombre entier qui ait l’air de vraiment être tiré au hasard entre 0 et n (n non compris).

La procédure Explications est appelée si l’utilisateur le désire. Elle ne fait qu’afficher la présentation.

Programme en C

/* Décollage de l'Astronef
 * =======================
 *   
 * Par Amine "nh2" Brikci-N, d'après D. Isaaman et J. Tyler
 * "Jeux électroniques Spacegames pour ZX Spectrum, ZX81, BBC, TRS-80,
 * Apple, VIC et PET" éd. Hachette Jeunesse 1983.
 * 
 * Fichier source : astronef.c
 * Compiler avec:
 * gcc -Wall astronef.c -o astronef -std=c99
 * 
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <ctype.h>

void explications(void){
    puts("Vous êtes le commandant d'un astronef qui s'est écrasé sur ");
    puts("une planète étrangère et vous devez repartir au plus vite  ");
    puts("dans l'engin extra-terrestre que vous venez de capturer.   ");
    puts("L'ordinateur de bord du vaisseau vous indique la gravité de");
    puts("la planète. Il vous reste à deviner la poussée nécessaire  "); 
    puts("au décollage. Si vous l'avez sous-estimée, le mécanisme de ");
    puts("sécurité du vaisseau empêchera que vous ne soyez réduit en ");
    puts("cendres. Si, après dix essais, vous êtes toujours sur la   "); 
    puts("planète, les extra-terrestres vous captureront.            ");
}

#define GRAVITE_MAX 20
#define MASSE_MAX 40
#define CHANCES 10

/* rand_initialisee : indique si le générateur de nombres pseudo-
 * aléatoires été initialisé (1) ou pas (0)
 */
int rand_initialisee = 0; 

/* aleatoire : génère un nombre entier "au hasard" (pseudo-aléatoire)
 * Paramètres :
 *  -  min : valeur minimale
 *  -  max : valeur maximale
 * Si ce n'est pas encore fait, initialise le générateur de nombres
 * aléatoires et met à jour la variable globale rand_initialisee 
 */ 
int aleatoire(int min, int max){
    if (!rand_initialisee){
        srand(time(NULL)); // utilise l'horloge système pour la "graine"
        rand_initialisee = 1;
    }
    return (int) (min + (max - min) * 1.0 * rand() / RAND_MAX);
}

int main(void){
    puts("DÉCOLLAGE DE L'ASTRONEF\n");

    printf("Des explications [O/n] ? ");
    if (tolower(getchar())!='n')
        explications();

    int gravite = aleatoire(1, GRAVITE_MAX) ; // gravité de la planète
    int masse = aleatoire(1, MASSE_MAX) ;     // masse du vaisseau
    int poids = masse * gravite ;
    printf("\nGravité = %d\n", gravite);
    printf("Tapez la poussée : ");
    int poussee = 0;
    for (int essai=1 ; essai <= CHANCES && poussee != poids ; ++essai) {
        scanf("%d", &poussee);
        if (poussee > poids)
            puts("Trop grand !");
        else if (poussee < poids)
            puts("Trop petit !");
        else puts("C'est bon, décollez.");
        if (poussee != poids) {
            if (essai < CHANCES)
                printf("Essayez à nouveau : ");
            else {
                puts("Vous avez échoué.");
                puts("Les extra-terrestres vous ont eu !");
            }    
        }
    }
    printf("\nLa poussée nécessaire était %d.\n", poids);
    return EXIT_SUCCESS;
}

Là aussi, c’est simple. La boucle for du C est plus flexible ; j’en ai profité pour y mettre non seulement la condition qui teste le compteur mais aussi celle qui teste si le joueur a bien répondu. Ça évite d’utiliser l’instruction break comme je l’ai fait en Pascal.

Cette fois j’ai caché la fonction rand() (qui génère un nombre aléatoire en C) dans une fonction plus simple à utiliser. La fonction qui initialise le générateur aléatoire est srand(). Contrairement à Randomize du Pascal, elle n’utilise pas directement l’horloge, il faut lui donner la graine. Pour cela, on utilise toujours le résultat de la fonction time(), déclarée dans <time.h>, qui est le nombre de secondes passées depuis le 1er janvier 1970. N’hésitez pas à lancer les commandes man srand et man 3 time pour mieux comprendre comment cela fonctionne.

Programme en Python 3

# Décollage de l'Astronef
# =======================
# Par Amine "nh2" Brikci-N, d'après D. Isaaman et J. Tyler
# "Jeux électroniques Spacegames pour ZX Spectrum, ZX81, BBC, TRS-80,
# Apple, VIC et PET" éd. Hachette Jeunesse 1983.

# "constantes" : (pas de vraies constantes en Python)
GRAVITE_MAX = 20
MASSE_MAX = 40
CHANCES = 10

def explications():
    print("Vous êtes commandant d'un astronef qui s'est écrasé sur    ")
    print("une planète étrangère et vous devez repartir au plus vite  ")
    print("dans l'engin extra-terrestre que vous venez de capturer.   ")
    print("L'ordinateur de bord du vaisseau indique la gravité de     ")
    print("la planète. Il vous reste à deviner la poussée nécessaire  ") 
    print("au décollage. Si vous l'avez sous-estimée, le mécanisme de ")
    print("sécurité du vaisseau empêchera que vous ne soyez réduit en ")
    print("cendres. Si, après dix essais, vous êtes toujours sur la   ") 
    print("planète, les extra-terrestres vous captureront.            ")

print("DÉCOLLAGE DE L'ASTRONEF")
rep = input('Des explications [O/n] ? ')
if not((rep == 'n') or (rep == 'N')) :
    explications()
from random import randint
gravite = randint(1, GRAVITE_MAX)
masse = randint(1, MASSE_MAX)
poids = masse * gravite
print('Gravité = ', gravite)
print('Tapez la poussée : ', end = "")
for essai in range(1, CHANCES+1) :
    poussee = int(input())
    if poussee == poids :
        print("C'est bon, decollez.")
        break
    if poussee > poids :
        print('Trop grand !')
    else :
        print('Trop petit !')
    if essai < CHANCES :
        print('Essayez à nouveau : ', end = "")
    else :
        print('Vous avez echoué.')
        print('Les extra-terrestres vous ont eu !')
print('La poussée nécessaire était', poids);

La fonction randint() importée du module random permet de générer des nombres peudo-aléatoires entiers compris entre les valeurs du 1er et du 2e paramètre (tous deux inclus).

Autres langages

Javascript, PHP, etc… peut-être un autre jour…

Programme en BASIC

Voici une capture d’écran d’un émulateur de ZXSpectrum avec le programme (en anglais).

Source : WorldOfSpectrum.org

Vous pourrez remarquer qu’en Sinclair BASIC la fonction RND permet de générer un nombre pseudo-aléatoire décimal entre 0 et 1.

Programme Scratch

Voir ici

L1ST – Informatique1 : chapitre 3 (110 p)

Voici la version finale (110 diapositives) du chapitre 3 d’Informatique1 pour la 1re année de licence ST de cette année 2014-2015 :

Ce chapitre commence l’initiation à la programmation avec le langage Python3.

Complément : Lisez également l’article Python – Chaines de formatage qui contient les explications et exemples que j’ai présentés en cours (le lundi 08/10/2014).

Je vous rappelle que vous pouvez trouver de bons livres sur la programmation Python à la bibliothèque de la faculté, et notamment celui dont je vous ai parlé sur ce blog.

L1ST – Deuxième test de TP

Je rappelle aux étudiants de 1re année ST que le deuxième test de TP d’Informatique1 se fera durant la semaine du dimanche 14/12/2014.

Il concernera la programmation en Python.

L1ST – TP N°6 : Variables

Voici la fiche de TP N°6 :

Encore une fois, je vous conseille de refaire les TP chez vous et de vous entraîner régulièrement à programmer en Python. Ne vous contentez pas des séances de TP, il faut vous familiariser avec Python pour pouvoir le maîtriser suffisamment.

Essayez d’abord de résoudre les exercices par vous-même. Comprendre une solution faite par quelqu’un d’autre n’est pas suffisant pour apprendre à programmer. Il faut d’abord réfléchir au problème. Même si vous n’arrivez pas à le résoudre, en regardant la solution après y avoir réfléchi vous assimilerez mieux.

Voici la solution finale de ce TP, le programme distances.py, comparez-le avec votre solution :

from math import *

x1, x2, y1, y2 = -3, -4, 19, 27
print("x1 =", x1, " x2 =", x2, " y1 =", y1, " y2 =", y2)
d = sqrt((x1 - x2)**2 + (y1 - y2)**2)
print("dist =", d)
print()

x1, x2, y1, y2 = -2, 0, 8.5, 17
print("x1 =", x1, " x2 =", x2, " y1 =", y1, " y2 =", y2)
d = sqrt((x1 - x2)**2 + (y1 - y2)**2)
print("dist =", d)
print()

x1, x2, y1, y2 = 1, -1, 9, 7.9
print("x1 =", x1, " x2 =", x2, " y1 =", y1, " y2 =", y2)
d = sqrt((x1 - x2)**2 + (y1 - y2)**2)
print("dist =", d)
print()

x1, x2, y1, y2 = 15, 9, 7, 32
print("x1 =", x1, " x2 =", x2, " y1 =", y1, " y2 =", y2)
d = sqrt((x1 - x2)**2 + (y1 - y2)**2)
print("dist =", d)
print()

Python – Chaines de formatage

En Python, quand on veut afficher plusieurs valeurs de types différents sur une même ligne, il existe plusieurs manières de le faire.

1re méthode

On peut concaténer toutes les valeurs ensemble pour faire un seul paramètre pour la fonction print().
Rappel : La concaténation est l’opération qui consiste à « coller » des chaînes de caractères pour en former une seule. Elle se fait en Python grâce à l’opérateur +
Évidemment, avant de pouvoir concaténer les valeurs qui ne sont pas des chaînes, il faut d’abord les convertir, grâce à la fonction str.
Exemple :

print("La somme de " + str(a) + " et " + str(b) + " est " + str(a+b))

Autre façon de faire

La fonction print() accepte plusieurs paramètres (séparés par des virgules) qui peuvent être de n’importe quel type. Elle les affiche en les séparant par une espace par défaut (ou par un autre séparateur si l’on a spécifié le paramètre sep).
Exemple :

# Cet exemple montre l'intérêt du formatage
# version du 08/12/2014 (sans formatage)

# affectations
prod1, prix1 = "oeuf", 12 # nom et prix du produit N°1
prod2, prix2 = "pain", 8
prod3, prix3 = "camembert", 160
prod4, prix4 = "pistache", 1250

# affichage
print("Alimentation Générale")
print("=" * 21)
print()  # affiche une ligne vide
print(prod1, "coûte", prix1, "DA")
print(prod2, "coûte", prix2, "DA")
print(prod3, "coûte", prix3, "DA")
print(prod4, "coûte", prix4, "DA")

On remarque au passage dans cet exemple que certaines lignes contiennent le caractère #. Quand l’interpréteur Python rencontre ce caractère, il l’ignore lui et tout ce qui suit dans cette ligne, et passe directement à la ligne suivante. Ce qui suit un caractère # est un commentaire.

On remarque aussi à la ligne 13 une instruction print() sans rien entre les parenthèses. La fonction print(), quand elle est utilisée sans paramètre, sert seulement à sauter une ligne.

À l’exécution, on obtient l’affichage suivant :

Alimentation Générale
=====================

oeuf coûte 12 DA
pain coûte 8 DA
camembert coûte 160 DA
pistache coûte 1250 DA

Utilisation des chaînes de formatage

Le programme de l’exemple précédent fonctionne bien mais ne donne pas un affichage très régulier. Si l’on préfère que les prix soient alignés, il va falloir utiliser un autre moyen.
La 3e méthode proposée ici est la plus compliquée, mais aussi la plus intéressante quand on veut maîtriser l’affichage. C’est celle qui utilise les chaînes de formatage.
Une chaîne de formatage est une chaîne de caractères qui contient des codes de format aux endroits où l’on veut mettre des valeurs.
Par exemple au lieu d’utiliser une chaîne comme celle du 1er exemple :

"La somme de " + str(a) + " et " + str(b) + " est " + str(a+b)

Nous pouvons utiliser la chaîne de formatage "La somme de %d et %d est %d" qui contient le message à afficher avec des codes %d à la place des valeurs, puis on utilise l’opérateur de formatage de chaînes % (ce n’est pas le même que l’opérateur % qui permet d’obtenir le reste de la division de deux entiers, mais il s’écrit de la même façon) que l’on fait suivre de la liste des valeurs à insérer dans la chaîne. Ce qui donne :

>>> a, b = 36, 6
>>> "La somme de %d et %d est %d" % (a, b, a + b)
'La somme de 36 et 6 est 42'

(Dans un programme nous utiliserions print() pour l’affichage)
Nous avons mis le code de format %d car il sera remplacé par une valeur entière. Suivant le type de valeur que l’on veut formater, on utilise différents codes de format :

  • %d ou %i pour un entier (int)
  • %f pour un réel (float)
  • %s pour une chaîne (str)
  • etc.

Il en existe beaucoup (ce sont les mêmes que ceux du langage C) mais les plus utiles pour l’instant sont les trois ci-dessus.

Remarquons que les valeurs doivent être mises entre parenthèses et séparées par des virgules. S’il n’y en a qu’une seule les parenthèses ne sont pas obligatoires. Exemple : "Cher Monsieur %s, bonjour." % nom

Attention, si l’on ne met pas autant de codes de format qu’il y a de valeurs, on obtient un message d’erreur :

>>> "La somme de %d et %d est %d" % (a, a + b)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: not enough arguments for format string
>>> "La somme de %d et %d est " % (a, b, a + b)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: not all arguments converted during string formatting

Transformons notre programme :

# Cet exemple montre l'intérêt du formatage
# version du 08/12/2014 avec formatage

# affectations
prod1, prix1 = "oeuf", 12 # nom et prix du produit N°1
prod2, prix2 = "pain", 8
prod3, prix3 = "camembert", 160
prod4, prix4 = "pistache", 1250

# affichage
print("Alimentation Générale")
print("=" * 21)
print()  # affiche une ligne vide
print("%s coûte %d DA" % (prod1, prix1))
print("%s coûte %d DA" % (prod2, prix2))
print("%s coûte %d DA" % (prod3, prix3))
print("%s coûte %d DA" % (prod4, prix4))

Essayez-le. Pour l’instant, le résultat est exactement le même que celui de la 1re version.
Alors pourquoi s’est-on cassé la tête :-/ ?
Attendez ! Nous n’avons pas fini : l’intérêt de ce formatage de chaîne est que les codes de format sont réglables.
On veut aligner l’affichage. Pour cela, il va falloir spécifier que les noms des produits doivent occuper toujours le même nombre de caractères. C’est possible en ajoutant dans le code de format %s, entre le % et le s, ce nombre de caractères.
Comme le nombre de lettres du plus grand nom de produit est 9, changeons les lignes d’affichage ainsi :

print("%10s coûte %d DA" % (prod1, prix1))
print("%10s coûte %d DA" % (prod2, prix2))
print("%10s coûte %d DA" % (prod3, prix3))
print("%10s coûte %d DA" % (prod4, prix4))

On obtient :

      oeuf coûte 12 DA
      pain coûte 8 DA
 camembert coûte 160 DA
  pistache coûte 1250 DA

C’est beaucoup mieux, non ?
Ce que l’on a obtenu, c’est que les valeurs des noms de produits qui ne font pas 10 caractères ont été complétées à gauche par des espaces pour qu’elles en occupent 10. Ainsi, 6 espaces ont été ajoutées avant oeuf et pain, une espace avant camembert et 2 avant pistache.
Mais il reste des problèmes :

  • Les DA ne sont pas alignés. Pour cela il faudra régler le code de format des prix pour qu’ils occupent tous le même nombre de caractères, disons 5 : nous mettrons alors %5d
  • Les noms sont alignés à droite ; ce serait mieux s’ils étaient alignés à gauche. Pour cela, il suffit de changer le réglage de %s et mettre une valeur négative, c’est-à-dire : %-10s

Voici les changements à faire :

print("%-10s coûte %5d DA" % (prod1, prix1))
print("%-10s coûte %5d DA" % (prod2, prix2))
print("%-10s coûte %5d DA" % (prod3, prix3))
print("%-10s coûte %5d DA" % (prod4, prix4))

Et voici le résultat :

oeuf       coûte    12 DA
pain       coûte     8 DA
camembert  coûte   160 DA
pistache   coûte  1250 DA

C’est beaucoup plus présentable, n’est-ce pas ?

Ce n’est pas fini. Nous avons fait une petite erreur dans le programme : le pain ne coûte pas 8 DA mais 8,50 DA ! Arrangeons cela :

prod2, prix2 = "pain", 8.50

À l’exécution, on obtient :

oeuf       coûte    12 DA
pain       coûte     8 DA
camembert  coûte   160 DA
pistache   coûte  1250 DA

O_o pourquoi a-t-on obtenu la même chose ? Parce que %d permet d’afficher la valeur sous la forme d’un entier ! Il faut donc mettre %f à la place :

print("%-10s coûte %5f DA" % (prod1, prix1))
print("%-10s coûte %5f DA" % (prod2, prix2))
print("%-10s coûte %5f DA" % (prod3, prix3))
print("%-10s coûte %5f DA" % (prod4, prix4))

Cela devrait marcher maintenant :

oeuf       coûte 12.000000 DA
pain       coûte 8.500000 DA
camembert  coûte 160.000000 DA
pistache   coûte 1250.000000 DA

Mais pourquoi y a-t-il autant de zéros ??? Cela n’est pas très joli, mais c’est parce que le code de format %f donne par défaut 6 chiffres après la virgule.
Heureusement, il existe un deuxième réglage pour les codes de format %f, c’est justement le nombre de décimales. Pour le régler à 2, il suffit de mettre %5.2f :

print("%-10s coûte %5.2f DA" % (prod1, prix1))
print("%-10s coûte %5.2f DA" % (prod2, prix2))
print("%-10s coûte %5.2f DA" % (prod3, prix3))
print("%-10s coûte %5.2f DA" % (prod4, prix4))

Remarque : On peut utiliser le réglage des décimales tout seul (sans régler le nombre de caractères occupés) avec juste %.2f

Cette fois, le résultat est :

oeuf       coûte 12.00 DA
pain       coûte  8.50 DA
camembert  coûte 160.00 DA
pistache   coûte 1250.00 DA

Les deux premiers prix sont alignés mais pas les autres. C’est parce que le réglage de tout à l’heure n’est plus valide : les deux derniers prix occupent plus de 5 caractères maintenant (le plus grand prix en occupe 7), donc le réglage de la taille occupée a été ignoré pour eux (il était trop petit).

Finalement, voici la version définitive :

# Cet exemple montre l'intérêt du formatage
# version finale du 08/12/2014 avec formatage

# affectations
prod1, prix1 = "oeuf", 12 # nom et prix du produit N°1
prod2, prix2 = "pain", 8
prod3, prix3 = "camembert", 160
prod4, prix4 = "pistache", 1250

# affichage
print("Alimentation Générale")
print("=" * 21)
print()  # affiche une ligne vide
print("%-10s coûte %8.2f DA" % (prod1,prix1) )
print("%-10s coûte %8.2f DA" % (prod2,prix2) )
print("%-10s coûte %8.2f DA" % (prod3,prix3) )
print("%-10s coûte %8.2f DA" % (prod4,prix4) )

Et voici son résultat :

Alimentation Générale
=====================

oeuf       coûte    12.00 DA
pain       coûte     8.50 DA
camembert  coûte   160.00 DA
pistache   coûte  1250.00 DA

Dernière remarque :
La réduction du nombre de décimales affichées pour un réel (float) est utile pour masquer les « défauts » de ce type de valeurs.
En effet, il nous est arrivé quand nous essayions des opérations sur des réels de tomber sur des résultats imprécis. C’est parce que les valeurs de ce type sont représentées en binaire avec un certain degré d’imprécision (voir cette page du tutoriel Python pour l’explication).

Voici un exemple :

>>> somme = 0.1 + 0.2
>>> print("la somme est", somme)
la somme est 0.30000000000000004
>>> print("la somme est %.2f" % somme)
la somme est 0.30

L2inf : Architecture des ordinateurs

M. Ziani-Cherif m’a informé que le site contenant les cours, TD et TP d’Architecture des ordinateurs pour la 2e année de licence informatique 2014-2015 se trouve à l’URL suivante :

 

Suivre

Recevez les nouvelles publications par mail.

Rejoignez 51 autres abonnés