Entrées/Sorties en console

Sortie en console

La fonction print permet l’affichage d’une valeur en console, quel qu’en soit le type.

On peut afficher un texte simple, ou composé de plusieurs parties, par concaténation de chaine :

clan = 'Vikings'
message = 'Fight Invaders'
print('We are the ' + clan + ' who say' + ' "'+ message + '!"')
# affiche 
# We are the Vikings who say "Fight Invaders!"

Le problème de cette méthode de concaténation est que chaque partie composant la chaine doit être de type str. Cela est possible avec la fonction str(variable, mais il existe une méthode plus efficace : formater la chaine.

La méthode str.format() sur les chaines de caractères :

La methode de base :

clan = 'Vikings'
message = 'Fight Invaders'
print('We are the {} who say "{}!"'.format(clan, message))
# affiche 
# We are the Vikings who say "Fight Invaders!"

On peut aussi préciser le nombre de caractères ou de chiffres attendus, le type de données, etc.

Exemple : affichage d’une table

for x in range(1, 11):
    print('{:2d} {:3d} {:4d}'.format(x, x*x, x*x*x))
# affichage : 
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

Cela permet d’aligner des chaînes dans une largeur de taille fixe.

Entrées au clavier : `input`

La fonction input met le programme en pause et attend que l’utilisateur entre une donnée.

nom = input('Quel est votre nom ? ')
print('Bonjour, {}'.format(nom))

Toutes les données saisies sont converties en chaîne. Il est donc necessaire de convertir les données numériques dans le type approprié avant de les utiliser :

prix = input('Combien coute ce camion ?')
prix = float(prix)
if prix < 10000:
  print('Ok, je le prends.')

Lire le contenu d’un fichier

Repertoire courant

Selon l’IDE python choisi, vous pouvez avoir des difficultés pour ouvrir un fichier. L’interpreteur peut considérer que le repertoire courant n’est pas celui du fichier en cours d’execution, et ne trouve pas votre fichier data, qui se trouve dans le même dossier.

Pour resoudre ce problème, vous pouvez ajouter les lignes suivantes:

import os

dir_path = os.path.dirname(os.path.abspath(__file__))
print('init:',dir_path)

os.chdir(dir_path)
#sys.path.append(dir_path)
print('after:',os.getcwd())
print('conten:t',os.listdir())

Le module os apporte les fonctions:

chdir: changer de repertoire courant pour le chemin utilisé par l’interpreteur
getcwd: chemin du repertoire courant
listdir: contenu du repertoire courant

Fichier txt

On utilise la fonction open de la librairie standart en python:

La fonction open crée donc un fichier. Elle renvoie un objet de la classeTextIoWrapper. Par la suite, nous allons utiliser des méthodes de cette classe pour interagir avec le fichier.

Exemple de programme : lit un fichier .txt et créé une liste mots

# initialisation de la liste vide
mots = []

# Lecture du fichier txt et remplissage de la liste
with open('liste_francais.txt', encoding='iso-8859-1') as f:
    for mot in f.read().splitlines():
        mots.append(mot)

open : renvoyer un objet TextIOWrapper
as : « en tant que »

Le mot-clé with permet de créer un “context manager” (gestionnaire de contexte) qui vérifie que le fichier est ouvert et fermé, même si des erreurs se produisent pendant le bloc.

Plus d’informations : https://python.sdv.univ-paris-diderot.fr/07_fichiers/

Caractères speciaux

Certains caractères sont fort utiles lors de l’écriture de fichiers texte afin d’organiser les données. Le symbole ; est très utilisé comme séparateur de colonnes pour une matrice, on utilise également le passage à la ligne ou la tabulation. Comme ce ne sont pas des caractères « visibles », ils ont des codes :

\ caractère d’echappement (par exemple pour écrire des guillemets dans une chaine)
\n : passage à la ligne
\t : tabulation, indique un passage à la colonne suivante dans le format tsv (Tabulation-separated values).

Lors de la lecture d’un fichier, on peut avoir besoin de supprimer ces caractères spéciaux:

table = []
# Lecture du fichier
with open('datas/rne-cm.csv', encoding='utf-8') as f:
    for line in f.read().splitlines():
        table.append(line)

table[2]
# affiche
'32\tGers\t\t\t32249\tMauvezin\tPASCOLINI\tJean-Marc\tM\t'
print(table[2])
# affiche
32 Gers   32249 Mauvezin PASCOLINI Jean-Marc M
len(table[2])
# affiche 
1

L’import des données n’a pas placé les valeurs comme des éléments de liste. Il faudrait découper la chaine de caractères au niveau des espaces:

On peut alors remplacer l’instruction table.append(line) par table.append(line.split('\t')), ce qui découpe la chaine au niveau des \t:

with open('datas/rne-cm.csv', encoding='utf-8') as f:
    for line in f.read().splitlines():
        table.append(line.split('\t'))
table[2]
# affiche
['32',
 'Gers',
 '',
 '',
 '32249',
 'Mauvezin',
 'PASCOLINI',
 'Jean-Marc',
 'M',...]

Bien entendu, il faudra adapter l’argument de la fonction split en fonction du caractère de séparation utilisé dans le fichier:

Pour le contenu suivant, il faudra utiliser line.split(';')

;2020;2021;2022;2023;2024;total
seconde;480;495;420;465;465;
premiere;420;525;420;510;465;
terminale;495;480;420;435;435;
;;;;;;

Fichier csv

Le module csv permet de reduire d’une ligne l’import des données (choisir le bon delimiter):

import csv
table = []
with open('ficher.csv', 'r') as file:
    reader = csv.reader(file, delimiter=',')
    for row in reader:
        table.append(row)

Souvent, la première ligne ne concerne que l’en-tête (descripteurs).
Le reste des données, numériques doivent être converties en float
Supposons que les données contiennent les valeur de x pour la première colonne, et y la deuxième colonne:

x = []
y = []
for i in range(1,len(table[1:])):
    x.append(float(table[i][0]))
    y.append(float(table[i][1]))

Ecrire dans un fichier

Texte non structuré

animaux2 = ["poisson", "abeille", "chat"]
with open("zoo2.txt", "w") as filout:
    for animal in animaux2:
         filout.write(animal)

à la ligne 2 : ouverture du fichier zoo2.txt en mode écriture, avec le caractère w pour write.

Si nous ouvrons le fichier zoo2.txt avec un éditeur de texte, voici ce que nous obtenons :

poissonabeillechat

Ce n’est pas exactement le résultat attendu. Le script peut être amélioré en utilisant une écriture formatée, comme vu plus haut, à la dernière ligne du script :

         filout.write("{}\n".format(animal))

Ce qui donne maintenant, à l’ouverture du fichier :

poisson
abeille
chat

Exemple issu de la page python.sdv.univ-paris-diderot.fr/07_fichiers

Tableau de données

convertir les données en chaine de caractère formatée:

descripteurs = ['courant','tension','puissance']
datas = [[0.100,2.00,0.200],[0.200,4.00,0.400]]
tab = ""
for title in descripteurs:
    # ajout des descripteurs en tete du tableau
    tab = tab + title + ','
for i in range(len(datas)):
    # saut de ligne
    tab = tab + '\n'
    for j in range(len(datas[0])):
        tab = tab + datas[i][j] + ','

exporter avec une extension csv

with open("fichier_datas.csv", "w") as filout:
    filout.write(tab)

Exporter des données (sauvegarde)

Il peut être utile de sauvegarder des données en cours de travail, comportant des paramètres que l’on veut retrouver lors d’une prochaine session de travail.

Utiliser le module pickle pour écrire, puis lire une structure de donnée python, comme un dictionnaire ou une liste:

import pickle

Exemple:

dico = {'b10' : 479.01,
        'b11' : 479.19,
        'b20' : 479.89,
        'b21' : 479.91}

Ecriture:

with open(fichier_export,'wb') as f1:
    pickle.dump(dico,f1)

Lecture:

with open('sauvegarde','rb') as f2:
    dico = pickle.load(f2)

Liens

Voir cours sur le formatage des sorties : Lien python.org

Allophysique