Je cherche à modifier un fichier 'sur place', de la manière la plus simple
possible, et j'aimerais avoir la possibilité de faire des sauvegardes
optionnels des fichiers...
Voici un petit bout de code simpliste pour expliquer ce que je voudrais :
# les méthodes de lecture sont celles de l'ancien fichier :
for attr in ('encoding', 'newlines', 'next', 'read',
'readinto', 'readline', 'readlines', 'seek',
'tell', 'xreadlines'):
setattr(self,attr,getattr(self.old,attr))
# les méthodes d'écritures sont celles du nouveau
for attr in ('closed','flush','write', 'writelines'):
setattr(self,attr,getattr(self.new,attr))
########################################################################
#
# Un petit example d'utilisation :
#
# equivalent de
# perl -i.bak -pe 's/\t+$//' *txt
from glob import glob
from re import compile, MULTILINE
regex = compile(r'\t+$',MULTILINE)
for f in [Modif_File(name) for name in glob('*.txt')]:
f.write(regex.sub('',f.read()))
f.close()
</ code >
Evidemment, sur cet exemple, l'intérêt de la version python par rapport à la
version perl est limité, mais c'est l'idée...
Est-ce qu'il existe qq part des modules qui font à peu près ça en plus
aboutis ?
Quelle est la méthode que vous utiliseriez pour faire ça ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Do Re Mi chel La Si Do
Bonsoir !
J'ai défini un truc assez compliqué. J'utilise une classe "UI", contenant des objets (instances) "User-Interface" (par exemple, un champ, un bouton, etc.) Pour chaque UI-objet, je crée des propriétés (dans un dictionnaire), indexées sur un évènement, et contenant le code-source qui sera exécuté, si l'évènement se déclenche.
Mon interface utilisateur (dans mes développements, Internet-Explorer), génère un appel, pour chacun des évènements, avec le nom de l'évènement, et la cible, en paramètres.
Il ne me reste plus qu'à lancer un : exec(UI[cible].method[event],globals(),globals())
Le code source est une chaîne de caractères, qui peut être lue, sauvegardée, ou éditée à la volée (ce sont des méthodes de la classe UI). Comme chaque instance de UI est mémorisée dans un dictionnaire, il m'est très facile de faire des traitements généraux, pour, par exemple, tout enregistrer, tout lire, etc.
Du coup, au lieu d'offrir aux utilisateurs une simple édition des routines, durant le travail, j'ai ajouté la possibilité d'intervenir sur d'autres propriétés de l'interface. Donc, s'ils ont le droit, les utilisateurs peuvent déplacer un bouton, changer son code, allonger un champ, etc. d'un écran de travail, sans sortir de celui-ci.
J'ai également vu la possibilité de modifier un écran de travail à distance (par TCP/IP, donc LAN ou Internet) durant son utilisation. Mais là, j'ai encore du travail.
Mais, bien que mon proto fonctionne, j'ai encore du travail pour terminer la mise au point.
Bonne nuit
Michel Claveau
Bonsoir !
J'ai défini un truc assez compliqué. J'utilise une classe "UI", contenant
des objets (instances) "User-Interface" (par exemple, un champ, un bouton,
etc.)
Pour chaque UI-objet, je crée des propriétés (dans un dictionnaire),
indexées sur un évènement, et contenant le code-source qui sera exécuté, si
l'évènement se déclenche.
Mon interface utilisateur (dans mes développements, Internet-Explorer),
génère un appel, pour chacun des évènements, avec le nom de l'évènement, et
la cible, en paramètres.
Il ne me reste plus qu'à lancer un :
exec(UI[cible].method[event],globals(),globals())
Le code source est une chaîne de caractères, qui peut être lue, sauvegardée,
ou éditée à la volée (ce sont des méthodes de la classe UI). Comme chaque
instance de UI est mémorisée dans un dictionnaire, il m'est très facile de
faire des traitements généraux, pour, par exemple, tout enregistrer, tout
lire, etc.
Du coup, au lieu d'offrir aux utilisateurs une simple édition des routines,
durant le travail, j'ai ajouté la possibilité d'intervenir sur d'autres
propriétés de l'interface. Donc, s'ils ont le droit, les utilisateurs
peuvent déplacer un bouton, changer son code, allonger un champ, etc. d'un
écran de travail, sans sortir de celui-ci.
J'ai également vu la possibilité de modifier un écran de travail à distance
(par TCP/IP, donc LAN ou Internet) durant son utilisation. Mais là, j'ai
encore du travail.
Mais, bien que mon proto fonctionne, j'ai encore du travail pour terminer la
mise au point.
J'ai défini un truc assez compliqué. J'utilise une classe "UI", contenant des objets (instances) "User-Interface" (par exemple, un champ, un bouton, etc.) Pour chaque UI-objet, je crée des propriétés (dans un dictionnaire), indexées sur un évènement, et contenant le code-source qui sera exécuté, si l'évènement se déclenche.
Mon interface utilisateur (dans mes développements, Internet-Explorer), génère un appel, pour chacun des évènements, avec le nom de l'évènement, et la cible, en paramètres.
Il ne me reste plus qu'à lancer un : exec(UI[cible].method[event],globals(),globals())
Le code source est une chaîne de caractères, qui peut être lue, sauvegardée, ou éditée à la volée (ce sont des méthodes de la classe UI). Comme chaque instance de UI est mémorisée dans un dictionnaire, il m'est très facile de faire des traitements généraux, pour, par exemple, tout enregistrer, tout lire, etc.
Du coup, au lieu d'offrir aux utilisateurs une simple édition des routines, durant le travail, j'ai ajouté la possibilité d'intervenir sur d'autres propriétés de l'interface. Donc, s'ils ont le droit, les utilisateurs peuvent déplacer un bouton, changer son code, allonger un champ, etc. d'un écran de travail, sans sortir de celui-ci.
J'ai également vu la possibilité de modifier un écran de travail à distance (par TCP/IP, donc LAN ou Internet) durant son utilisation. Mais là, j'ai encore du travail.
Mais, bien que mon proto fonctionne, j'ai encore du travail pour terminer la mise au point.