[Introduction à Python3, jour 17] Chapitre 8 Destinations de données (8.1-8.2.5)

8.1 Entrée / sortie de fichier

--Ouvrez le fichier avec fileobj = open (nom de fichier, mode). --fileobj est l'objet du fichier retourné par open () --filename est le nom du fichier

• Choisissez ce que vous voulez faire avec le fichier. --r est lu, w est écrit et peut être écrasé et nouvellement créé, x est écrit mais uniquement lorsque le fichier n'existe pas. Le deuxième caractère de --mode indique le type de fichier. t signifie texte et b signifie binaire.

8.1.1 Ecrire dans un fichier texte avec write ()

>>> poem = """There was a young lady named Bright,
... Whose speed was far faster than light,
... She started one day,
... In a relative way,
... And returned on the previous night."""
>>> len(poem)
151

#write()La fonction renvoie le nombre d'octets écrits.
>>> f=open("relatibity","wt")
>>> f.write(poem)
151
>>> f.close()

#print()Mais vous pouvez écrire dans un fichier texte.
#print()Ajoute un espace après chaque argument et un saut de ligne à la fin du tout.
>>> f=open("relatibity","wt")
>>> print(poem,file=f)
>>> f.close()

#print()Écrire()Pour travailler de la même manière que sep,Utilisez end.
#sep:Séparateur. Espace par défaut(" ")devenir.
#end:La dernière chaîne de caractères. Pause pauses par défaut("\n")devenir.
>>> f=open("relatibity","wt")
>>> print(poem,file=f,sep="",end="")
>>> f.close()

#Si la chaîne source est très volumineuse, elle peut être divisée en morceaux et écrite dans le fichier.
>>> f=open("relatibity","wt")
>>> size=len(poem)
>>> offset=0
>>> chunk=100
>>> while True:
...     if offset>size:
...         break
...     f.write(poem[offset:offset+chunk])
...     offset+=chunk
... 
100
51
>>> f.close()

#La corruption de fichiers peut être évitée en empêchant l'écrasement avec le mode x.
>>> f=open("relatibity","xt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: 'relatibity'

#Il peut également être utilisé comme gestionnaire d'exceptions.
>>> try:
...     f=open("relatibity","xt")
...     f.write("stomp stomp stomp")
... except FileExistsError:
...     print("relativity already exists!. That was a close one.")
... 
relativity already exists!. That was a close one.

8.1.2 Lire des fichiers texte avec read (), readline (), headlines ()

#Le fichier entier peut être lu à la fois.
>>> fin=open("relatibity","rt")
>>> poem=fin.read()
>>> fin.close()
>>> len(poem)
151

#read()Vous pouvez limiter la quantité de données renvoyées à la fois en mettant le nombre de caractères dans l'argument de.
#En savoir plus après avoir lu tous les fichiers()Lorsque vous appelez, une chaîne vide("")Est retourné. → sinon f:Est évalué comme False.
>>> poem=""
>>> fin=open("relatibity","rt")
>>> chunk=100
>>> while True:
...     f=fin.read(chunk)
...     if not f:
...         break
...     poem+=f
... 
>>> fin.close()
>>> len(poem)
151

#readline()Vous pouvez utiliser pour lire le fichier ligne par ligne.
#Lire tous les fichiers()De même, il renvoie une chaîne de caractères vide et est évalué comme False.
>>> poem=""
>>> fin=open("relatibity","rt")
>>> while True:
...     line=fin.readline()
...     if not line:
...         break
...     poem+=line
... 
>>> fin.close()
>>> len(poem)
151

#Il peut être facilement lu en l'utilisant avec un itérateur.
>>> poem=""
>>> fin=open("relatibity","rt")
>>> for line in fin:
...     poem+=line
... 
>>> fin.close()
>>> len(poem)
151

#readlines()Lit une ligne à la fois et renvoie une liste de chaînes sur une ligne.
>>> fin=open("relativity","rt")
>>> lines=fin.readlines()
>>> fin.close()
>>> for line in lines:
...      print(line,end="")
... 
There was a young lady named Bright,
Whose speed was far faster than light,
She started one day,
In a relative way,
And returned on the previous night.>>> 

8.1.3 Ecrire un fichier binaire avec write ()

• L'ajout de "b" à la chaîne de mode ouvrira le fichier en mode binaire. Dans ce cas, vous lirez et écrirez des octets au lieu de chaînes.

#Générons 256 octets de 0 à 255.
>>> bdata=bytes(range(0,256))
>>> len(bdata)
256
>>> f=open("bfile","wb")
>>> f.write(bdata)
256
>>> f.close()

#Il est également possible d'écrire en unités de bloc comme dans le cas du texte.
>>> f=open("bfile","wb")
>>> size=len(bdata)
>>> offset=0
>>> chunk=100
>>> while True:
...     if offset>size:
...         break
...     f.write(bdata[offset:offset+chunk])
...     offset+=chunk
... 
100
100
56
>>> f.close

8.1.4 Lire le fichier binaire avec read ()

#"rb"Ouvrez-le simplement comme.
>>> f=open("bfile","rb")
>>> bdata=f.read()
>>> len(bdata)
256
>>> f.close()

8.1.5 avec fermeture automatique des fichiers

--with Lorsque le bloc de contexte suivant se termine, le fichier sera fermé automatiquement. --Utiliser sous forme d'expression comme variable.

>>> with open("relatibity","wt") as f:
...     f.write(poem)
... 
151

8.1.6 Repositionnement avec seek ()

• La fonction tell () renvoie le décalage entre le début du fichier et votre emplacement actuel en octets.

• La fonction seek () peut changer la position d'un objet fichier. --Utilisez f.seek (offset, whence) pour changer la position de l'objet fichier. Il est également défini dans le module os standard. --La position du fichier est calculée en ajoutant la valeur de décalage au point de référence. --Sélectionnez le point de référence avec l'argument whence. S'il est à 0, il se déplace du début à la position de décalage, s'il est 1, il se déplace de la position actuelle à la position d'octet de décalage, et s'il est à 2, il se déplace de la fin à la position de l'octet de décalage. --whence est facultatif, la valeur par défaut est 0, c'est-à-dire que le début du fichier est utilisé comme point de référence.

>>> f=open("bfile","rb")
>>> f.tell()
0

#seek()Utilisez pour passer au dernier octet du fichier.
#endroit(255)J'ai déménagé et lu le dos à partir de là. → Le dernier octet a été lu.
#Une image située entre 254 et 255 et dont 255 sont chargés lors du dernier chargement.
>>> f.seek(255)
255
>>> b=f.read()
>>> len(b)
1
#seek()Renvoie également le décalage après le déplacement.
>>> b[0]
255


>>> import os
>>> os.SEEK_SET
0
>>> os.SEEK_CUR
1
>>> os.SEEK_END
2


>>> f=open("bfile","rb")
#À partir de la fin-Déplacé vers une position décalée de 1.
>>> f.seek(-1,2)
255
#Renvoie le décalage en octets depuis le début du fichier.
>>> f.tell()
255
>>> b=f.read()
>>> len(b)
1
>>> b[0]
255

#Passer du début du fichier aux 2 derniers octets
#Image entre 253 et 254
>>> f=open("bfile","rb")
>>> f.seek(254,0)
254
>>> f.tell()
254
#Passer de 2 octets avant la fin du fichier à 1 octet avant
#Image entre 254 et 255
>>> f.seek(1,1)
255
>>> f.tell()
255
>>> b=f.read()
>>> len(b)
1
>>> b[0]
255

8.2 Fichier texte structuré

• Il existe les méthodes suivantes pour créer des données structurelles. --Séparateur, séparateur. Séparez-les par des tabulations ("\ t"), des virgules (","), des barres verticales ("|"), etc. Format CSV. --Séparez les balises avec "<" et ">". XML et HTML correspondent à cela. ――Ces qui utilisent pleinement les symboles. JSON est ainsi. --Indent. Par exemple, YAML.

CSV

• Les fichiers séparés en champs par des délimiteurs sont utilisés comme format d'échange de données avec des feuilles de calcul et des bases de données.
• Certains fichiers utilisent des séquences d'échappement. Si le caractère délimiteur est susceptible d'être utilisé dans le champ, mettez le champ entier entre guillemets ou faites précéder le délimiteur d'un caractère d'échappement.

>>> import csv
>>> villains=[
...     ["Doctor","No"],
...     ["R","K"],
...     ["Mister","Big"],
...     ["Auric","Goldfinger"],
...     ["E","B"],
...     ]

>>> with open ("villains","wt") as fout:
#writer()Écrire avec
...     csvout=csv.writer(fout)
#Un fichier csv appelé méchants a été créé.
...     csvout.writerows(villains)

Résultat d'exécution

Docter,No
R,K
Miser,Big
Auric,Goldfinger
E,B

>> import csv
>>> with open("villains","rt") as fin:
#reader()Lire avec
...     cin=csv.reader(fin)
...     villains=[row for row in cin]
... 
>>> print(villains)
[['Doctor', 'No'], ['R', 'K'], ['Mister', 'Big'], ['Auric', 'Goldfinger'], ['E', 'B']]

#DictReader()Spécifiez le nom de la colonne à l'aide de.
>>> import csv
>>> with open("villains","rt") as fin:
...     cin=csv.DictReader(fin,fieldnames=["first","last"])
...     villains=[row for row in cin]
... 
>>> print(villains)
[{'first': 'Docter', 'last': 'No'}, {'first': 'R', 'last': 'K'}, {'first': 'Miser', 'last': 'Big'}, {'first': 'Auric', 'last': 'Goldfinger'}, {'first': 'E', 'last': 'B'}]


>>> import csv
>>> villains= [
...     {"first":"Docter","last":"No"},
...     {"first":"R","last":"K"},
...     {"first":"Miser","last":"Big"},
...     {"first":"Auric","last":"Goldfinger"},
...     {"first":"E","last":"B"},
...     ]
>>> with open("villains","wt") as fout:
...     cout=csv.DictWriter(fout,["first","last"])
#writeheader()Vous pouvez également écrire le nom de la colonne au début du fichier CSV en utilisant.
...     cout.writeheader()
...     cout.writerows(villains)
... 

Résultat d'exécution

first,last
Docter,No
R,K
Miser,Big
Auric,Goldfinger
E,B

#Relisez les données du fichier.
#DictReader()Si vous omettez l'argument fieldnames dans l'appel, la valeur sur la première ligne du fichier(first,last)Signifie qui peut être utilisé comme clé de dictionnaire pour les étiquettes de colonne.
>>> import csv
>>> with open("villains","rt") as fin:
...     cin=csv.DictReader(fin)
...     villains=[row for row in cin]
... 
>>> print(villains)
[OrderedDict([('first', 'Docter'), ('last', 'No')]), OrderedDict([('first', 'R'), ('last', 'K')]), OrderedDict([('first', 'Miser'), ('last', 'Big')]), OrderedDict([('first', 'Auric'), ('last', 'Goldfinger')]), OrderedDict([('first', 'E'), ('last', 'B')])]

8.2.2 XML

--Utilisez ElementTree pour lire facilement XML.

menu.xml

<?xml version="1.0"?>
<menu>
#Des attributs facultatifs peuvent être incorporés dans la balise de début.
    <breakfast hours="7-11">
        <item price="$6.00">breakfast burritos</item>
        <item price="$4.00">pancakes</item>
    </breakfast>
    <lunch hours="11-3">
        <item price="$5.00">hamburger</item>
    </lunch>
    <dinner hours="3-10">
        <item price="$8.00">spaghetti</item>
    </dinner>
</menu>

>>> import xml.etree.ElementTree as et
>>> tree=et.ElementTree(file="menu.xml")
>>> root=tree.getroot()
>>> root.tag
'menu'
#tag est une chaîne de balises et attrib est un dictionnaire de ses attributs.
>>> for child in root:
...     print("tag:",child.tag,"attributes:",child.attrib)
...     for grandchild in child:
...         print("\ttag:",grandchild.tag,"attributes:",grandchild.attrib)
... 
tag: breakfast attributes: {'hours': '7-11'}
	tag: item attributes: {'price': '$6.00'}
	tag: item attributes: {'price': '$4.00'}
tag: lunch attributes: {'hours': '11-3'}
	tag: item attributes: {'price': '$5.00'}
tag: dinner attributes: {'hours': '3-10'}
	tag: item attributes: {'price': '$8.00'}
#nombre de sections de menu
>>> len(root)
3
#Nombre d'articles pour le petit-déjeuner
>>> len(root[0])
2

8.2.3 JSON

• C'est un format d'échange de données très populaire au-delà du cadre de JavaSciript.
• Le format JSON est un sous-ensemble de JavaSciript et est souvent utilisé en Python. --Json dans le module JSON encode (vide) les données Python en chaînes JSON et décode (charge) les chaînes JSON en données Python.

#Créer une structure de données
>>> menu=\
... {
... "breakfast":{
...     "hours":"7-11",
...     "items":{
...             "breakfast burritos":"$6.00",
...             "pancakes":"$4.00"
...             }
...         },
... "lunch":{
...         "hours":"11-3",
...         "items":{
...             "hamburger":"$5.00"
...                 }
...         },
... "dinner":{
...     "hours":"3-10",
...     "items":{
...             "spaghetti":"$8.00"
...             }
...     }
... }

#dumps()Cette structure de données utilisant(menu)Vers la chaîne JSON(menu_json)Encoder en.
>>> import json
>>> menu_json=json.dumps(menu)
>>> menu_json
`{"breakfast": {"hours": "7-11", "items": {"breakfast burritos": "$6.00", "pancakes": "$4.00"}}, "lunch": {"hours": "11-3", "items": {"hamburger": "$5.00"}}, "dinner": {"hours": "3-10", "items": {"spaghetti": "$8.00"}}}`

#loads()Utilisation du menu de chaînes JSON_Renvoyer json au menu 2 de la structure de données Python.
>>> menu2=json.loads(menu_json)
>>> menu2
{'breakfast': {'hours': '7-11', 'items': {'breakfast burritos': '$6.00', 'pancakes': '$4.00'}}, 'lunch': {'hours': '11-3', 'items': {'hamburger': '$5.00'}}, 'dinner': {'hours': '3-10', 'items': {'spaghetti': '$8.00'}}}

#Lorsque vous essayez d'encoder ou de décoder certains objets tels que datetime, l'exception suivante se produit.
#En effet, la norme JSON ne définit pas les types de date et d'heure.
>>> import datetime
>>> now=datetime.datetime.utcnow()
>>> now
datetime.datetime(2020, 1, 23, 1, 59, 51, 106364)
>>> json.dumps(now)
#...réduction
TypeError: Object of type datetime is not JSON serializable

#Vous pouvez convertir datetime en chaîne ou heure Unix.
>>> now_str=str(now)
>>> json.dumps(now_str)
'"2020-01-23 01:59:51.106364"'
>>> from time import mktime
>>> now_epoch=int(mktime(now.timetuple()))
>>> json.dumps(now_epoch)
'1579712391'

#Si le type de données qui est normalement converti inclut une valeur de type datetime, il est difficile de convertir à chaque fois.
#Alors json.Créez une classe qui hérite de JSONEncoder.
#Remplacez la méthode par défaut.
#isinstance()La fonction est obj est datetime.Vérifiez s'il s'agit d'un objet de la classe datetime.
>>> class DTEncoder(json.JSONEncoder):
...     def default(self,obj):
...     #isinstance()Vérifie le type d'obj.
...         if isinstance(obj,datetime.datetime):
...             return int(mktime(obj.timetuple()))
...         return json.JSONEncoder.default(self,obj)
... 
#now=datetime.datetime.utcnow()Est défini, donc True est renvoyé.
>>> json.dumps(now,cls=DTEncoder)
`1579712391`

>>> type(now)
<class `datetime.datetime`>
>>> isinstance(now,datetime.datetime)
True
>>> type(234)
<class `int`>
>>> type("hey")
<class `str`>
>>> isinstance("hey",str)
True
>>> isinstance(234,int)
True

8.2.4 YAML

• Comme JSON, YAML a des clés et des valeurs, mais il peut gérer plus de types de données que JSON, y compris les dates et les heures.

• Pour traiter YAML, vous devez installer une bibliothèque appelée PyYAML.

mcintyre.yaml

name:
  first:James
  last:McIntyre
dates:
  birth:1828-05-25
  death:1906-03-31
details:
  bearded:true
  themes:[cheese,Canada]
books:
  url:http://www.gutenberg.org/files/36068/36068-h/36068-h.htm
poems:
  - title: "Motto" #Une erreur s'est produite car il n'y avait pas d'espace demi-largeur.
    text: |
        Politeness,perseverance and pluck,
        To their possessor will bring good luck.
  - title: "Canadian Charms" #Une erreur s'est produite car il n'y avait pas d'espace demi-largeur.
    text: |
        Here industry is not in vain,
        For we have bounteous crops of grain,
        And you behold on every field
        Of grass and roots abundant yield,
        But after all the greatest charm
        Is the snug home upon the farm,
        And stone walls now keep cattle warm.

>>> import yaml
>>> with open("mcintyre.yaml","rt") as fin:
...     text=fin.read()
... 
>>> data=yaml.load(text)
>>> data["details"]
'bearded:true themes:[cheese,Canada]'
>>> len(data["poems"])
2

8.2.5 Sérialisation avec pickle

• Prendre la hiérarchie de données Python et la convertir en une représentation sous forme de chaîne s'appelle ** sérialisation **. La reconstruction de données à partir d'une représentation sous forme de chaîne s'appelle ** désérialisation **.
• De la sérialisation à la désérialisation, la représentation sous forme de chaîne de l'objet peut être enregistrée sous forme de fichiers ou de données, ou envoyée à une machine distante sur le réseau.

--Python est un format binaire spécial qui fournit un module pickle qui peut stocker et restaurer n'importe quel objet.

>>> import pickle
>>> import datetime
>>> now1=datetime.datetime.utcnow()
>>> pickled=pickle.dumps(now1)
>>> now2=pickle.loads(pickled)
>>> now1
datetime.datetime(2020, 1, 23, 5, 30, 56, 648873)
>>> now2
datetime.datetime(2020, 1, 23, 5, 30, 56, 648873)

#pickle peut également gérer des classes et des objets propriétaires définis dans le programme.
>>> import pickle
>>> class Tiny():
...     def __str__(self):
...         return "tiny"
... 
>>> obj1=Tiny()
>>> obj1
<__main__.Tiny object at 0x10af86910>
>>> str(obj1)
'tiny'
#pickled est une séquence binaire sérialisée avec pickle à partir d'un objet obj1.
#dump()Sérialisez dans un fichier à l'aide de.
>>> pickled=pickle.dumps(obj1)
>>> pickled
b'\x80\x03c__main__\nTiny\nq\x00)\x81q\x01.'
#Je l'ai reconverti en obj2 et ai fait une copie de obj1.
#loads()Désérialisez les objets des fichiers à l'aide de.
>>> obj2=pickle.loads(pickled)
>>> obj2
<__main__.Tiny object at 0x10b21cdd0>
>>> str(obj2)
'tiny'

Impressions

Enfin à côté du SGBDR.

Les références

"Introduction à Python3 par Bill Lubanovic (publié par O'Reilly Japon)"

"Tutoriel Python 3.8.1 Document 7. Entrée et sortie" https://docs.python.org/ja/3/tutorial/inputoutput.html#old-string-formatting