Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Lettres accentuées en majuscules

9 réponses
Avatar
atchoum
Bonjour,

J'ai plusieurs noms de villes: ('Vendôme','Châtillon','Juré')
Je désire mettre tous les caractères en majuscules.
J'utilise la fonction upper mais elles ne transforme pas les lettres
accentuées. Pour corriger le coup, je peux finir à coup de
replace('ô','O') et pour chaque voyelle mais je trouve cela un peu lourd.

Existe-il une meilleure solution.

Je suis en 'latin1' sous Sarge/Python 2.3

Merci par avance
Jean-Pierre

9 réponses

Avatar
Do Re Mi chel La Si Do
Bonsoir !

Tu peux t'inspirer du script ci-dessous (adapter de nouveaux "mappingXXX")
--
Michel Claveau




mappingtoutascii = {
chr(0):chr(0), chr(1):chr(1), chr(2):chr(2), chr(3):chr(3), chr(4):chr(4),
chr(5):chr(5), chr(6):chr(6), chr(7):chr(7), chr(8):chr(8), chr(9):chr(9),
chr(10):chr(10), chr(11):chr(11), chr(12):chr(12), chr(13):chr(13),
chr(14):chr(14), chr(15):chr(15), chr(16):chr(16), chr(17):chr(17),
chr(18):chr(18), chr(19):chr(19),
chr(20):chr(20), chr(21):chr(21), chr(22):chr(22), chr(23):chr(23),
chr(24):chr(24), chr(25):chr(25), chr(26):chr(26), chr(27):chr(27),
chr(28):chr(28), chr(29):chr(29),
chr(30):chr(30), chr(31):chr(31), chr(32):chr(32), chr(33):chr(33),
chr(34):chr(34), chr(35):chr(35), chr(36):chr(36), chr(37):chr(37),
chr(38):chr(38), chr(39):chr(39),
chr(40):chr(40), chr(41):chr(41), chr(42):chr(42), chr(43):chr(43),
chr(44):chr(44), chr(45):chr(45), chr(46):chr(46), chr(47):chr(47),
chr(48):chr(48), chr(49):chr(49),
chr(50):chr(50), chr(51):chr(51), chr(52):chr(52), chr(53):chr(53),
chr(54):chr(54), chr(55):chr(55), chr(56):chr(56), chr(57):chr(57),
chr(58):chr(58), chr(59):chr(59),
chr(60):chr(60), chr(61):chr(61), chr(62):chr(62), chr(63):chr(63),
chr(64):chr(64), chr(65):chr(65), chr(66):chr(66), chr(67):chr(67),
chr(68):chr(68), chr(69):chr(69),
chr(70):chr(70), chr(71):chr(71), chr(72):chr(72), chr(73):chr(73),
chr(74):chr(74), chr(75):chr(75), chr(76):chr(76), chr(77):chr(77),
chr(78):chr(78), chr(79):chr(79),
chr(80):chr(80), chr(81):chr(81), chr(82):chr(82), chr(83):chr(83),
chr(84):chr(84), chr(85):chr(85), chr(86):chr(86), chr(87):chr(87),
chr(88):chr(88), chr(89):chr(89),
chr(90):chr(90), chr(91):chr(91), chr(92):chr(92), chr(93):chr(93),
chr(94):chr(94), chr(95):chr(95), chr(96):chr(96), chr(97):chr(97),
chr(98):chr(98), chr(99):chr(99),
chr(100):chr(100), chr(101):chr(101), chr(102):chr(102), chr(103):chr(103),
chr(104):chr(104), chr(105):chr(105), chr(106):chr(106), chr(107):chr(107),
chr(108):chr(108), chr(109):chr(109),
chr(110):chr(110), chr(111):chr(111), chr(112):chr(112), chr(113):chr(113),
chr(114):chr(114), chr(115):chr(115), chr(116):chr(116), chr(117):chr(117),
chr(118):chr(118), chr(119):chr(119),
chr(120):chr(120), chr(121):chr(121), chr(122):chr(122), chr(123):chr(123),
chr(124):chr(124), chr(125):chr(125), chr(126):chr(126), chr(127):chr(127),
chr(128):chr(128), chr(129):chr(129),
chr(130):chr(130), chr(131):chr(131), chr(132):chr(132), chr(133):chr(133),
chr(134):chr(134), chr(135):chr(135), chr(136):chr(136), chr(137):chr(137),
chr(138):chr(138), chr(139):chr(139),
chr(140):chr(140), chr(141):chr(141), chr(142):chr(142), chr(143):chr(143),
chr(144):chr(144), chr(145):chr(145), chr(146):chr(146), chr(147):chr(147),
chr(148):chr(148), chr(149):chr(149),
chr(150):chr(150), chr(151):chr(151), chr(152):chr(152), chr(153):chr(153),
chr(154):chr(154), chr(155):chr(155), chr(156):chr(156), chr(157):chr(157),
chr(158):chr(158), chr(159):chr(159),
chr(160):chr(160), chr(161):chr(161), chr(162):chr(162), chr(163):chr(163),
chr(164):chr(164), chr(165):chr(165), chr(166):chr(166), chr(167):chr(167),
chr(168):chr(168), chr(169):chr(169),
chr(170):chr(170), chr(171):chr(171), chr(172):chr(172), chr(173):chr(173),
chr(174):chr(174), chr(175):chr(175), chr(176):chr(176), chr(177):chr(177),
chr(178):chr(178), chr(179):chr(179),
chr(180):chr(180), chr(181):chr(181), chr(182):chr(182), chr(183):chr(183),
chr(184):chr(184), chr(185):chr(185), chr(186):chr(186), chr(187):chr(187),
chr(188):chr(188), chr(189):chr(189),
chr(190):chr(190), chr(191):chr(191), chr(192):chr(192), chr(193):chr(193),
chr(194):chr(194), chr(195):chr(195), chr(196):chr(196), chr(197):chr(197),
chr(198):chr(198), chr(199):chr(199),
chr(200):chr(200), chr(201):chr(201), chr(202):chr(202), chr(203):chr(203),
chr(204):chr(204), chr(205):chr(205), chr(206):chr(206), chr(207):chr(207),
chr(208):chr(208), chr(209):chr(209),
chr(210):chr(210), chr(211):chr(211), chr(212):chr(212), chr(213):chr(213),
chr(214):chr(214), chr(215):chr(215), chr(216):chr(216), chr(217):chr(217),
chr(218):chr(218), chr(219):chr(219),
chr(220):chr(220), chr(221):chr(221), chr(222):chr(222), chr(223):chr(223),
chr(224):chr(224), chr(225):chr(225), chr(226):chr(226), chr(227):chr(227),
chr(228):chr(228), chr(229):chr(229),
chr(230):chr(230), chr(231):chr(231), chr(232):chr(232), chr(233):chr(233),
chr(234):chr(234), chr(235):chr(235), chr(236):chr(236), chr(237):chr(237),
chr(238):chr(238), chr(239):chr(239),
chr(240):chr(240), chr(241):chr(241), chr(242):chr(242), chr(243):chr(243),
chr(244):chr(244), chr(245):chr(245), chr(246):chr(246), chr(247):chr(247),
chr(248):chr(248), chr(249):chr(249),
chr(250):chr(250), chr(251):chr(251), chr(252):chr(252), chr(253):chr(253),
chr(254):chr(254), chr(255):chr(255)
}

mappingcharnumber = {
chr(1):'', chr(2):'', chr(3):'', chr(4):'', chr(5):'', chr(6):'', chr(7):'',
chr(8):'', chr(9):'', chr(10):'', chr(11):'', chr(12):'', chr(13):'',
chr(14):'', chr(15):'', chr(16):'', chr(17):'', chr(18):'', chr(19):'',
chr(20):'', chr(21):'', chr(22):'', chr(23):'', chr(24):'', chr(25):'',
chr(26):'', chr(27):'', chr(28):'', chr(29):'', chr(30):'', chr(31):'',
chr(32):'', chr(33):'', chr(34):'', chr(35):'', chr(36):'', chr(37):'',
chr(38):'', chr(39):'', chr(40):'', chr(41):'', chr(42):'', chr(43):'',
chr(44):'.', chr(45):'.', chr(46):'.', chr(47):'.', chr(48):'0',
chr(49):'1',
chr(50):'2', chr(51):'3', chr(52):'4', chr(53):'5', chr(54):'6',
chr(55):'7', chr(56):'8', chr(57):'9', chr(58):'', chr(59):'', chr(60):'',
chr(61):'',
chr(62):'', chr(63):'', chr(64):'', chr(65):'', chr(66):'', chr(67):'',
chr(68):'', chr(69):'', chr(70):'', chr(71):'', chr(72):'', chr(73):'1',
chr(74):'', chr(75):'', chr(76):'', chr(77):'', chr(78):'', chr(79):'0',
chr(80):'', chr(81):'', chr(82):'', chr(83):'', chr(84):'', chr(85):'',
chr(86):'', chr(87):'', chr(88):'', chr(89):'', chr(90):'', chr(91):'',
chr(92):'', chr(93):'', chr(94):'', chr(95):'', chr(96):'', chr(97):'',
chr(98):'', chr(99):'', chr(100):'', chr(101):'', chr(102):'', chr(103):'',
chr(104):'', chr(105):'1', chr(106):'', chr(107):'', chr(108):'',
chr(109):'', chr(110):'', chr(111):'0', chr(112):'', chr(113):'',
chr(114):'', chr(115):'', chr(116):'', chr(117):'', chr(118):'',
chr(119):'',
chr(120):'', chr(121):'', chr(122):'', chr(123):'', chr(124):'',
chr(125):'', chr(126):'', chr(127):'', chr(128):'', chr(129):'',
chr(130):'',
chr(131):'', chr(132):'', chr(133):'', chr(134):'', chr(135):'.',
chr(137):'', chr(138):'', chr(139):'', chr(140):'0', chr(141):'',
chr(142):'',
chr(143):'', chr(144):'', chr(145):'', chr(146):'', chr(147):'',
chr(148):'', chr(149):'', chr(150):'.', chr(151):'', chr(152):'.',
chr(153):'.',
chr(154):'', chr(155):'', chr(156):'0', chr(157):'', chr(158):'',
chr(159):'', chr(160):'', chr(161):'1', chr(162):'', chr(163):'1',
chr(164):'',
chr(165):'', chr(166):'1', chr(167):'', chr(168):'', chr(169):'',
chr(170):'', chr(171):'', chr(172):'', chr(173):'', chr(174):'',
chr(175):'',
chr(176):'0', chr(177):'', chr(178):'2', chr(179):'3', chr(180):'',
chr(181):'', chr(182):'', chr(183):'', chr(184):'', chr(185):'1',
chr(186):'0',
chr(187):'', chr(188):'4', chr(189):'2', chr(190):'4', chr(191):'',
chr(192):'', chr(193):'', chr(194):'', chr(195):'', chr(196):'',
chr(197):'',
chr(198):'', chr(199):'', chr(200):'', chr(201):'', chr(202):'',
chr(203):'', chr(204):'', chr(205):'1', chr(206):'', chr(207):'1',
chr(208):'',
chr(209):'', chr(210):'', chr(211):'', chr(212):'0', chr(213):'',
chr(214):'0', chr(215):'', chr(216):'0', chr(217):'', chr(218):'',
chr(219):'',
chr(220):'', chr(221):'', chr(222):'', chr(223):'', chr(224):'',
chr(225):'', chr(226):'', chr(227):'', chr(228):'', chr(229):'',
chr(230):'',
chr(231):'', chr(232):'', chr(233):'', chr(234):'', chr(235):'',
chr(236):'', chr(237):'1', chr(238):'', chr(239):'1', chr(240):'0',
chr(241):'',
chr(242):'', chr(243):'', chr(244):'', chr(245):'0', chr(246):'0',
chr(247):'', chr(248):'0', chr(249):'', chr(250):'', chr(251):'',
chr(252):'',
chr(253):'', chr(254):'', chr(255):''}


def convchar(inp, mapchar=mappingtoutascii):
return(''.join([mapchar.get(i, i) for i in inp]))


a="azerty"
print convchar(a)

b="I3OOO"
print convchar(b,mappingcharnumber)
Avatar
Christophe Cavalaria
atchoum wrote:

Bonjour,

J'ai plusieurs noms de villes: ('Vendôme','Châtillon','Juré')
Je désire mettre tous les caractères en majuscules.
J'utilise la fonction upper mais elles ne transforme pas les lettres
accentuées. Pour corriger le coup, je peux finir à coup de
replace('ô','O') et pour chaque voyelle mais je trouve cela un peu lourd.

Existe-il une meilleure solution.

Je suis en 'latin1' sous Sarge/Python 2.3

Merci par avance
Jean-Pierre



a = u'Vendôme'
print a
Vendôme



print a.upper()
VENDÔME





Donc, il suffit de passer les string en unicode et d'utiliser upper()



Avatar
Gilles Lenfant
Bonjour,

J'ai plusieurs noms de villes: ('Vendôme','Châtillon','Juré')
Je désire mettre tous les caractères en majuscules.
J'utilise la fonction upper mais elles ne transforme pas les lettres
accentuées. Pour corriger le coup, je peux finir à coup de
replace('ô','O') et pour chaque voyelle mais je trouve cela un peu lourd.

Existe-il une meilleure solution.

Je suis en 'latin1' sous Sarge/Python 2.3

Merci par avance
Jean-Pierre


2 solutions : passer par l'unicode comme déja suggéré, ou utiliser le
package "locale".

import string
s = "Vendée"
S = s.upper()
print S
VENDéE



print string.lowercase
abcdefghijklmnopqrstuvwxyz



import locale
dummy locale.setlocale(locale.LC_ALL, '')
S = s.upper()
print S
VENDÉE



print string.lowercase
abcdefghijklmnopqrstuvwxyzµßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ








Testé sur Debian, Windows et Python 2.3.4. Pas besoin de tables de
substitutions en Python puisqu'elles sont déja dans l'OS.

--
Gilles



Avatar
F. Petitjean
atchoum wrote:

Bonjour,

J'ai plusieurs noms de villes: ('Vendôme','Châtillon','Juré')
Je désire mettre tous les caractères en majuscules.
J'utilise la fonction upper mais elles ne transforme pas les lettres
accentuées. Pour corriger le coup, je peux finir à coup de
replace('ô','O') et pour chaque voyelle mais je trouve cela un peu lourd.




a = u'Vendôme'
print a
Vendôme



print a.upper()
VENDÔME





Donc, il suffit de passer les string en unicode et d'utiliser upper()
Excellent! Mais pourquoi donc ne voit-on jamais ce genre d'exemple qui

montre l'intérêt pratique de l'unicode ?

Un exemple de problème :
. print "Vendôme"
Vendôme
. print "Vendôme".decode('latin-1')
Vendôme
. print "Vendôme".decode('latin-1') == "Vendôme"
Traceback (most recent call last)
File "<stdin>", line 1, in ?
UnicodeDecodeError: 'ascii' codec can't decode byte 0xf4 in position 4:
ordinal not in range(128)

Comme dirait Sempé rien n'est simple et tout se complique

Question : comment trouver les noms officiels de ces codages ? (ex
"latin1" ou "Latin-1" ou latin-1" ou "iso8859-1" ou ??? )
Je veux le nom officieln "canonique" pas les alias possibles qui sont
tolérés ("Utf8" "utf8" "utf-8" "iso????" ...)




Avatar
atchoum

2 solutions : passer par l'unicode comme déja suggéré, ou utiliser le
package "locale".

import string
s = "Vendée"
S = s.upper()
print S
VENDéE



print string.lowercase
abcdefghijklmnopqrstuvwxyz



import locale
dummy locale.setlocale(locale.LC_ALL, '')
S = s.upper()
print S
VENDÉE



print string.lowercase
abcdefghijklmnopqrstuvwxyzµßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ








Testé sur Debian, Windows et Python 2.3.4. Pas besoin de tables de
substitutions en Python puisqu'elles sont déja dans l'OS.


J'aurais voulu éviter les majuscules accentuées comme sur le site de
l'INSEE.

Je suis en train de lire l'excellent pavé "PYTHON EN CONCENTRE" chez
O'Reilly. (J'explore Python depuis quelques semaines après avoir tâté Perl).

j'y ai trouvé une 3ème solution:
========== cut here ============================ #!/usr/bin/env python
# -*- coding: iso-8859-15 -*-

import string

a = ('Vendôme','Châtillon','Juré')

table1 = string.maketrans('âéèîôù','aeeiou')

print [k.translate(table1).upper() for k in a]
========= cut here ============================ Voir pp151-152 du bouquin pour les fonctions translate et maketrans

Merci quand même pour votre aide
Jean-Pierre




Avatar
Jonathan Barnoud
atchoum wrote:

2 solutions : passer par l'unicode comme déja suggéré, ou utiliser le
package "locale".

import string
s = "Vendée"
S = s.upper()
print S
VENDéE



print string.lowercase
abcdefghijklmnopqrstuvwxyz



import locale
dummy locale.setlocale(locale.LC_ALL, '')
S = s.upper()
print S
VENDÉE



print string.lowercase
abcdefghijklmnopqrstuvwxyzµßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ








Testé sur Debian, Windows et Python 2.3.4. Pas besoin de tables de
substitutions en Python puisqu'elles sont déja dans l'OS.



J'aurais voulu éviter les majuscules accentuées comme sur le site de
l'INSEE.

Je suis en train de lire l'excellent pavé "PYTHON EN CONCENTRE" chez
O'Reilly. (J'explore Python depuis quelques semaines après avoir tâté
Perl).

j'y ai trouvé une 3ème solution:
========== cut here ============================ > #!/usr/bin/env python
# -*- coding: iso-8859-15 -*-

import string

a = ('Vendôme','Châtillon','Juré')

table1 = string.maketrans('âéèîôù','aeeiou')

print [k.translate(table1).upper() for k in a]
========= cut here ============================ > Voir pp151-152 du bouquin pour les fonctions translate et maketrans

Merci quand même pour votre aide
Jean-Pierre


Pourquoi éviter les majuscule accentuées ? En français en tout cas, les majuscules
ont doivent être accentué...
Enfin bon, c'est juste par curiosité (et puis on est pas vendredi sur fctt...)

Jonathan Barnoud





Avatar
atchoum
Pourquoi éviter les majuscule accentuées ? En français en tout cas, les
majuscules ont doivent être accentué...
Enfin bon, c'est juste par curiosité (et puis on est pas vendredi sur
fctt...)
La liste des 36000 communes de France est dispo ici:

http://www.insee.fr/fr/nom_def_met/nomenclatures/cog/cog.htm
et il n'y a pas de majuscules accentuées.
Par ailleurs, j'ai récupéré des adresses d'entreprises sur Internet où
la ville est "capitalisée" et j'ai besoin de regrouper les entreprises
par zone géographique (département, arrondissement, canton).
Après tout ça est envoyé sur un serveur PostgreSQL et traité à coup de
requêtes SQL donc il faut que le nom des villes coincident dans chaque
table.

A vendredi
Jean-Pierre

Avatar
Encolpe DEGOUTE
Dans fr.comp.lang.python, atchoum écrivit:
Pourquoi éviter les majuscule accentuées ? En français en tout cas, les
majuscules ont doivent être accentué...
Enfin bon, c'est juste par curiosité (et puis on est pas vendredi sur
fctt...)
La liste des 36000 communes de France est dispo ici:

http://www.insee.fr/fr/nom_def_met/nomenclatures/cog/cog.htm
et il n'y a pas de majuscules accentuées.
Par ailleurs, j'ai récupéré des adresses d'entreprises sur Internet où
la ville est "capitalisée" et j'ai besoin de regrouper les entreprises
par zone géographique (département, arrondissement, canton).
Après tout ça est envoyé sur un serveur PostgreSQL et traité à coup de
requêtes SQL donc il faut que le nom des villes coincident dans chaque
table.


string.lower()


--
Encolpe DEGOUTE
http://encolpe.degoute.free.fr/
Logiciels libres, hockey sur glace et autres activités cérébrales


Avatar
Hervé Cauwelier
Encolpe DEGOUTE wrote:
Dans fr.comp.lang.python, atchoum écrivit:
La liste des 36000 communes de France est dispo ici:
http://www.insee.fr/fr/nom_def_met/nomenclatures/cog/cog.htm
et il n'y a pas de majuscules accentuées.
Par ailleurs, j'ai récupéré des adresses d'entreprises sur Internet où
la ville est "capitalisée" et j'ai besoin de regrouper les entreprises
par zone géographique (département, arrondissement, canton).
Après tout ça est envoyé sur un serveur PostgreSQL et traité à coup de
requêtes SQL donc il faut que le nom des villes coincident dans chaque
table.


string.lower()


capitalize(), les noms de villes sont des noms propres quand même, et en
méthode de chaîne, c'est plus joli que le module string de Python 1.5. :-)

--
Vendredi avance à grands pas.