Discussion :

[anass_59]

Slt tout le monde
voilà je vous propose de jetter un coup d'oeil au programme suivant qui parcour un text donné:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
def avance(S):
    i=0
    while True:
        Mot=''
        while not S[i].isalpha():
            i+=1
        while S[i].isalpha():
            Mot+=S[i]
            i+=1
        yield Mot        
 
 
def  main():
    S= "bru-11-r6.car.belbone.be"
    A=avance(S)
    try:
        while True:
            print A.next()
    except IndexError:
        print "C'est fini"
 
main()

Question:
1 - Lors de l'affichage il n'y a pas l'apparition des chiffre, comment faire pour y remédier.

2 - Si je veux qu'à la place d'une petite phrase, faire la même démarche avec un document txt, comment s'y prendre??

Merci d'avance

[vincent.mbg]

pour les chiffres tu a isdigit()

[eyquem]

Et bien tu te débrouilles pas mal d'après ce que je vois avec ton code.

La discussion suivante devrait t'être pas mal utile
http://www.developpez.net/forums/d73...vancer-chaine/

Bon, il semble que tu veuille faire une analyse de texte "naturel", et non pas une analyse syntaxique informatique.

Je n'aime pas trop les trucs liés au langage naturel, sauf quand c'est bien délimité, parce que c'est un champ aux frontières floues. Un langage inforamtique est quelque chose de fortement structuré et bien défini, une analyse syntaxique on voit comment la mener. Mais les questions de linguistiques, ça peut dériver à l'infini, il est susceptible de survenir des cas particuliers n'ayant pas été envisagé à n'importe quel moment. Un programme qui s'occupe d'une telle analyse est une marmite sur le feu, il faut toujours le surveiller.
C'est l'idée que j'ai de ces choses, mais je ne suis pas un spécialiste.

Sinon, à la place de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while not S[i].isalpha():

tu pourrais peut être utiliser à la place

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while S[i} not in [' ','"',',','-'...]

etc et tout autre caractère que tu ne souhaites pas être considéré comme étant un caractère constituant des mots. Ce serait plus extensif à volonté. À toi de voir.

Je pense aussi que tu ferais sans doute bien de te mettre à l'étude des expressions régulières car, s'il est vrai qu'il ne faut pas en devenir un maniaque et les utiliser à tout bout de champ même quand elles sont le moins justifiées, c'est un outil très utile, et dans certains cas incontournable, à mon avis.

[eyquem]

J'ai bien l'impression que tu as pompé ton code dans le lien que j'ai donné ensuite !
Ce qui prouve qu'au moins tu as fait des recherches.

Voici une solution qui n'a pas été donnée dans la discussion en question, enfin je crois, j'ai regardé rapidement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
from string import maketrans
chars = '-."'
tab = maketrans(chars,len(chars)*' ')
 
S= "bru-11-r6.car.belbone.be"
 
ch = S.translate(tab)
print ch
print ch.split()

Resultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
bru 11 r6 car belbone be
['bru', '11', 'r6', 'car', 'belbone', 'be']

Dans maketrans(cha,chb) , les deux chaines de caractères cha et chb doivent avoir la même longueur.
Au lieu d'écrire maketrans('-".',' ') j'ai écrit comme ci-dessus pour faciliter l'extension de chars sans avoir à penser à rajouter un blanc dans la seconde chaîne.

[oiffrig]

Sinon, pour vérifier si un caractère est alphanumérique il y a la méthode isalnum()

[anass_59]

Bonjour tout le monde,
Je vois qu'il y a beaucoup de solutions concernant la distinction entre isalpha et isalnum,mais e vrai problème, c'est que je n'arrive pas à ouvrir le fichier "bru-11-r6.car.belbone.txt", je ne sais pas si c'est un problème d'emplacement du fichier ou autre.
En tout cas durant ce week end, c'est ce que j'ai trouvé comme solution mais malgré ca ca ne marche pa, à vous de juger:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#!/usr/bin/python  
# -*- coding: UTF-8 -*-   
 
import re  
import sys   
 
def listeMot(ligne): 
     mot =["empty"] 
     mots = re.findall('\w*', ligne) #match tous les caractère alphanumérique consécutif 
     for mot in mots: 
          if mot == "":              #les match nul renvoi une chaine videjusqu au prochain  
          mots.remove(mot)           #match je les supprime donc ici 
     return mots 
 
#exemple 
motsLigne = listeMot("okdok oakzd?.azd23.diqjij") 
for mot in motsLigne: 
     print mot 
 
 
def main(): 
     mots =["code"]
     myFile = open("test.txt",'r')             #fichier situé dans le même dossier             
     for ligne in myFile:                      #que le script 
          mots.extend(listeMot(ligne))         #concaténation de chaques listes de mots  
     print "fini liste des mots : "         #recuperés 
     for mot in mots: 
          print mot 
 
main()

[anass_59]

Je viens de changer le chemin du fichier que je veux ouvrir, mais voilà ce que ca affiche :

>>>
okdok
oakzd
azd23
diqjij


Traceback (most recent call last):
File "C:/Python23/Ouvrir un texte.py", line 30, in -toplevel-
main()
File "C:/Python23/Ouvrir un texte.py", line 22, in main
mots =[code]
NameError: global name 'code' is not defined


Si quelqu'un pourrait trouver l'orogine du problème rapidement ca serait vraiment trs sympa

[anass_59]

Ca y est j'y suis arrivé, j'ai résolu le problème.
Merci à tous pour votre aide
slt slt

PS: il fallait supprimer mots[code] et mettre des [], car il ne reconnaissat pas la variable code, en plus j'ai redéfinies le chemin du fichier en question en remplacant '\' par '\\'

[eyquem]

Dans la fonction listeMot(ligne):
- si tu as bien voulu écrire mot =["empty"] : à quoi sert cette définition puisque un peu plus loin mot devient du type chaîne dans la boucle for mot in mots?
- si tu as voulu écrire mots =["empty"] : cette instruction est superflue. L'instruction mots = re.findall('\w*', ligne) crée la liste mots, elle ne fait pas que la remplir.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
    for mot in mots: 
        if mot == "":  
            mots.remove(mot)
    return mots

peut être remplacé par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return [ mot for mot in mots if mot!=""]

Ton code est l'occasion pour moi de découvrir quelque chose que je ne connaissais pas:
avec une RE constituée de char* , où char représente 1 caractère quelle que soit la manière dont il est spécifié, on matche:
- toute répétition du caractère char, * valant alors 'plusieurs'
- tout caractère qui n'est pas char, y compris la blanc: * vaut alors 0, c'est pourquoi ça ne matche qu'un caractère et non pas une succession même s'il y a par exemple plussieurs blancs qui se succèdent

Quand je dis "quelle que soit la manière dont il est spécifié", cela signifie qu'on peut avoir char* égal à :
r* (n'importe quelle lettre)
[aeiou]*
[a-p]*
[a-z0-7]*
\w*
\d*
\D*
\s*
etc...

Pour éviter ce comportement, il faut écrire ta RE: '\w+'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
def listeMot(ligne):
    mot =["empty"] 
    mots = re.findall('\w*', ligne) #match tous les caractère alphanumérique consécutif
    print mots
    for mot in mots: 
        if mot == "":              #les match nul renvoi une chaine videjusqu au prochain  
            mots.remove(mot)           #match je les supprime donc ici 
    return mots 
 
#exemple 
motsLigne = listeMot("okdok oakzd?.azd23.diqjij") 
for mot in motsLigne: 
     print mot

peut être abrégé en :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for mot in re.findall('\w*', "okdok oakzd?.azd23.diqjij") :
    print mot

et ton code peut devenir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
import re
mots = []
myFile = open("test.txt",'r')
for ligne in myFile:
     mots.extend(re.findall('\w+', ligne))
myFile.close()
print "fini liste des mots : "
print '\n'.join(mots)

Remarque le close() c'est mieux de ne pas l'oublier.
Si tu écris ' '.join(mots) tu auras les mots sur une seule ligne séparés par des blancs.



Tu as trouvé pour mot[code].
Mais qu'elle était ton intention en écrivant cette instruction ?

[anass_59]

Je sais qu'il y a des choses à ajouter mais voilà la version que j'ai finalement adopté:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
 
# -*- coding: cp1252 -*-
 
 
import re  
import sys   
 
def listeMot(ligne): 
     mot =["empty"] 
     mots = re.findall('\w*', ligne) #match tous les caractère alphanumérique consécutif 
     for mot in mots: 
          if mot == "":              #les match nul renvoi une chaine videjusqu au prochain  
              mots.remove(mot)           #match je les supprime donc ici 
     return mots 
 
def main(): 
     mots =[]
     myFile = open("C:\\Documents and Settings\\All Users\\bru-11-r6.car.belbone.rtf",'r')             #fichier situé dans le même dossier             
     for ligne in myFile:                      #que le script 
          mots.extend(listeMot(ligne))         #concaténation de chaques listes de mots  
     print "fini liste des mots : "         #recuperés 
     for mot in mots: 
          print mot 
 
main()

J'ai carrément enlever l'exemple car je n'en ai pas besoin, tout ce que je veux c'est ouvrir le fichier. Mais une fois ce fichier ouvert, je rencontre deux petits problèmes:

1 - L'affichage du texte dans le fenetre interactive n'est pas le meme que celui dans le document d'origine. Par exemple les caractères come '\n' retour chariot est repris par '\par' puis retour à la ligne, en plus que la ponctuation ce n'est pas du tout ca, car à chaque fois qu'il rencontre des caractères spéciaux il reviens à la ligne, ce qui peux poser problème lors de la récupération des données.

2 - Je ne suis pas un champions pour trier sr python, je voudrais une méthode efficace pour déterminer moi meme les mots que je veux afficher sur la fenetre interactive.

Merci

[eyquem]

Tu te lances dans quelque chose qui présente une double difficulté:
- l'analyse d'un fichier
- le véritable contenu d'un fichier en fonction de son format

Il faut d'abord avoir un minimum de compréhension sur le contenu des fichiers.
Voici pour comprendre:

- Créer un document .txt
Personnellement, j'ai Windows, et pour faire cela, je clique droit sur le bureau, puis dans le menu, sur New/Text Document : cela crée un document .txt sur le bureau. Je le déplace ensuite où je veux.
Une fois créé, le renommer en "fleurs.txt", l'ouvrir et y écrire:
Rose
Tulipe
Marguerite
Le refermer.

Si on le rouvre en lecture, il va s'afficher:
Rose
Tulipe
Marguerite
Pas très instructif.

Si on fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
f = open("fleurs.txt",'r')
ch = f.read()
f.close()
print repr(ch)

on obtient l'affichage
'Rose\nTulipe\nMarguerite' qui est la représentation du contenu exact du fichier.

Cela signifie que le contenu du fichier est la succession de caractères Rose\nTulipe\nMarguerite
L'affichage interprète ce contenu pour afficher à l'écran
Rose
Tulipe
Marguerite
et 'Rose\nTulipe\nMarguerite' est une représentation du contenu du fichier par une chaîne obtenue par la fonction repr().

En bleu, je mets les affichages.
En vert, les représentations données par repr() (c'est aussi des affichages...)
En marron, les contenus de variable ou de fichier, c'est à dire leurs valeurs



- Sous Windows, il y a une subtilité.
La succession Rose\nTulipe\nMarguerite comporte 22 caractères.
Si on clique sur Propriétés du fichier, on obtient une réponse indiquant qu'il fait 24 bytes.
Les deux bytes en plus sont deux caractères \r que le système d'exploitation rajoute pour inscrire sur le disque dur des fins de ligne à sa façon, c'est à dire \r\n.

Si on veut voir ces fins de lignes exactement, il faut ouvrir en 'rb'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
f = open("fleurs.txt",'rb')
ch = f.read()
f.close()
print repr(ch)

On obtient la représentation 'Rose\r\nTulipe\r\nMarguerite' du contenu réel Rose\r\nTulipe\r\nMarguerite du fichier.



- Faisons maintenant la même chose avec un fichier .rtf
Créer un document .rtf
Personnellement, j'ai Windows, et pour faire cela, je clique droit sur le bureau, puis dans le menu, sur New/Rich Text Document : cela crée un document .rtf sur le bureau. Je le déplace ensuite où je veux.
Une fois créé, le renommer en "volailles.rtf", l'ouvrir et y écrire:
Poule
Canard sauvage
Dinde
Mettre en gras le mot sauvage
Poule
Canard sauvage
Dinde
et refermer le fichier.

Si on le rouvre en lecture, on ne va voir s'afficher que
Poule
Canard sauvage
Dinde

Mais si on regarde la taille: 168 bytes. Ouhla !
On regarde le contenu exact en ouvrant en 'rb':

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
f = open("volailles.rtf",'rb')
ch = f.read()
f.close()
print repr(ch)

La représentation obtenue est
'{\\rtf1\\ansi\\ansicpg1252\\deff0\\deflang1036{\\fonttbl{\\f0\\fswiss\\fcharset0 Arial;}}\r\n\\viewkind4\\uc1\\pard\\f0\\fs20 Poule\\par\r\nCanard \\b sauvage\\b0\\par\r\nDinde\\par\r\n\\par\r\n}\r\n\x00'

Là aussi il y a une subtilité.

On peut regarder le contenu d'une autre manière: on renomme le fichier en "volailles.txt" et on l'ouvre normalement. Il s'affiche
{\rtf1\ansi\ansicpg1252\deff0\deflang1036{\fonttbl{\f0\fswiss\fcharset0 Arial;}}
\viewkind4\uc1\pard\f0\fs20 Poule\par
Canard \b sauvage\b0\par
Dinde\par
\par
}

Comme le format du fichier a été modifié en .txt, l'interprétation de ce fichier ne se fait pas selon les règles d'interprétation de .rtf mais de .txt.

Il n'y a plus que des slashes simples et l'affichage fait les retours à la ligne indiqués dans le contenu du fichier.
Quand on lit le fichier renommé en volailles.txt, l'interpréteur de format .txt lit tous les caractères et n'interprète que les \r\n pour ce qu'ils représentent , des retours à la ligne; tous les autres caractères sont lus et affichés tels quels.
S'il n'affiche que des simples slashes et non des doubles, c'est donc que le contenu du fichier ne comporte pas des doubles slashes mais des simples. D'ailleurs si on compte le nombres de caractères dans l'affichage
{\rtf1\ansi\ansicpg1252\deff0\deflang1036{\fonttbl{\f0\fswiss\fcharset0 Arial;}}
\viewkind4\uc1\pard\f0\fs20 Poule\par
Canard \b sauvage\b0\par
Dinde\par
\par
}

on trouve 155 caractères.
En additionnant les 12 caractères des 6 retours à la ligne + le caractère \x00 affiché par programme Python à la fin, on trouve bien 168 caractères.


S'il y a des doubles slashes dans la représentation du contenu du fichier obtenue par un programme Python, c'est parce que la fonction repr() représente son argument sous forme d'une chaîne Python, que le slash \ est le caractère d'échappement dans les chaînes Python et qu'il y a des slashes qui ne sont pas des slashes d'échappement dans le contenu de fichier à représenter:

pour représenter les deux caractères \ r successifs c'est à dire \ puis r, et non pas l'unique caractère représenté par l'accolement indissociable des deux caractères \r, il faut échapper le slash, et pour cela il faut ...un slash devant le slash !




- Y a un truc mortel: une représentation fournie par la fonction repr() est elle même un affichage. Donc pour produire à l'écran un affichage qui produise l'effet désiré, c'est à dire la représentation exacte de la valeur d'une variable ou du contenu exact d'un fichier, il faut que la vraie valeur de repr() soit telle que cet affichage ait lieu. Si par exemple une repr() doit faire afficher \r, il faut que sa valeur comporte \\r !!
Ça peut se vérifier en faisant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
f = open("fleurs.txt",'rb')
ch = f.read()
f.close()
print repr(ch)
print repr(repr(ch))

On obtient:
'Rose\r\nTulipe\r\nMarguerite'
"'Rose\\r\\nTulipe\\r\\nMarguerite'"



- Il est clair que les 140 caractères supplémentaires dans volailles.rtf par rapport au même texte dans volailles.txt sont des caractères qui qualifient le fichier comme un fichier .rtf et qu'ils sont là pour être interprétés par l'afficheur de fichier .rtf
J'ai cherché sur internet des renseignements sur la structure des fichiers .rtf mais je n'en ai pas trouvé et j'en ai été réduit à comprendre tout seul. Il me semble que ce qui précède suffit pour se débrouiller. Si je me trompe sur certains points , merci de m'expliquer.

Tout ça permet donc de comprendre que les par qui apparraissent quand tu appliques ton code ne sont pas des parenthèses dans le fichier, ce sont les caractères par présents de façon tout à fait normale dans un fichier .rtf

Pour en être tout à fait convaincu, il suffit de regarder autour du mot sauvage: il est écrit
\b sauvage\b0
On voit bien que les caractères \b et \b0 spécifient la mise en gras.



- Pour le reste, l'explication est dans ce que j'ai déjà écrit plus haut.
Ta regex étant créée à partir de la RE '\w*' , * = 0 ou plusieurs, il se passe que lorsque le moteur de regex tombe sur un caractère qui n'appartient pas à l'ensemble symbolisé par \w , il déclare qu'il y a matching selon '\w0' . Puisque c'est zéro, il ne cherche pas à voir si la suite est une répétition puisque le caractère qui vient d'être trouvé non matchant ne peut pas être le premier terme d'une répétition..... Le moteur de regex passe au caractère suivant et se redemande s'il s'agit d'un caractère de type \w. Tant que ce n'est pas le cas, il va additionner des vides "" comme étant des matches avec les mauvais caractères. D'où ta necessité d'éliminer ces "" après, travail inutile à cause d'une * au lieu de + . Si tu ne prêtes pas attention à ce qu'on t'écrit, tu vas avoir du mal.

[anass_59]

Ok

[anass_59]

Jusqu'à présent la meilleur représentation du texte d'origine reste avec ce programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
 
myFile = open("C:\\Documents and Settings\\All Users\\bru-11-r6.car.belbone.rtf",'r')   #Ouverture du fichier             
for ligne in myFile:                                                                    
    print ligne                                                                         #Affichage du fichier

Le seul petit problème reste le fait que le caractère retour chariot '\n' est repris par '\par" suivis du retour à la ligne.

1 - Est ce que c'est normal que cela s'affiche lors de l'execusion, et pourquoi ca?

2 - comment faire pour le supprimer ?

[eyquem]

Je regrette de dire ça mais tu as une façon d'exposer les problèmes un peu spéciale.
- Dans ton message #1, tu titres "Ouverture fichier text " puis tu donnes un code qui traite une chaîne.
- Dans le #6, tu appliques ton code de nouveau à une chaîne et aussi à un texte de fichier de format .txt
Bon, ça parait normal, vu que, à ma connaissance, il n'y a dans un fichier .txt que des caractères \r et \n en plus des caractères destinés à être écrit à l'écran lors d'un affichage, et que ces caractères \r et \n ne sont pas du type défini par le \w qu'il y a dans ta regex.
Ce code cherche à isoler des mots dans une chaîne ou une ligne de texte.
- Dans le #9, je t'indique comment condenser ton code et je corrige aussi '\w*' en '\w+'.
- Dans le #10, tu remets ton code sans modification, y compris avec '\w*'. Mais cette fois tu l'appliques à un fichier de format .rtf et tu parles encore de déterminer des mots. Évidemment avec un fichier .rtf , il y a des problèmes nouveaux.
- Dans #11, je fais un grand laïus pour bien fixer les choses concernant le contenu d'un fichier .rtf et comment examiner précisément ce contenu, pensant qu'avec ces explications tu pourras commencer à construire toi-même un code qui va prendre en charge la gestion des caractères non voulus ou que tu préciseras ce que tu veux faire puisqu'on est passé d'un fichier .txt dans lequel il n'y a que des mots et des \r\n à un fichier .rtf dans lequel il y a des lignes préalables au texte lui-même et que ce dernier contient des faux mots \par et est susceptible d'en contenir d'autres (servant au formatage, comme la mise en gras, le soulignement,etc).
- Mais non. Dans le #12 tu t'exprimes d'une façon qui montre que tu ne sembles pas bien saisir les choses précisément. Par dessus le marché, en #12 c'est un code pour isoler des mots, dans #13 c'est un code pour afficher des lignes.
Alors que s'agit-il de faire ? Isoler des mots ou pas ?

En plus de reprendre le caractère '(' ou ')' par (par)

le caractère retour chariot '\n' est repris par '\par" suivis du retour à la ligne.
1 - Est ce que c'est normal que cela s'affiche lors de l'execusion, et pourquoi ca?

Réponse

les par qui apparraissent quand tu appliques ton code ne sont pas des parenthèses dans le fichier, ce sont les caractères par présents de façon tout à fait normale dans un fichier .rtf
message #11

Pour voir le contenu exact du fichier (je complète une indication que j'ai déjà donnée):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
myFile = open("C:\\Documents and Settings\\All Users\\bru-11-r6.car.belbone.rtf",'rb')
li = myFile.readlines()
myFile.close()
for ln in li:
    print repr(ln)

readlines() est la condensation de read() et splitlines(True) :ça lit un fichier en le mettant en liste de lignes tout en gardant les symboles de retour à la ligne.
En ouvrant en 'rb', les symboles de retour à la ligne restent \r\n dans la liste obtenue s'ils sont tels dans le fichier, sinon en 'r' Python ne garde que les \n.

chaque fois qu'il termine une chaine et rencontre un espace blanc il y a retour chariot

Le retour de chariot n'est pas dû à l'espace blanc rencontré. D'ailleurs il n'y a pas que les espaces blancs qui produisent cela: tout caractère non \w donne la même chose, comme les \ présents devant par, etc....
Le retour chariot est dû au '\n' de '\n'.join(mots)
'\n'.join(mots) joint les mots de la liste mots avec des \n.
Par exemple, 'n'.join(['salade','viande hachée','yaourt']) donne la chaîne 'salade\nviande hachée\nyaourt' qui à l'affichage va donner
salade
viande hachée
yaourt
J'ai mis ce '\n' pour obtenir justement ce retour chariot parce que c'est l'effet que produit le print dans ton code du #6

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for mot in motsLigne: 
     print mot

mais j'ai précisé quelque part que pour ne pas avoir ce retour à la ligne entre chaque mot il suffisait d'écrire:
" ".join(mots) , avec un blanc entre les " "


----------------------------------------------


Bon, voilà pour ce qui est question méthode. Maintenant pour ce qui est de répondre à ton problème:
d'après ce que j'ai vu en analysant le contenu exact d'un fichier .rtf,
ce contenu se présente de la façon suivante:

{\rtf1\ansi\ansicpg1252\deff0{\fonttbl{\f0\fnil\fcharset0 Courier New;}}\r\n
\viewkind4\uc1\pard\lang1033\f0\fs20 blabla1\par\r\n
blabla2\par\r\n
blabla3\par\r\n
blabla4\par\r\n
.....
blablaN-2\par\r\n
blablaN-1\par\r\n
blablaN\par\r\n
}\r\n
\x00

Ceci est un contenu de fichier, ce n'est pas un affichage par repr()
Pour clarté, j'ai écrit en séparant les lignes,quoique dans le fichier tous les caractères soient à la suite les uns des autres.
On voit que la première ligne est du codage de fromat .rtf, ainsi que le début de la deuxième ligne jusqu'au premier blanc.
Les deux dernières lignes sont aussi des lignes qui ne sont pas du contenu affichable.

Je pourrais écrire le code qui ne prend pas en compte la première et les deux dernières lignes et qui ne prend de la deuxième que ce qu'il y a après le blanc, et qui élimine les \par\r\n , mais il faut bien te laisser chercher. Je m'attendais à ce que tu l'aies déjà fait, après avoir pu regarder en détail le contenu précis d'un fichier avec repr() et mes explications.

[anass_59]

Tout d'abord,je tiens à m'excuser pour les informations un peu ambigues que je poste souvent, car après tout je reçois beaucoup de nouvelles notions nouvelles pour moi, et je n'ai que peu de temps pour réaliser le travail

Ce que je cherche à faire en fait, c'est tout simplement dans un premier temps ouvrir le fichier .rtf normalement. Grâce au programme que voici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 
 
myFile = open("C:\\Documents and Settings\\All Users\\bru-11-r6.car.belbone.rtf",'r')   #Ouverture du fichier             
for ligne in myFile:                                                                    
    print ligne                                                                         #Affichage du fichier

Tout est OK, ca marche à la perfection.

Maintenant que cette première partie du projet est terminée, je cherche à effectuer des filtres et des tris lors de l'ouverture d'un fichier du genre. Par exemple, chercher un mot qui se répète souvent dans le document et n'afficher que les données qui le précèdent. Ou encorepermettre directement à celui qui utilise le programme, d'afficher les données qu'il désire (ca serait le paradis !! )

[eyquem]

#13

myFile = open("C:\\Documents and Settings\\All Users\\bru-11-r6.car.belbone.rtf",'r')
for ligne in myFile:
print ligne

Le seul petit problème reste le fait que le caractère retour chariot '\n' est repris par '\par" suivis du retour à la ligne.

#15

myFile = open("C:\\Documents and Settings\\All Users\\bru-11-r6.car.belbone.rtf",'r')
for ligne in myFile:
print ligne

Tout est OK, ca marche à la perfection.

Vraiment bizarre.............
Bon ça ne fait rien, on verra plus tard.

je cherche à effectuer des filtres et des tris lors de l'ouverture d'un fichier du genre

Pour être un peu rigoureux, je dirais que l'ouverture est une chose et qu'un traitement du texte du fichier en est une autre , qui vient postérieurement à l'ouverture. Mais ça ne peut pas se faire en même temps.
Ouverture de fichier = essentiellement une sollicitation du système d'exploitation pour lui faire positionner un pointeur dans les données du fichier inscrites dans le disque dur et le mettre en état d'obéir à des ordres qui peuvent être donnés par read() , readline() , readlines() ,seek() ,tell() ,write() . Il faut lire la documentation pour savoir ce que font ces fonctions.
Les types d'ordre autorisés dépendent du mode d'ouverture du fichier, spécifié par 'r','a','w','r+','U','U+',etc.




Faire print ligne n'est pas une instruction qui permet d'analyser un fichier.
Pour traiter les données d'un fichier, il faut d'abord les avoir mises dans une structure de données.
On peut mettre le contenu du fichier dans une chaîne avec read() ou dans une liste avec readlines().
À cette occasion, on peut déjà faire une sélection dans les données qu'on met en mémoire en chaîne ou en liste.
Par exemple si on fait d'abord seek(20) avant de lire le fichier, le pointeur va avancer de 20 caractères et on ne lira ensuite que les caractères suivants.
Ou bien pour sauter la première ligne, on peut faire agir une fonction citée plus haut.
Il faut se creuser les méninges.

----------------

Ensuite, une fois les données mises en chaîne ou en liste, on peut s'attaquer à un traitement de ces données.

Soyons concret:

chercher un mot qui se répète souvent dans le document

En sachant a priori que le mot se répète souvent , ou en faisant trouver ce ou ces mots répétitifs par le programme lui-même ?

n'afficher que les données qui le précèdent

Fastoche, à condition de savoir ce que veut dire précisément "qui le précèdent". Jusqu'où ?

permettre directement à celui qui utilise le programme, d'afficher les données qu'il désire

Rien de difficle.
Mais tu veux dire : les données d'un certain type ?
Parce que sinon, si l'utilisateur connaît a priori les données, à quoi servirait-il de les chercher dans le texte ?
La question qui se pose est en fait: quel type de données ? quelles caractéristiques de ces données permettent de les localiser dans le texte ? il faut être plus précis. Par exemple, s'il s'agit d'une température, on cherchera les chiffres situés entre les chaines'T = ' et 'degres celsius'. mais il faut un minimum d'information sur ce qu'on cherche.

PS

Regarde
- la méthode de chaîne find()
- la classe de création d'un type particulier de dictionnaire bien utile pour les décomptes: defaultdict()

Il y a aussi plein de discussions sur le forum concernant la recherche de mots , de décompte de mots, de tris en fonction de leurs occurences.