Dans ce guide, nous utiliserons Python version 3. La plupart des systèmes sont livrés avec Python 2.7 pré-installé. Alors que Python 2.7 est utilisé dans la plupart des codes existants, Python 3 représente le présent et l'avenir du langage Python. À moins que vous n'ayez une raison spécifique d'écrire ou de prendre en charge du code Python hérité, nous vous recommandons de travailler dans Python 3.
Pour Microsoft Windows, Python3 peut être téléchargé à partir de //www.python.org. Lors de l'installation, assurez-vous que les options "Installer le programme de lancement pour tous les utilisateurs" et "Ajouter Python à PATH" sont toutes deux cochées, comme indiqué dans l'image ci-dessous.
Sous Linux, vous pouvez installer Python 3 avec votre gestionnaire de paquets. Par exemple, sur Debian ou Ubuntu, vous pouvez l’installer avec la commande suivante:
sudo apt-get update && sudo apt-get install python3
Pour macOS, le programme d’installation de Python 3 peut être téléchargé à partir de python.org, comme indiqué ci-dessus. Si vous utilisez le gestionnaire de paquets Homebrew, vous pouvez également l'installer en ouvrant une fenêtre de terminal ( Applications → Utilitaires ) et en exécutant cette commande:
brasser installer python3
Exécuter Python
Sous Linux et macOS, la commande permettant d'exécuter l'interpréteur Python 3 est python3 . Sous Windows, si vous avez installé le programme de lancement, la commande est py . Les commandes de cette page utilisent python3 ; si vous utilisez Windows, remplacez py par python3 dans toutes les commandes.
L'exécution de Python sans aucune option lancera l'interpréteur interactif. Pour plus d'informations sur l'utilisation de l'interpréteur, consultez Vue d'ensemble de Python: utilisation de l'interpréteur Python. Si vous entrez accidentellement dans l'interpréteur, vous pouvez le quitter en utilisant la commande exit () ou quit () .
L'exécution de Python avec un nom de fichier interprétera ce programme python. Par exemple:
programme.py python3
... exécute le programme contenu dans le fichier program.py .
Comment pouvons-nous utiliser Python pour extraire du texte d’un fichier texte?
Lecture de données à partir d'un fichier texte
Commençons par lire un fichier texte. Disons que nous travaillons avec un fichier nommé lorem.txt, qui contient quelques lignes de latin:
Lorem ipsum dolor sit amet, consectetur elip adipiscing elit.Mauris nec maximus purus. Maecenas sit amet pretium tellus.Quisque à dignissim lacus.
Remarque: Dans tous les exemples qui suivent, nous travaillons avec le texte contenu dans ce fichier. N'hésitez pas à copier et coller le texte latin ci-dessus dans un fichier texte et à l'enregistrer sous le nom lorem.txt afin de pouvoir exécuter l'exemple de code en utilisant ce fichier en tant qu'entrée.
Un programme Python peut lire un fichier texte en utilisant la fonction open () intégrée. Par exemple, ci-dessous, un programme Python 3 ouvre le fichier lorem.txt pour le lire en mode texte, lit le contenu dans une variable chaîne nommée contenu, ferme le fichier, puis imprime les données.
myfile = open ("lorem.txt", "rt") # ouvrez lorem.txt pour lire le contenu du texte = myfile.read () # lit l'intégralité du fichier dans une chaîne myfile.close () # ferme le fichier print (contenu) # imprimer le contenu Ici, myfile est le nom que nous donnons à notre objet file.
Le paramètre " rt " dans la fonction open () signifie "nous ouvrons ce fichier pour lire des données externes"
La marque de hachage (" # ") signifie que tout ce qui se trouve sur le reste de la ligne est un commentaire et que l'interpréteur Python l'ignore.
Si vous enregistrez ce programme dans un fichier nommé read.py, vous pouvez l'exécuter à l'aide de la commande suivante.
python3 read.py
La commande ci-dessus affiche le contenu de lorem.txt :
Lorem ipsum dolor sit amet, consectetur elip adipiscing elit.Mauris nec maximus purus. Maecenas sit amet pretium tellus.Quisque à dignissim lacus.
Utiliser "avec ouvert"
Il est important de fermer vos fichiers ouverts dès que possible: ouvrez le fichier, effectuez votre opération et fermez-le. Ne le laissez pas ouvert pendant de longues périodes.
Lorsque vous travaillez avec des fichiers, il est judicieux d'utiliser l'instruction with open ... en tant qu'instruction composée. C'est le moyen le plus propre d'ouvrir un fichier, de l'exploiter et de le fermer, le tout dans un bloc de code facile à lire. Le fichier est automatiquement fermé à la fin du bloc de code.
Avec open ... as, nous pouvons réécrire notre programme pour ressembler à ceci:
avec open ('lorem.txt', 'rt') sous myfile: # Ouvrez lorem.txt pour lire le contenu du texte = myfile.read () # Lire le fichier entier dans une chaîne print (contenu) # Imprimer la chaîne Remarque: l'indentation est importante en Python. Les programmes Python utilisent un espace au début d'une ligne pour définir la portée, telle qu'un bloc de code. Il est recommandé d'utiliser quatre espaces par niveau d'indentation et d'utiliser des espaces plutôt que des tabulations. Dans les exemples suivants, assurez-vous que votre code est mis en retrait exactement comme il est présenté ici.
Enregistrez le programme sous le nom read.py et exécutez-le:
python3 read.py
Sortie
Lorem ipsum dolor sit amet, consectetur elip adipiscing elit.Mauris nec maximus purus. Maecenas sit amet pretium tellus.Quisque à dignissim lacus.
Lecture de fichiers texte ligne par ligne
Jusqu'à présent, dans les exemples, nous avons lu l'intégralité du fichier à la fois. Lire un fichier complet n’a rien de grave avec de petits fichiers, mais d’une manière générale, ce n’est pas une bonne idée. D'une part, si votre fichier est plus grand que la quantité de mémoire disponible, vous rencontrerez une erreur.
Dans presque tous les cas, il est préférable de lire un fichier texte ligne par ligne.
En Python, l'objet fichier est un itérateur. Un itérateur est un type d'objet Python qui se comporte de différentes manières lorsqu'il est utilisé à plusieurs reprises. Par exemple, vous pouvez utiliser une boucle for pour agir sur un objet fichier à plusieurs reprises et chaque fois que vous effectuez la même opération, vous obtenez un résultat différent ou "suivant".
Pour les fichiers texte, l’objet fichier itère une ligne de texte à la fois. Il considère une ligne de texte comme une "unité" de données. Nous pouvons donc utiliser une instruction de boucle for ... in pour effectuer une itération sur les données ligne par ligne:
avec open ('lorem.txt', 'rt') en tant que myfile: # Ouvrez le fichier lorem.txt pour lire le texte de myline dans myfile: # Pour chaque ligne, lisez-la en une chaîne print (myline) # imprimez cette chaîne, répétez Sortie
Lorem ipsum dolor sit amet, consectetur elip adipiscing elit. Mauris nec maximus purus. Maecenas sit amet pretium tellus. Quisque à dignissim lacus.
Notez que nous obtenons un saut de ligne supplémentaire ("nouvelle ligne") après chaque ligne. C'est parce que deux nouvelles lignes sont en cours d'impression. Le premier est la nouvelle ligne à la fin de chaque ligne de notre fichier texte. La deuxième nouvelle ligne se produit parce que, par défaut, print () ajoute un saut de ligne à la fin de ce que vous lui avez demandé d'imprimer.
Stockons nos lignes de texte dans une variable - en particulier une variable de liste - afin de pouvoir l'examiner de plus près.
Stocker des données de texte dans une variable de liste
En Python, les listes sont similaires à un tableau en C ou Java, mais pas identiques. Une liste Python contient des données indexées, de différentes longueurs et types.
mylines = [] # Déclare une liste vide nommée mylines. avec open ('lorem.txt', 'rt') en tant que myfile: # Ouvrez lorem.txt pour lire des données texte. pour myline dans myfile: # Pour chaque ligne, stockée sous la forme myline, mylines.append (myline) # ajoute son contenu à mylines. print (mylines) # Imprimez la liste. Le résultat de ce programme est un peu différent. Au lieu d’imprimer le contenu de la liste, ce programme imprime notre objet liste, qui ressemble à ceci:
Sortie
['Lorem ipsum dolor sit amet, consectetur elit adipiscing. Nunc fringilla arcu congue metus aliquam mollis. \ N ', ' Mauris nec maximus purus. Maecenas sit amet pretium tellus. Praesent sed rhoncus eo. Duis id commodo orci. \ N ', ' Quisque chez dignissim lacus. \ N ']
Ici, nous voyons le contenu brut de la liste. Dans sa forme d'objet brut, une liste est représentée par une liste délimitée par des virgules. Ici, chaque élément est représenté par une chaîne et chaque nouvelle ligne est représentée par sa séquence de caractères d'échappement, \ n .
Tout comme un tableau en C ou en Java, nous pouvons accéder aux éléments d'une liste en spécifiant un numéro d'index après le nom de la variable, entre parenthèses. Les numéros d'index commencent à zéro - autrement dit, le n- ème élément d'une liste a l'index numérique n- 1.
Remarque: Si vous vous demandez pourquoi les index commencent par zéro au lieu d'un, vous n'êtes pas seul. Les informaticiens ont débattu de l'utilité des systèmes de numérotation basés sur zéro dans le passé. En 1982, Edsger Dijkstra donna son avis sur le sujet, expliquant pourquoi la numérotation à base zéro était le meilleur moyen d’indexer les données en informatique. Vous pouvez lire la note vous-même - il présente un argument convaincant.
Nous pouvons imprimer le premier élément de lignes en spécifiant le numéro 0, entre parenthèses après le nom de la liste:
print (mylines [0])
Sortie
Lorem ipsum dolor sit amet, consectetur elip adipiscing elit. Nunc fringilla arcu congue metus aliquam mollis.
Ou la troisième ligne, en spécifiant l'index numéro 2:
imprimer (mylines [2])
Sortie
Quisque à dignissim lacus.
Mais si nous essayons d'accéder à un index pour lequel il n'y a pas de valeur, nous obtenons une erreur:
imprimer (mylines [3])
Sortie
Traceback (dernier appel le plus récent): fichier, ligne, en impression (mylines [3]) IndexError: index de liste hors limites
Un objet de liste est un itérateur. Pour imprimer chaque élément de la liste, nous pouvons le parcourir avec ... for :
mylines = [] # Déclarez une liste vide avec open ('lorem.txt', 'rt') sous la forme myfile: # Ouvrez lorem.txt pour lire du texte. for line in myfile: # Pour chaque ligne de texte, mylines.append (line) # ajoute cette ligne à la liste. pour l'élément dans les lignes directrices: # pour chaque élément de la liste, print (element) # print it. Sortie
Lorem ipsum dolor sit amet, consectetur elip adipiscing elit. Mauris nec maximus purus. Maecenas sit amet pretium tellus. Quisque à dignissim lacus.
Mais nous avons toujours des nouvelles lignes supplémentaires. Chaque ligne de notre fichier texte se termine par un caractère de nouvelle ligne (' \ n '), en cours d'impression. De plus, après avoir imprimé chaque ligne, print () ajoute une nouvelle ligne, sauf indication contraire de votre part.
Nous pouvons changer ce comportement par défaut en spécifiant un paramètre de fin dans notre appel print () :
print (element, end = '')
En définissant end à une chaîne vide (représentée par deux guillemets simples, sans espace entre eux), nous demandons à print () de ne rien imprimer à la fin d'une ligne, au lieu d'un caractère de nouvelle ligne.
Notre programme révisé ressemble à ceci:
mylines = [] # Déclarez une liste vide avec open ('lorem.txt', 'rt') sous la forme myfile: # Ouvrez le fichier lorem.txt pour lire le texte de la ligne dans myfile: # Pour chaque ligne de texte, mylines.append ( ligne) # ajoute cette ligne à la liste. Pour l'élément dans les lignes de mines: # Pour chaque élément de la liste, print (element , end = '' ) # affichez-le , sans nouvelles lignes . Sortie
Lorem ipsum dolor sit amet, consectetur elip adipiscing elit.Mauris nec maximus purus. Maecenas sit amet pretium tellus.Quisque à dignissim lacus.
Les nouvelles lignes que vous voyez ici sont en réalité dans le fichier; ils sont un caractère spécial (' \ n ') à la fin de chaque ligne. Nous voulons nous en débarrasser pour ne pas nous inquiéter pendant le traitement du fichier.
Comment décaper les nouvelles lignes
Pour supprimer complètement les nouvelles lignes, nous pouvons les supprimer. Supprimer une chaîne, c'est supprimer un ou plusieurs caractères, généralement des espaces, du début ou de la fin de la chaîne.
Conseil: Ce processus est parfois également appelé "rognage".
Les objets de chaîne Python 3 ont une méthode appelée rstrip (), qui supprime les caractères du côté droit de la chaîne. La langue anglaise étant lue de gauche à droite, le fait de supprimer du côté droit supprime les caractères de la fin.
Si la variable s'appelle mystring, nous pouvons en éliminer le côté droit avec mystring.rstrip ( chars ), où les caractères sont une chaîne de caractères à supprimer, s'ils se trouvent du côté droit de la chaîne. Par exemple, "123abc" .rstrip ("bc") renvoie 123a .
Conseil: lorsque vous représentez une chaîne dans votre programme avec son contenu littéral, cela s'appelle un littéral de chaîne. En Python (comme dans la plupart des langages de programmation), les littéraux de chaîne sont toujours entre guillemets, entourés de guillemets simples (') ou doubles ("). En Python, les guillemets simples et doubles sont équivalents; vous pouvez utiliser l'un ou l'autre, tant qu’ils correspondent aux deux extrémités de la chaîne, il est de tradition de représenter une chaîne lisible par l’homme (telle que Hello ) entre guillemets ( "Hello" ). Si vous représentez un seul caractère (tel que b ), ou un seul caractère spécial tel que le caractère de nouvelle ligne ( \ n ), il est de tradition d'utiliser des guillemets simples ( 'b', '\ n' ). Pour plus d'informations sur l'utilisation des chaînes en Python, vous pouvez consulter la documentation de chaînes. en Python.
La chaîne de déclaration .rstrip ('\ n') supprimera un caractère de nouvelle ligne du côté droit de la chaîne . La version suivante de notre programme supprime les nouvelles lignes lorsque chaque ligne est lue dans le fichier texte:
mylines = [] # Déclare une liste vide. avec open ('lorem.txt', 'rt') en tant que monfichier: # Ouvrez lorem.txt pour lire du texte. pour myline dans myfile: # Pour chaque ligne du fichier, mylines.append (myline.rstrip ('\ n')) # nouvelle ligne et ajouter à la liste. pour l'élément dans les lignes directrices: # pour chaque élément de la liste, print (element) # print it. Le texte est maintenant stocké dans une variable de liste afin que chaque ligne soit accessible par numéro d'index. Les nouvelles lignes ont été supprimées, nous n'avons donc pas à nous en soucier. Nous pouvons toujours les remettre plus tard si nous reconstruisons le fichier et l'écrivons sur le disque.
Maintenant, recherchons une sous-chaîne spécifique dans les lignes de la liste.
Disons que nous voulons localiser chaque occurrence d'une phrase donnée, voire une seule lettre. Par exemple, nous avons peut-être besoin de savoir où se trouve chaque "e". Nous pouvons accomplir cela en utilisant la méthode find () de la chaîne.
La liste stocke chaque ligne de notre texte en tant qu’objet chaîne. Tous les objets chaîne ont une méthode, find (), qui localise la première occurrence d'une sous-chaîne dans la chaîne.
Utilisons la méthode find () pour rechercher la lettre "e" dans la première ligne de notre fichier texte, qui est stockée dans la liste mylines . Le premier élément de mylines est un objet chaîne contenant la première ligne du fichier texte. Cet objet chaîne a une méthode find () .
Dans les parenthèses de find (), nous spécifions des paramètres. Le premier et unique paramètre requis est la chaîne à rechercher, "e" . L'instruction mylines [0] .find ("e") indique à l'interpréteur de commencer au début de la chaîne et de rechercher un caractère à la fois, jusqu'à ce qu'il trouve la lettre "e". Quand il en trouve un, il arrête la recherche et renvoie le numéro d'index où se trouve ce "e". S'il atteint la fin de la chaîne, il renvoie -1 pour indiquer que rien n'a été trouvé.
print (mylines [0] .find ("e")) Sortie
3
La valeur de retour "3" nous indique que la lettre "e" est le quatrième caractère, le "e" dans "Lorem". (N'oubliez pas que l'index est basé sur zéro: l'index 0 est le premier caractère, 1 est le deuxième, etc.)
La méthode find () prend deux paramètres supplémentaires facultatifs: un index de début et un index d' arrêt, indiquant le début et la fin de la recherche dans la chaîne. Par exemple, string .find ("abc", 10, 20) recherchera la sous-chaîne "abc", mais uniquement du 11ème au 21ème caractère. Si stop n'est pas spécifié, find () commencera au début de l'index et s'arrêtera à la fin de la chaîne.
Par exemple, l'instruction suivante recherche "e" dans mylines [0], en commençant au cinquième caractère.
print (mylines [0] .find ("e", 4)) Sortie
24
En d’autres termes, à partir du 5ème caractère de la ligne [0], le premier "e" est situé à l’indice 24 (le "e" dans "nec").
Pour commencer la recherche à l'index 10 et s'arrêter à l'index 30:
print (mylines [1] .find ("e", 10, 30)) Sortie
28
(Le premier "e" dans "Mécène").
Si find () ne localise pas la sous-chaîne dans la plage de recherche, il renverra le nombre -1, indiquant un échec:
print (mylines [0] .find ("e", 25, 30)) Sortie
-1
Il n'y a pas eu d'occurrence "e" entre les indices 25 et 30.
Trouver toutes les occurrences d'une sous-chaîne
Mais que se passe-t-il si nous voulons localiser chaque occurrence d'une sous-chaîne, pas seulement la première que nous rencontrons? Nous pouvons parcourir la chaîne en partant de l'index de la correspondance précédente.
Dans cet exemple, nous utiliserons une boucle while pour trouver à plusieurs reprises la lettre "e". Lorsqu'une occurrence est trouvée, nous appelons à nouveau la recherche, en partant d'un nouvel emplacement dans la chaîne. Plus précisément, l'emplacement de la dernière occurrence, plus la longueur de la chaîne (afin que nous puissions aller au-delà de la dernière). Lorsque find renvoie -1 ou que l'index de démarrage dépasse la longueur de la chaîne, nous nous arrêtons.
# Construisez des lignes mylines comme indiqué ci-dessus mylines = [] # Déclarez une liste vide. avec open ('lorem.txt', 'rt') en tant que monfichier: # Ouvrez lorem.txt pour lire du texte. pour myline dans myfile: # Pour chaque ligne du fichier, mylines.append (myline.rstrip ('\ n')) # nouvelle ligne et ajouter à la liste. # Localiser et imprimer toutes les occurrences de la lettre "e" index = 0 # index actuel prev = 0 # index précédent str = mylines [0] # chaîne à rechercher (premier élément de mylines) substr = "e" # sous-chaîne à rechercher tandis que index = len (str)) print ('\ n' + str); # Imprimer la chaîne d'origine sous les e Sortie
eeeee Lorem ipsum dolor sit amet, consectetur elit adipiscing. ee Nunc fringilla arcu congue metus aliquam mollis.
Incorporer des expressions régulières
Pour les recherches complexes, vous devez utiliser des expressions régulières.
Le module des expressions régulières Python est appelé re . Pour l'utiliser dans votre programme, importez le module avant de l'utiliser:
import re
Le module re implémente des expressions régulières en compilant un motif de recherche dans un objet motif. Les méthodes de cet objet peuvent ensuite être utilisées pour effectuer des opérations de correspondance.
Par exemple, supposons que vous souhaitiez rechercher un mot dans votre document qui commence par la lettre d et se termine par la lettre r . Nous pouvons accomplir cela en utilisant l'expression régulière " \ bd \ w * r \ b ". Qu'est-ce que ça veut dire?
| séquence de caractères | sens |
|---|---|
| \ b | Une limite de mot correspond à une chaîne vide (n'importe quoi, y compris rien du tout), mais uniquement si elle apparaît avant ou après un caractère autre qu'un mot. Les "caractères Word" sont les chiffres de 0 à 9, les lettres minuscules et majuscules ou un trait de soulignement (" _ "). |
| ré | Lettre minuscule d . |
| \ w * | \ w représente n'importe quel caractère du mot et * est un quantificateur signifiant "zéro ou plus du caractère précédent". Donc, \ w * correspondra à zéro ou plusieurs caractères. |
| r | Lettre minuscule r . |
| \ b | Limite de mot. |
Ainsi, cette expression régulière correspondra à toute chaîne pouvant être décrite comme "une limite de mot, puis une minuscule" d ", puis zéro ou plusieurs caractères de mot, puis une" minuscule "r, puis une limite de mot". Les chaînes qui peuvent être décrites de cette manière incluent les mots destroyer, dour et doctor, ainsi que l’abréviation dr .
Pour utiliser cette expression régulière dans les opérations de recherche Python, nous la compilons d’abord dans un objet pattern. Par exemple, l’instruction Python suivante crée un objet pattern nommé pattern que nous pouvons utiliser pour effectuer des recherches à l’aide de cette expression régulière.
pattern = re.compile (r "\ bd \ w * r \ b")
Remarque: la lettre r devant notre chaîne dans la déclaration ci-dessus est importante. Il dit à Python d'interpréter notre chaîne en tant que chaîne brute, exactement comme nous l'avons typée. Si nous ne préfixons pas la chaîne par un r, Python interprètera les séquences d'échappement telles que \ b d'une autre manière. Chaque fois que vous avez besoin que Python interprète littéralement vos chaînes, spécifiez-les en tant que chaîne brute en le préfixant avec r .
Nous pouvons maintenant utiliser les méthodes de l'objet modèle, telles que search () pour rechercher une chaîne pour l'expression régulière compilée, en recherchant une correspondance. S'il en trouve un, il retournera un résultat spécial appelé objet de correspondance. Sinon, elle renvoie Aucune, une constante Python intégrée utilisée comme la valeur booléenne "false".
Exemple
import re str = "Bonjour, docteur." pat = re.compile (r "\ bd \ w * r \ b") # compile une expression rationnelle "\ bd \ w * r \ b" en un objet modèle si pat.search (str)! = None: # Recherche le modèle. Si trouvé, imprimez ("trouvé.") Sortie
Je l'ai trouvé
Pour effectuer une recherche ne respectant pas la casse, vous pouvez spécifier la constante spéciale re.IGNORECASE lors de l'étape de compilation:
import re str = "Bonjour DoctoR." pat = re.compile (r "\ bd \ w * r \ b", re.IGNORECASE) # majuscule et minuscule correspond si pat.search (str)! = None: print ("trouvé le.") Sortie
Je l'ai trouvé
Mettre tous ensemble
Nous savons maintenant comment ouvrir un fichier, lire les lignes dans une liste et localiser une sous-chaîne dans un élément donné de cette liste. Utilisons cette connaissance pour construire quelques exemples de programmes.
Imprimer toutes les lignes contenant une sous-chaîne
Le programme ci-dessous lit un fichier journal ligne par ligne. Si la ligne contient le mot "erreur", elle est ajoutée à une liste appelée erreurs . Sinon, il est ignoré. La méthode de chaîne lower () convertit toutes les chaînes en minuscules à des fins de comparaison, rendant ainsi la recherche insensible à la casse sans modifier les chaînes d'origine.
Notez que la méthode find () est appelée directement sur le résultat de la méthode lower () ; c'est ce qu'on appelle la méthode de chaînage . Notez également que dans l'instruction print (), nous construisons une chaîne de sortie en joignant plusieurs chaînes avec l'opérateur + .
errors = [] # La liste où nous allons stocker les résultats. Linnum = 0 substr = "erreur" .lower () # Sous-chaîne à rechercher. avec open ('logfile.txt', 'rt') en tant que monfichier: pour une ligne dans monfichier: linum + = 1 si line.lower (). find (substr)! = -1: # si la correspondance ne respecte pas la casse, erreurs. append ("Line" + str (linnum) + ":" + line.rstrip ('\ n')) en cas d'erreur dans les erreurs: print (err) Sortie
Ligne 6: 28 mars 09:10:37 Erreur: impossible de contacter le serveur. Connexion rejetée. Ligne 10: 28 mars 10:28:15 Erreur de noyau: l'emplacement spécifié n'est pas monté. Ligne 14: 28 mars 11:06:30 ERREUR: usb 1-1: impossible de définir config, sortie.
Extraire toutes les lignes contenant une sous-chaîne, en utilisant regex
Le programme ci-dessous est similaire au programme ci-dessus, mais utilise le module expressions régulières. Les erreurs et les numéros de ligne sont stockés sous forme de n-uplets, par exemple (linum, line). Le tuple est créé par les parenthèses supplémentaires incluses dans l' instruction errors.append () . Les éléments du tuple sont référencés de manière similaire à une liste, avec un index de base zéro entre parenthèses. Tel que construit ici, err [0] est un linum et err [1] est la ligne associée contenant une erreur.
import re erreurs = [] linum = 0 pattern = re.compile ("erreur", re.IGNORECASE) # Compilez une expression rationnelle ne faisant pas de distinction entre les majuscules et les minuscules avec open ('logfile.txt', 'rt') comme myfile: pour la ligne dans mon fichier : linux + = 1 si pattern.search (line)! = None: # Si une correspondance est trouvée, errors.append ((linum, line.rstrip ('\ n'))) en cas d'erreur: # Iterate sur la liste des tuples imprimés ("Line" + str (err [0]) + ":" + err [1]) Sortie (comme ci-dessus)
Ligne 6: 28 mars 09:10:37 Erreur: impossible de contacter le serveur. Connexion rejetée. Ligne 10: 28 mars 10:28:15 Erreur de noyau: l'emplacement spécifié n'est pas monté. Ligne 14: 28 mars 11:06:30 ERREUR: usb 1-1: impossible de définir config, sortie.
Extraire toutes les lignes contenant un numéro de téléphone
Le programme ci-dessous imprime n’importe quelle ligne d’un fichier texte, info.txt, contenant un numéro de téléphone américain ou international. Il accomplit cela avec l'expression régulière " (\ + \ d {1, 2})? [\ S .-]? \ D {3} [\ s .-]? \ D {4} ". Cette expression rationnelle correspond aux notations de numéro de téléphone suivantes:
- 123-456-7890
- (123) 456-7890
- 123 456 7890
- 123.456.7890
- +91 (123) 456-7890
import re erreurs = [] linum = 0 modèle = re.compile (r "(\ + \ d {1, 2})? [\ s .-]? \ d {3} [\ s .-]? \ d {4} ") avec open ('info.txt', 'rt') en tant que monfichier: pour une ligne dans monfichier: linim + + 1 si pattern.search (line)! = Aucun: # si la recherche d'un modèle trouve une correspondance, des erreurs .append ((linumum, line.rstrip ('\ n'))) en cas d'erreur dans les erreurs: print ("Line", str (err [0]), ":" + err [1]) Sortie
Ligne 3: Mon numéro de téléphone est le 731.215.8881. Ligne 7: Vous pouvez joindre M. Walters au (212) 558-3131. Ligne 12: Son agent, Mme Kennedy, peut être contactée au +12 (123) 456-7890 Ligne 14: Elle peut également être contactée au (888) 312.8403, poste 12.
Rechercher des mots dans un dictionnaire
Le programme ci-dessous cherche dans le dictionnaire tous les mots commençant par h et finissant par pe . Pour l’entrée, il utilise un fichier dictionnaire inclus sur de nombreux systèmes Unix, / usr / share / dict / words .
import re nomfichier = "/ usr / share / dict / mots" modèle = re.compile (r "\ bh \ w * pe $", re.IGNORECASE) avec ouvert (nomfichier, "rt") en tant que myfile: for line in myfile: if pattern.search (line)! = None: print (line, end = '')
Sortie
Espoir heliotrope espoir battage médiatique horoscope