Conversion de caracteres accentues en ces memes caracteres non accentues

Salut !


Je me suis construit un truc un peu "boeuf". L'avantage, c'est que me
construit autant de dicos que de besoins (extraction des numériques seuls ;
conversion en ascii, en majuscules "à ma façon" ; suppression d'ensembles de
caractères ; etc.)

Voilà un exemple :


mappingcharmaj = {
chr(97):'A', chr(98):'B', chr(99):'C', chr(100):'D', chr(101):'E',
chr(102):'F', chr(103):'G', chr(104):'H',
chr(105):'I', chr(106):'J', chr(107):'K', chr(108):'L', chr(109):'M',
chr(110):'N', chr(111):'O', chr(112):'P',
chr(113):'Q', chr(114):'R', chr(115):'S', chr(116):'T', chr(117):'U',
chr(118):'V', chr(119):'W', chr(120):'X',
chr(121):'Y', chr(122):'Z', chr(127):' ', chr(128):'E', chr(129):'.',
chr(130):',', chr(131):'F', chr(132):'"',
chr(133):'.', chr(134):'+', chr(135):'+', chr(137):'%', chr(138):'S',
chr(139):'<', chr(140):'O', chr(141):'.',
chr(142):'Z', chr(143):'.', chr(144):'.', chr(145):''', chr(146):''',
chr(147):'"', chr(148):'"', chr(149):'.',
chr(150):'-', chr(151):'_', chr(152):'-', chr(153):'.', chr(154):'S',
chr(155):'>', chr(156):'O', chr(157):'.',
chr(158):'Z', chr(159):'Y', chr(160):'.', chr(161):'I', chr(162):'C',
chr(163):'L', chr(164):'+', chr(165):'Y',
chr(166):'|', chr(167):'S', chr(168):'?', chr(169):'C', chr(170):'A',
chr(171):'<', chr(172):'.', chr(173):'-',
chr(174):'R', chr(175):'-', chr(176):'O', chr(177):'+', chr(178):'2',
chr(179):'3', chr(180):''', chr(181):'U',
chr(182):'.', chr(183):'.', chr(184):',', chr(185):'1', chr(186):'O',
chr(187):'>', chr(188):'4', chr(189):'2',
chr(190):'4', chr(191):'?', chr(192):'A', chr(193):'A', chr(194):'A',
chr(195):'A', chr(196):'A', chr(197):'A',
chr(198):'A', chr(199):'C', chr(200):'E', chr(201):'E', chr(202):'E',
chr(203):'E', chr(204):'I', chr(205):'I',
chr(206):'I', chr(207):'I', chr(208):'D', chr(209):'N', chr(210):'O',
chr(211):'O', chr(212):'O', chr(213):'O',
chr(214):'O', chr(215):'X', chr(216):'O', chr(217):'U', chr(218):'U',
chr(219):'U', chr(220):'U', chr(221):'Y',
chr(222):'P', chr(223):'B', chr(224):'A', chr(225):'A', chr(226):'A',
chr(227):'A', chr(228):'A', chr(229):'A',
chr(230):'A', chr(231):'C', chr(232):'E', chr(233):'E', chr(234):'E',
chr(235):'E', chr(236):'I', chr(237):'I',
chr(238):'I', chr(239):'I', chr(240):'O', chr(241):'N', chr(242):'O',
chr(243):'O', chr(244):'O', chr(245):'O',
chr(246):'O', chr(247):'+', chr(248):'O', chr(249):'U', chr(250):'U',
chr(251):'U', chr(252):'U', chr(253):'Y',
chr(254):'B', chr(255):'Y'}


def conv(chaine, mappingchar=mappingcharmaj):
return=''.join([mappingchar.get(i, i) for i in chaine])





@-salutations

Michel Claveau

Do Re Mi chel La Si Do écrivait le 22/06/05 10:45 :

Je me suis construit un truc un peu "boeuf". L'avantage, c'est que me
construit autant de dicos que de besoins (extraction des numériques seuls ;
conversion en ascii, en majuscules "à ma façon" ; suppression d'ensembles de
caractères ; etc.)

Ça n'est pas un module mais c'est très intéressant pour un newbie en
python comme moi. ;)

Merci Michel pour ce partage. :)

--
Frédéric Momméja

On 22-06-2005, Frédéric Momméja wrote:

Bonjour à tous,

j'aimerais savoir si l'un d'entre vous connaît un module ou une manière
élégante qui permette de transformer les caractères accentués d'une
phrase en leur équivalent non accentué ?

string.translate(s,string.maketrans("ÀÁÂÃÄÅàáâãäåÒÓÔÕÖØòóôõöøÈÉÊËèéêëÇçÌÍÎÏìíîïÙÚÛÜùúûüÿÑñ","aaaaaaaaaaaaooooooooooooeeeeeeeecciiiiiiiiuuuuuuuuynn"))


--
William Dodé - http://flibuste.net

William Dodé écrivait le 22/06/05 11:14 :

On 22-06-2005, Frédéric Momméja wrote:

j'aimerais savoir si l'un d'entre vous connaît un module ou une manière
élégante qui permette de transformer les caractères accentués d'une
phrase en leur équivalent non accentué ?

string.translate(s,string.maketrans("ÀÁÂÃÄÅàáâãäåÒÓÔÕÖØòóôõöøÈÉÊËèéêëÇçÌÍÎÏìíîïÙÚÛÜùúûüÿÑñ","aaaaaaaaaaaaooooooooooooeeeeeeeecciiiiiiiiuuuuuuuuynn"))

Merci William, c'est un peu ce vers quoi je pensais me rabattre si aucun
module ne prenait en charge la manip. ;)

J'en profite pour remercier les contributeurs réguliers de ce groupe
dont Michel et toi faites partie, que je lis avec assiduité et dont les
interventions m'apprennent énormément de chose.

Merci donc. ;)

--
Frédéric Momméja

def safe(chtr):
aa = ['xe1', 'xe0', 'xe2', 'xe4']
AA = ['xc1', 'xc0', 'xc2', 'xc4']
ee = ['xe9', 'xe8', 'xea', 'xeb']
EE = ['xc9', 'xc8', 'xca', 'xcb']
ii = ['xee', 'xef']
II = ['xce', 'xcf']
oo = ['xf4', 'xf6']
OO = ['xd4', 'xd6']
uu = ['xfb', 'xfc']
UU = ['xdb', 'xdc']
if chtr in aa: return 'a'
if chtr in AA: return 'A'
if chtr in ee: return 'e'
if chtr in EE: return 'E'
if chtr in ii: return 'i'
if chtr in II: return 'I'
if chtr in oo: return 'o'
if chtr in OO: return 'O'
if chtr in uu: return 'u'
if chtr in UU: return 'U'
if chtr=='x9c': return 'oe'
if chtr=='x8c': return 'OE'
if chtr=='xe7': return 'c'
if chtr=='xc7': return 'C'
return chtr

safename = lambda strg: ''.join(map(safe,strg))

Sean McIlroy écrivait le 22/06/05 16:29 :

def safe(chtr):
[SNIP]

safename = lambda strg: ''.join(map(safe,strg))

C'est vraiment très intéressant de découvrir toutes ces possibilités de
traitement tellement différentes les unes des autres qu'offre python
pour résoudre un seul et même problème.

Merci Sean pour cette solution pour le moins originale ! ;)

--
Frédéric Momméja

Frédéric Momméja wrote:

Bonjour à tous,

j'aimerais savoir si l'un d'entre vous connaît un module ou une manière
élégante qui permette de transformer les caractères accentués d'une
phrase en leur équivalent non accentué ?

Par exemple : « Vous êtes extrêmement sympas de m'avoir dépanné »
deviendrait : « Vous etes extremement sympas de m'avoir depanne »

Pour l'instant, j'utilise un dictionnaire...
Le but est de transformer des titres de chapitre en URLs pour au final
avoir : « Vous_etes_extremement_sympas_de_m_avoir_depanne »
(virer les espaces et les apostrophes, je sais faire).

Merci. ;)

J'ai fait ça, je l'ai mis sur le wiki python-fr, sur la page:
http://wikipython.flibuste.net/moin.py/JouerAvecUnicode
En plus ça traite les o-eliés (le but étant d'avoir une chaîne type
'ascii' au final pour pouvoir faire des tris & Co).

Ca donne:

_reptable = {}
def _fill_reptable():
_corresp = [
(u"A",
[0x00C0,0x00C1,0x00C2,0x00C3,0x00C4,0x00C5,0x0100,0x0102,0x0104]),
(u"AE", [0x00C6]),
(u"a",
[0x00E0,0x00E1,0x00E2,0x00E3,0x00E4,0x00E5,0x0101,0x0103,0x0105]),
(u"ae", [0x00E6]),
(u"C", [0x00C7,0x0106,0x0108,0x010A,0x010C]),
(u"c", [0x00E7,0x0107,0x0109,0x010B,0x010D]),
(u"D", [0x00D0,0x010E,0x0110]),
(u"d", [0x00F0,0x010F,0x0111]),
(u"E",
[0x00C8,0x00C9,0x00CA,0x00CB,0x0112,0x0114,0x0116,0x0118,0x011A]),
(u"e",
[0x00E8,0x00E9,0x00EA,0x00EB,0x0113,0x0115,0x0117,0x0119,0x011B]),
(u"G", [0x011C,0x011E,0x0120,0x0122]),
(u"g", [0x011D,0x011F,0x0121,0x0123]),
(u"H", [0x0124,0x0126]),
(u"h", [0x0125,0x0127]),
(u"I",
[0x00CC,0x00CD,0x00CE,0x00CF,0x0128,0x012A,0x012C,0x012E,0x0130]),
(u"i",
[0x00EC,0x00ED,0x00EE,0x00EF,0x0129,0x012B,0x012D,0x012F,0x0131]),
(u"IJ", [0x0132]),
(u"ij", [0x0133]),
(u"J", [0x0134]),
(u"j", [0x0135]),
(u"K", [0x0136]),
(u"k", [0x0137,0x0138]),
(u"L", [0x0139,0x013B,0x013D,0x013F,0x0141]),
(u"l", [0x013A,0x013C,0x013E,0x0140,0x0142]),
(u"N", [0x00D1,0x0143,0x0145,0x0147,0x014A]),
(u"n", [0x00F1,0x0144,0x0146,0x0148,0x0149,0x014B]),
(u"O",
[0x00D2,0x00D3,0x00D4,0x00D5,0x00D6,0x00D8,0x014C,0x014E,0x0150]),
(u"o",
[0x00F2,0x00F3,0x00F4,0x00F5,0x00F6,0x00F8,0x014D,0x014F,0x0151]),
(u"OE", [0x0152]),
(u"oe", [0x0153]),
(u"R", [0x0154,0x0156,0x0158]),
(u"r", [0x0155,0x0157,0x0159]),
(u"S", [0x015A,0x015C,0x015E,0x0160]),
(u"s", [0x015B,0x015D,0x015F,0x01610,0x017F]),
(u"T", [0x0162,0x0164,0x0166]),
(u"t", [0x0163,0x0165,0x0167]),
(u"U",
[0x00D9,0x00DA,0x00DB,0x00DC,0x0168,0x016A,0x016C,0x016E,0x0170,0x172]),
(u"u",
[0x00F9,0x00FA,0x00FB,0x00FC,0x0169,0x016B,0x016D,0x016F,0x0171]),
(u"W", [0x0174]),
(u"w", [0x0175]),
(u"Y", [0x00DD,0x0176,0x0178]),
(u"y", [0x00FD,0x00FF,0x0177]),
(u"Z", [0x0179,0x017B,0x017D]),
(u"z", [0x017A,0x017C,0x017E])
]
global _reptable
for repchar,codes in _corresp :
for code in codes :
_reptable[code] = repchar
_fill_reptable()
def suppression_diacritics(s) :
"""Suppression des accents et autres marques.

@param s: le texte à nettoyer.
@type s: str ou unicode
@return: le texte nettoyé de ses marques diacritiques.
@rtype: unicode
"""
if isinstance(s,str) :
s = unicode(s,"utf8","replace")
res = []
for c in s :
res.append(_reptable.get(ord(c),c))
return u"".join(res)

Laurent Pointal écrivait le 27/06/05 9:33 :

J'ai fait ça, je l'ai mis sur le wiki python-fr, sur la page:
http://wikipython.flibuste.net/moin.py/JouerAvecUnicode
En plus ça traite les o-eliés (le but étant d'avoir une chaîne type
'ascii' au final pour pouvoir faire des tris & Co).

Merci pour le lien, très intéressant car prend en charge Unicode.
J'en ferai bon usage. ;)

--
Frédéric Momméja

Frédéric Momméja wrote:

Bonjour à tous,

j'aimerais savoir si l'un d'entre vous connaît un module ou une manière
élégante qui permette de transformer les caractères accentués d'une
phrase en leur équivalent non accentué ?

Par exemple : « Vous êtes extrêmement sympas de m'avoir dépanné »
deviendrait : « Vous etes extremement sympas de m'avoir depanne »

Pour l'instant, j'utilise un dictionnaire...
Le but est de transformer des titres de chapitre en URLs pour au final
avoir : « Vous_etes_extremement_sympas_de_m_avoir_depanne »
(virer les espaces et les apostrophes, je sais faire).

Merci. ;)

J'ai fait ça, je l'ai mis sur le wiki python-fr, sur la page:
http://wikipython.flibuste.net/moin.py/JouerAvecUnicode
En plus ça traite les o-eliés (le but étant d'avoir une chaîne type
'ascii' au final pour pouvoir faire des tris & Co).

Ca donne:

...

J'ai mis le temps, mais j'ai trouvé une méthode qui n'a pas besoin de
lister tous les caractères. Elle utilise le module unicodedata:

from unicodedata import decomposition
s = u"Vous êtes extrêmement sympas de m'avoir dépanné"
"".join([chr(int((decomposition(c) or hex(ord(c))).split()[0],16))
for c in s])

C'est peut-être plus clair comme ceci:

from unicodedata import decomposition
def enleveAccent(car):
deco = decomposition(car)
if deco:
return chr( int( deco.split()[0] ,16) )
else:
return car

s = u"Vous êtes extrêmement sympas de m'avoir dépanné"
print "".join([enleveAccent(c) for c in s])

Amaury

Amaury wrote:

from unicodedata import decomposition

et dire que c'était si proche...
Moi qui cherchais une solution de dingue...

Merci.

--
Guillaume.