Ouverture/Fermeture de fichier

Ouverture et fermeture d’un fichier

La fonction open()

Elle permet d’ouvrir un fichier et de récupérer un descripteur pour le fichier. C’est ce descripteur que nous utiliserons pour lire ou écrire dans le fichier.

fileObject = open("filename", "mode")

Les modes :

  • ‘r’ : ouverture du fichier en lecture
  • ‘w’ : ouverture du fichier en écriture (si le fichier existe déjà il est détruit)
  • ‘a’ : ouverture du fichier en écriture et on se place à la fin

La fonction close()

Elle permet de fermer un fichier et effectue réellement les écritures dans le fichier.

fileObject.close()

Ouverture avec contrôle

Pour contrôler simplement que le fichier est bien ouvert on peut utiliser la forme suivante :

with open(newfile, 'w') as outfile, open(oldfile, 'r') as infile:
  for line in infile:
    if line.startswith(txt):
      line = line[0:len(txt)] + ' - Truly a great person!\n'
    outfile.write(line)

Ecritre/Lecture dans un fichier

Ecriture d’un fichier texte

file = open("testfile.txt","w") 
 
file.write("Hello World") 
file.write("This is our new text file") 
file.write("and this is another line.") 
file.write("Why? Because we can.") 
 
file.close()

Lecture dans un fichier texte

file = open("testfile.text", "r")
print file.read()      # Affiche tout le fichier
print file.read(5)     # Affiche les 5 premiers caractères
print file.readline()  # Affiche la première ligne
print file.readline(3) # Affiche la 3ème ligne
print file.readlines() # ['line 1', 'line 2', ..., 'last line'] 
file.close()

Copie de fichier

Copier un fichier

Très simple :

from shutil import copyfile

copyfile(source, destination)

Gestion des chemins de fichiers

Construction d’un chemin

Pour gérer les chemins de fichiers il est plus simple (et protable) d’utiliser l’utilitaire path de la bibliothèque os :

import os

path = os.path.join("c:\\", "repertoire", "sous-repertoire", "fichier")

Récupération du répertoire dans un path

import os

directory = os.path.dirname(file_path)

Ajouter un répertoire au milieu d’un path

>>> import os
>>> root = os.path.join("c:\\", "test")
>>> path = os.path.join(root, "sousrep")
>>> path
'c:\\test\\sousrep'
>>> sub = os.path.relpath(path, root)
>>> sub
'sousrep'
>>> new_dir = "newsub"
>>> os.path.join(root, new_dir, sub)
'c:\\test\\newsub\\sousrep'

Sous quel système je suis ?

OS et Platform

Pour savoir sous quel système un script est en cours d’exécution il existe plusieurs solutions. La solution suivante reste une solution tout à fait portable et simple d’utilisation :

>>> import os
>>> os.name
'nt'
>>> import platform
>>> platform.system()
'Windows'
>>> platform.release()
'Vista'

Voici donc une manière simple et élégante de gérer des appels différents dans vos scripts :

import os
import platform

(...)

if platform.system().lower() == "windows":
  # action pour windows
else if platform.system().lower() == "darwin":
  # action pour MACOS
else if platform.system().lower() == "linux":
  # action pour Linux

Créer un dictionnaire

Qu’est-ce qu’un dictionnaire

Les dictionnaires sont les tableaux associatifs de python, ils permettent d’associer des valeurs à des clés qui ne sont pas forcément des entiers. C’est une technique simple et efficace pour stocker des données.

Création d’un dictionnaire

d = dict()

d["key"] = value
d["key2"] = value2

d = { "key": value, "key2": value2 }

Création à partir de deux listes de même taille

>>> l = '123456789'
>>> c = 'ABCDEFGHI'
>>> dict(zip(l,c))
{'8': 'H', '6': 'F', '3': 'C', '5': 'E', '9': 'I', 
'7': 'G', '1': 'A', '4': 'D', '2': 'B'}
>>> dict(zip(c,l))
{'G': '7', 'F': '6', 'C': '3', 'I': '9', 'E': '5', 
'A': '1', 'H': '8', 'B': '2', 'D': '4'}

Supprimer un couple clé-valeur

deux méthodes :

  • utiliser la suppresion globale ‘del’
  • utiliser la fonction ‘pop(key)’ des dictionnaires
>>> del d[2]
>>> d
{'key': 2}

>>> d.pop('key')
2

Attention la fonction pop() renvoit la valeur, ce qui peut être très utile.

Itération sur les éléments d'un dictionnaire

Itération sur les valeurs

for value in d.values():
  print( "valeur :", value)

Itération sur les clés

for key in d.keys():
  print("cle :", key )
  print("valeur :", d[key])

Itération sur les couple clé-valeur

for key, value in d.items():
  print("cle :", key)
  print("valeur :", value)

Les Sets

Les sets

Les sets sont des ensembles non ordonnés d’éléments uniques. Ils sont très pratiques pour éliminer des valeurs multiples

>>> l = list('12345654321')
>>> l
['1', '2', '3', '4', '5', '6', '5', '4', '3', '2', '1']
>>> l = list(set(l))
>>> l
['5', '4', '2', '6', '3', '1']
>>> l.sort()
>>> l
['1', '2', '3', '4', '5', '6']

Les Dictionnaires

Les Dictionnaires

Les dictionnaires sont des ensembles non ordonnés de binomes clé-valeur. Les clés sont uniques. Ils sont très pratiques pour stocker simplement des données vivantes.

>>> d = dict()
>>> d
{}
>>> d["key"] = 2
>>> d
{ 'key': 2 }
>>> d[2] = "key"
>>> d
{'key': 2, 2: 'key'}

Introspection

dir()

La fonction dir() permet d’accéder aux éléments présents dans l’espace de travail.

>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> a = 1
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a']
>>> import math
>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'math']
>>>

Elle permet également d’accéder aux fonctions applicables à certains éléments

>>> dir(a)
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', 
(...)
'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

type()

La fonction type permet de connaitre le type actuel d’une variable. N’oubliez pas que les variables changent de type en fonction de ce qu’elles contiennent

>>> a = 1
>>> type(a)
<class 'int'>
>>> a = "Salut"
>>> type(a)
<class 'str'>

help()

La fonction help() permet d’accéder à l’aide en ligne dans un interpréteur. Elle peut également fournir la documentation disponible sur une fonction.

>>> help()

Welcome to Python 3.6's help utility!
(...)
help> quit
>>>

>>> help(print)
Help on built-in function print in module builtins:

print(...)

(...)
>>>

Quelques opérations utiles

Combinaison de chaînes de caractères

>>> a = 'Hello'
>>> b = 'World'
>>> a+b
'HelloWorld'
>>> a+' '+b
'Hello World'
>>> print("%s %s" % (a,b))
Hello World

Strip, upper et lower

>>> x
'  heLLo '
>>> print(x)
  heLLo 
>>> print(x.upper())
  HELLO 
>>> print(x.capitalize())
  hello 
>>> print(x.lower())
  hello 
>>> print(x.strip())
heLLo
>>> # Et en plus ça se chaine...
>>> print(x.strip().capitalize())
Hello

Est-ce qu’une chaine commence par …

str.startswith(str, beg=0,end=len(string));

>>> a = 'Hello World'
>>> a.startswith("hello")
False
>>> a.startswith("Hello")
True
>>> a.lower().startswith("hello")
True
>>> a.lower().startswith("heLLo".lower())
True