TP pygame – saisie et affichages, vers l’utf8

Question flash :

Compléter en suivant ce que disent les commentaires :

# import bibliothèque adaptée

def jeu(pseudo) :
    # calcule un aléatoire entre 12 et 36
    # affiche que le pseudo dans la variable pseudo a fait ce score
    # renvoie le score
>>> jeu("La belle au bois dormant")
La belle au bois dormant a fait 18
18
>>>

Réponse lors du chat discord :

# import bibliothèque adaptée
from random import randint

def jeu(pseudo) :
    # calcule un aléatoire entre 12 et 36
    score = randint(12, 36)
    # affiche que le pseudo dans la variable pseudo a fait ce score
    print(pseudo, "a fait", score)
    # renvoie le score
    return score

Dans le shell :

>>> jeu("Gaëtan")
Gaëtan a fait 23
23
>>>

TP pygame – saisie et affichages, vers l’utf8

Les fichiers de départ sont ici.

« gestion des scores » lors du chat discord :

import pickle

def initialise():
    # liste des scores au cas où
    return [(42, "Mr Marchant !"),(28,"Superman"),(21, "Kirsten Dunst"),(5, "Le Joker")]

def enregistre(liste):
    # Sauvegarde de la liste dans le même dossier dans un fichier
    fichier = open('scores_dump', 'wb')
    # 'wb' comme write en binaire
    pickle.dump(liste, fichier)
    fichier.close() # libérer délivrer le fichier

def charge() :
    fichier = open('scores_dump', 'rb')
    # 'rb' comme read en binaire
    liste = pickle.load(fichier)
    fichier.close() # libérer délivrer le fichier

    return liste

scores = initialise()
for truc in scores:
    print(truc[1], "\t",truc[0])
print()

scores.remove((28,"Superman"))
for truc in scores:
    print(truc[1], "\t",truc[0])

# scores.append((36, "Gaëtan !"))

print()
scores = charge()
for truc in scores:
    print(truc[1], "\t",truc[0])
# enregistre(scores)

Un fichier scores_dump est apparu dans le dossier !

On enlève la fin et le fichier « gestion_scores.py » contient :

import pickle

def initialise():
    # liste des scores au cas où
    return [(42, "Mr Marchant !"),(28,"Superman"),(21, "Kirsten Dunst"),(5, "Le Joker")]

def enregistre(liste):
    # Sauvegarde de la liste dans le même dossier dans un fichier
    fichier = open('scores_dump', 'wb')
    # 'wb' comme write en binaire
    pickle.dump(liste, fichier)
    fichier.close() # libérer délivrer le fichier

def charge() :
    fichier = open('scores_dump', 'rb')
    # 'rb' comme read en binaire
    liste = pickle.load(fichier)
    fichier.close() # libérer délivrer le fichier

    return liste

On explique que les constantes sont en MAJUSCULES comme dans le fichiers parametres.py.

Dans le fichier « tableau_des_scores.py

Les lignes ci-dessous permettent d’importer les fonctions et CONSTANTES de nos fichiers qui deviennent des « bibliothèques perso ».

Ceci permet de partager les fonctionnalités dans un binôme/trinôme !

from parametres import *
from prog_jeu import jeu
from gestion_scores import charge, enregistre, initialise

N.B. : un dossier « py_cache » est alors apparu avec nos modules « pré-interprétées »

Les trois « boulots » demandés :

« Boulot 1 »

###########################

    # BOULOT 1 -> trier les scores

    ##############################

    scores_tries = sorted(scores, reverse = True)
    # for truc in scores_tries:
    #    print(truc[1], "\t",truc[0])

« Boulot 2 »

    ordonnee = ORD_DEPART

    ####################################

    #BOULOT 2

    ###################################

    for truc in scores_tries[:5]: # les 5 premiers
        text2 = font.render(str(truc[0]), 1, BLANC)
        fenetre.blit(text2, (ABS_SCORES, ordonnee))
        text2 = font.render(truc[1], 1, BLANC)
        fenetre.blit(text2, (ABS_NOMS, ordonnee))
        ordonnee += PAS_ORD

« Boulot 3 »

            #######################################

            # BOULOT 3

            ######################################

            elif event.key == K_BACKSPACE:
                pseudo = pseudo[:-1] # enlève la dernière
            elif event.key == K_RETURN:
                # jeu de ouf
                score = jeu(pseudo)
                scores.append((score, pseudo))
            elif len(pseudo) < 18:
                pseudo += event.dict['unicode']

Codage des caractères

ASCII, la norme ancestrale mais inchangée pour les caractères dont le « point de code » est strictement inférieur à 128. La trace de ce qui a été tapé pendant la séance :

>>> ord('u') # le code de 'u' ( ord donne le code )
117                 # les minuscules de 97 à 122
>>> ord('U')        # le code de 'U' est 85
85
>>> ord('A')        # les majuscules de 'A' en 65 à ...
65
>>> ord('Z')
90                  # .... 'Z' en 90
>>> chr(65)         # chr donne le caractère correpondant à un code
'A'
>>> for i in range(32, 128) : chr(i) # avant 32 pas imprimables

' '     # espace en 32
'!'     # là on est en 33
'"'     # je vais les mettre l'un à côté de l'autre, c'est long ...
'#' '$' '%' '&' "'" '(' ')' '*' '+' ',' '-' '.' '/'
# les chiffres : '0' en 48 ... '9' en 57
'0' '1' '2' '3' '4' '5' '6' '7' '8' '9'
':' ';' '&lt;' '=' '&gt;' '?' '@' 'A' 'B' 'C' 'D' 'E' 'F'
'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' 'P' 'Q' 'R' 'S'
'T' 'U' 'V' 'W' 'X' 'Y' 'Z' '[' '\\' ']' '^' '_' '`'
# là on est en 97
'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm'
'n' 'o' 'p' 'q' 'r' 's' 't' 'u' 'v' 'w' 'x' 'y' 'z'
'{' '|' '}' '~'
'\x7f'     #pas imprimable
>>> ord('0')  # les chiffres : '0' en 48 ...
48
>>> chr(57)
'9'      # ..... en '9' en 57

Mais ça ne suffit plus !

Les accents européens, les idéogrammes, les caractères cyrilliques, grecs, etc. D’autres… Les smileys …

La norme qui s’est imposée dans les quinze dernières années : l’unicode ou utf-8.

En pratique, tous les systèmes évoluent vers cette norme unifiée pour « tout caractère de n’importe quel système d’écriture (un nom et un identifiant numérique) » : l’Unicode.

La norme UTF-8 est d’un usage de plus en plus courant sur Internet, et dans les systèmes devant échanger de l’information.

C’est une norme rétro-compatible avec l’ASCII initial.

Tous les caractères du « répertoire universel de caractères codés » devant avoir un identifiant unique, un octet ne suffit pas !

Par exemple, le symbole est a un code de 8364 !

Codons 8364 en binaire : 10000010101100.

Il faut non pas 1, non pas 2, non pas 3 mais bien … 14 bits !

L’UTF-8 : de 1 à 4 octets – c’est variable suivant la longueur en bits du code  (à savoir)

cm 2020-01-13 NSI utf8

Pour le symbole , codé 8364 donc 10000010101100 , il faut 14 bits donc 3 octets :

11100010     10000010     10101100    soit      E2   82   AC

Notez que l’UTF-8 demande plus de place que l’ASCII ou d’autres normes intercalées ! C’est le prix de l’universalité.

Les caractères ASCII restent identiques. On parle de rétrocompatibilité de l’utf-8 avec l’ASCII, je le répète (à savoir).

Exercices pour jeudi prochain :

Question 1 :

  • Coder en UTF8 (binaire) le é codé 233.

Question 2 :

  • Combien de caractères différents peut on coder en UTF-8 ?

Question 3 :

On a la séquence de huit octets suivante :

C3 A9 6C C3 A8 76 65 73

où chaque octet est représenté par deux chiffres hexadécimaux.

    • C’est en UTF-8, décoder la séquence.

N'hésitez-pas à poser une question, ou faire avancer le schmilblick

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur la façon dont les données de vos commentaires sont traitées.