Imposer une majuscule dans une chaîne de caractère après un tiret (-)

**Karybu** · 07/10/2022, 17h36

Bonjour à tous,

Je suis cartographe, je réalise des cartes d'un département qui affichent des noms de ville, de quartier etc. Ces noms sont dans une base de données, ils sont en minuscule. Je souhaite à travers un code python, obtenir des majuscules à chaque début de mot même devant les mots ayant un "-" ex : Saint-Christophe. Le code que j'ai réussi à récupérer et à adapter exclut les articles des noms (de, aux, des, en etc.) et met bien les majuscules en début de mots, mais cela pose problème lorsqu'il y a tiret à un nom propre, il n'en met pas. Est il possible d'intégrer dans ce code une fonction pour obliger les majuscules dans un mot après un tiret ?
info :
[graphie] = le champs de mes noms

Je vous remercie par avance, voila le code actuel :

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
import re
 
def FindLabel([graphie]):
    s = [graphie]
    return " ".join(
        w.capitalize() if (     
            i == 0              
            or (
                w not in {"de", "des", "en", "du", "le", "la", "les", "sur", "sous", "en", "aux"}
            )
        ) else w
        for (i, w) in enumerate(s.split())
    )
 
    print(f"{s} --> {FindLabel(s)}")

**Sve@r** · 07/10/2022, 18h29

Bonjour
J'aime bien ton code (surtout ce découpage ligne par ligne d'une instruction complexe). Mais il y a quelques incohérences qui font que je le comprends mal. C'est pas grave, on est là pour discuter et aplanir les difficultés

Déjà def FindLabel([graphie]) ça ça ne marche pas. La syntaxe n'est pas bonne. Soit la fonction reçoit un tableau que tu veux nommer "graphie" et tu écris def FindLabel(graphie), soit elle reçoit n noms à suivre et tu écris def FindLabel(*graphie) (ou plus conventionnellement def FindLabel(*args)). Mais cette notation de tableau en paramètre n'est pas correcte.

Ensuite le s=[graphie] là aussi me parait bancal. Si "graphie" est déjà un tableau de noms, mettre ce tableau dans un tableau donnera un tableau 2D. Or la 2° dimension me parait peu utile dans ce contexte.

Et ensuite tu utilises split sur "s" qui est un tableau (enfin une liste). Or une liste ne possède pas de méthode "split". C'est dommage que tu n'aies pas donné un exemple d'appel.

Bref il faudrait préciser si la fonction reçoit un nom, ou une liste de noms. Perso je préconise l'atomicité (travailler sur "un" élément, quitte à répéter ensuite l'action sur "tous" les éléments).

Et pour ton principal souci, je le pensais au début pas très compliqué (je pensais à couper sur l'espace plus le tiret via la fonction split() du module "re") mais le souci, c'est qu'au final les tirets disparaissent (le " ".join(...) positionne des espaces uniquement).
Donc j'ai pondu un petit truc basé sur l'algo suivant

récupérer toute la liste des mots du nom
si le mot n'est pas un mot interdit, alors remplacer, dans le nom, le mot par le mot transformé

Accessoirement, puisqu'il semble que le premier mot soit toujours transformé quoi qu'il arrive, autant ne pas en tenir compte et capitaliser la string finale, ça revient au même et ça évite de tester "i != 0" bien inutilement dans 99% des cas. Et puis bon, recréer la liste de mots interdits à chaque itération de la boucle...

De fait...

Code python :

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
import re
 
def FindLabel(s):
	bad={
		"de", "du", "en",
		"le", "la", "les",
		"un", "une", "des",
		"sur", "sous", "aux",
	}
	for m in re.split("[- ]", s)[1:]:
		if m in bad: continue
		while (f:=s.find(m)) != -1: s=s[0:f] + s[f].upper() + s[f+1:]
	# for
	# return s.capitalize()		# Cette solution ne fonctionne pas (voir post de Hominidé ci-dessous)
	return s[0].upper() + s[1:]	# Cette solution permet de régler le souci
# FindLabel()
 
print(FindLabel("xxx, de yyy"))
print(FindLabel("xxx-yyy"))
print(FindLabel("xxx-yyy-xxx"))
print(FindLabel("xxx-yyy-xxx-yyy"))
print(FindLabel("xxx-de-yyy"))
print(FindLabel("xxx de-yyy"))
print(FindLabel("xxx-de yyy"))
print(FindLabel("en-xxx yyy"))
print(FindLabel("saint-just-en-chaussée"))

Pas super optimisé (je pense qu'un pro des regex pourrait améliorer l'idée) mais bon... c'est efficace (et puis vendredi soir=crevé)

PS: dans ton code d'origine, les parenthèses au "or" n'étaient pas utiles. Cours de mathématiques niveau 6°: les parenthèses servent à prioriser des opérations par rapport à d'autres. On peut écrire (2+3)*4 pour prioriser l'addition sur la multiplication. Mais ça suppose au minimum d'avoir deux opérations. Et dans w not in ... il n'y a qu'une seule opération.
Les parenthèses aussi sont des instructions Python, donc elles aussi ne se mettent que quand c'est nécessaire (ou quand cela facilite la lecture, je ne dirai rien si tu écris if (a+b) == c même si c'est là aussi inutile de par les priorités naturelles du langage).

[edit] Suite à la remarque de Hominidé, j'ai rectifié mon code en mettant en commentaire l'erreur qu'il a relevée

**MPython Alaplancha** · 08/10/2022, 05h32

Bonjour,

Envoyé par Sve@r

Accessoirement, puisqu'il semble que le premier mot soit toujours transformé quoi qu'il arrive, autant ne pas en tenir compte et capitaliser la string finale, ça revient au même et ça évite de tester "i != 0" bien inutilement dans 99% des cas.

Il y a de l'idée, mais plouf:

Code :

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

1
2
3
>>> 'le Pingre A Oublié, une Fois Encore, Son Porte-Monnaie'.capitalize()
'Le pingre a oublié, une fois encore, son porte-monnaie'
>>>

Tu peux constater que ce n'est pas juste la première lettre qui est mise en majuscule, mais que c'est l'ensemble de la string qui est transformée. (C'est ce qui se passe avec le code que tu as présenté)

Sinon sans re:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
def FindLabel(s):
    out = str()
    bad={"de", "du", "en","le", "la", "les",
         "un", "une", "des","sur", "sous", "aux",
	}
    for index, label in enumerate(s.split(" ")):
        if label in bad and index:
            out += label + " "
        elif "-" in label:
            out += "-".join(word.capitalize() for word in label.split('-'))
        else:
            out += label.capitalize() + " "
    return out

Code :

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

1
2
3
>>> FindLabel("le pingre a oublié, une fois encore, son porte-monnaie")
'Le Pingre A Oublié, une Fois Encore, Son Porte-Monnaie'
>>>

**Sve@r** · 08/10/2022, 09h01

Envoyé par Hominidé

Il y a de l'idée, mais plouf:

Tu peux constater que ce n'est pas juste la première lettre qui est mise en majuscule, mais que c'est l'ensemble de la string qui est transformée. (C'est ce qui se passe avec le code que tu as présenté)

Zut !!!
En plus j'avais au départ codé correctement le truc (en prenant tous les mots et en testant i != 0) puis je l'ai modifié à la fin sans vérifier !!! Effectivement capitalize() change tous les mots d'une chaine et non pas son premier caratère, je viens de l'apprendre

Enfin ça s'arrange facilement. Suffit de remplacer return s.capitalize() par return s[0].upper() + s[1:]

Envoyé par Hominidé

Sinon sans re:

Bah pourquoi faire? "re" c'est bien pratique. Si demain il faut aussi gérer le "_", on le rajoute dans re.split("[- _]", s) et hop, c'est réglé

Et puis le PO l'avait importé donc je me suis dit "ok, il a probablement raison, autant que ça serve"...

**MPython Alaplancha** · 08/10/2022, 09h07

Envoyé par Sve@r

Bah pourquoi faire?

histoire de blablater devant un café

**fred1599** · 08/10/2022, 11h36

Hello,

Voici ma solution,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def find_label(s):
    words = s.split()
    words_transformed = [words[0].capitalize()]
    bad = {
        "de", "du", "en", "le", "la", "les",
        "un", "une", "des", "sur", "sous", "aux"
    }
    for word in words[1:]:
        if word in bad:
            ws = word
        else:
            ws = '-'.join(map(str.capitalize, word.split("-")))
        words_transformed.append(ws)
    return ' '.join(words_transformed)

ou mieux,

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
BAD = {    
    "de", "du", "en", "le", "la", "les",
    "un", "une", "des", "sur", "sous", "aux"
}
 
 
def find_label(s):
    words = s.split()
    words_transformed = [words[0].capitalize()]
    for word in words[1:]:
        if word in BAD:
            ws = word
        else:
            ws = '-'.join(map(str.capitalize, word.split("-")))
        words_transformed.append(ws)
    return ' '.join(words_transformed)

**Sve@r** · 08/10/2022, 11h52

Envoyé par fred1599

Voici ma solution,

Suis désolé, aucune des deux ne fonctionne pour "xxx-yyy". Elles retournent "Xxx-yyy" alors que ça devrait retourner "Xxx-Yyy". C'est parce que "words" a splitté "s" sur l'espace mais "s" ne contient pas d'espace. Et comme la boucle commence à l'élément [1] qui donc n'existe pas...

PS: au fait, ma solution non plus ne fonctionne pas parfaitement. Pour "xxx-yyy-x" elle retourne "XXX-Yyy-X". C'est parce que j'utilise find() pour repérer la position de la chaine à transformer et bon ben find("X") quand il y a "XXX"...

Après bon je me dis que pour des noms de lieux, le cas doit être peu probable (balance classique "probabilité de souci" vs "coût de développement pour y remédier")

Envoyé par fred1599

ou mieux,

Mieux de passer par une globale?

**fred1599** · 08/10/2022, 12h08

Envoyé par Sve@r

Suis désolé, aucune des deux ne fonctionne pour "xxx-yyy". Elles retournent "Xxx-yyy" alors que ça devrait retourner "Xxx-Yyy". C'est parce que "words" a splitté "s" sur l'espace mais "s" ne contient pas d'espace. Et comme la boucle commence à l'élément [1] qui donc n'existe pas...

Mieux de passer par une globale?

Peux-tu me donner un exemple, car l'exemple donné par @Hominidé fonctionne chez moi ?

Pour la variable globale oui dans le sens où à chaque appel de fonction, tu ne demandes pas à reconstruire bad.

Parce-que si c'est ce que je comprend (mot composé en tout début de phrase) alors on peut imaginer cela,

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
BAD = {    
    "de", "du", "en", "le", "la", "les",
    "un", "une", "des", "sur", "sous", "aux"
}
 
 
capitalize = lambda w: '-'.join(map(str.capitalize, w.split("-")))
 
 
def find_label(s):
    words = s.split()
    words_transformed = [capitalize(words[0])]
    for word in words[1:]:
        if word in BAD:
            ws = word
        else:
            ws = capitalize(word)
        words_transformed.append(ws)
    return ' '.join(words_transformed)

**Sve@r** · 08/10/2022, 12h49

Envoyé par fred1599

Peux-tu me donner un exemple, car l'exemple donné par @Hominidé fonctionne chez moi ?

Alors bon c'est d'après ce que j'ai compris, un nom comme "saint-just de la chaussée" doit devenir "Saint-Just de la Chaussée". C'est à dire que tous les mots qui ne sont pas interdits sont alors capitalisés tout en préservant le séparateur d'origine (avec aussi le premier mot capitalisé quel qu'il soit même si mot interdit)

Envoyé par fred1599

Pour la variable globale oui dans le sens où à chaque appel de fonction, tu ne demandes pas à reconstruire bad.

Compris. Mais j'aime pas. C'est plus fort que moi, je n'aime pas utiliser les globales. J'aime trop la notion d'indépendance de fonction (on prend une fonction, on la met dans n'importe quel code elle continue à remplir son job).
A la limite, ce que je te proposerais pour l'éviter serait un truc ressemblant à ceci

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
def FindLabel(*tabMot):
	def __work(mot):
		...
		return (le mot comme il faut)
	# __work()
 
	bad={...}
	yield from map(__work, tabMot)
# FindLabel()
 
for x in FindLabel("...", "...", "...", "..."): print(x)

Ainsi, un seul appel pour n mots et donc une seule définition de "bad" sans passer par une globale. Un petit ersatz d'objet en quelque sorte. Evidemment si tu dois l'utiliser à différents moments de ton code il te faudra l'appeler plusieurs fois(et là ça redéfinira à chaque appel et le bad et la sous-fonction) mais je pense que c'est quand-même un compromis qui pourrait satisfaire la grande majorité des cas.

Invité · 08/10/2022, 13h13

@fred1599

Code :

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

1
2
3
4
5
find_label('Le Moulin de lévêque')
'Le Moulin de Lévêque'
 
find_label('Le Moulin de-lévêque')
'Le Moulin De-Lévêque'

Je ne sais pas si ce genre d'exemple existe dans la vraie vie... Par contre :

Code :

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

1
2
find_label('ducey-les-chéris')
'Ducey-les-chéris'

Pas bon non plus

**fred1599** · 08/10/2022, 13h20

Envoyé par Sve@r

Ainsi, un seul appel pour n mots et donc une seule définition de "bad" sans passer par une globale. Un petit ersatz d'objet en quelque sorte. Evidemment si tu dois l'utiliser à différents moments de ton code il te faudra l'appeler plusieurs fois(et là ça redéfinira à chaque appel et le bad et la sous-fonction) mais je pense que c'est quand-même un compromis qui pourrait satisfaire la grande majorité des cas.

Ok, et si j'ai besoin de réutiliser les mots clé se trouvant dans la variable bad dans une autre fonction du projet ?

Envoyé par Sve@r

Alors bon c'est d'après ce que j'ai compris, un nom comme "saint-just de la chaussée" doit devenir "Saint-Just de la Chaussée". C'est à dire que tous les mots qui ne sont pas interdits sont alors capitalisés tout en préservant le séparateur d'origine (avec aussi le premier mot capitalisé quel qu'il soit même si mot interdit)

Oui mais je ne connais pas tous les cas possibles, et c'est tout l'intérêt des tests unitaires, on part d'une base et on vérifie à chaque nouveau cas non fonctionnel que tout passe comme on veut.

**Sve@r** · 08/10/2022, 13h45

Envoyé par fred1599

Ok, et si j'ai besoin de réutiliser les mots clé se trouvant dans la variable bad dans une autre fonction du projet ?

Dans ma vision des choses, je passe alors "bad" (qui se trouvera non pas en globale mais dans la fonction main()) en paramètre à toutes les fonctions qui en ont besoin.
Et si ce "bad" fait partie d'un ensemble plus vaste du projet (comme par exemple ses valeurs de configuration) alors j'ai un objet particulier nommé "cConfig" qui contient toutes les valeurs de configuration (valeurs dont certaines peuvent être récupérées depuis un fichier ".ini") et c'est lui que je passe à tout le projet

Voici par exemple le programme de départ qui commence tous mes projets

Code python :

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
32
33
34
35
36
37
38
39
40
41
42
43
# Fonction principale
def Appli():
	# Récupération modules application
	envp=cEnv(argv=sys.argv)
	config=cConfig(
		tabFic=(
			{
				"nom" : pathlib.Path(envp.wdir).joinpath("etc", "config.ini"),
				"mode" : "r",
			},
			{
				"nom" : pathlib.Path.home().joinpath(
					{
						"posix" : ".%src" % cEnv.appli,
						"nt" : "%s.ini" % cEnv.appli,
					}[os.name]
				),
				"mode" : "w",
			},
		),
	)
	bdd=cBdd(
		dbname=cEnv.dbname,
		log=pathlib.Path(envp.wdir).joinpath("historique", "histo_log.sql"),
	)
 
	# Lancement de l'IHM avec les éléments du logiciel
	status=QtAppli(
		sys.argv,
		envp=envp,
		config=config,
		bdd=bdd,
	).exec_()
 
	# Fermeture modules application
	config.close()
	envp.close()
	bdd.close()
	return status
# Appli()
 
# Si le module est lançé en tant que programme
if __name__ == "__main__": sys.exit(Appli())

"config" contient la configuration, "envp" l'environnement et "bdd" le module d'accès à la bdd. Avec ça, je couvre tous les champs possibles

Envoyé par fred1599

Oui mais je ne connais pas tous les cas possibles, et c'est tout l'intérêt des tests unitaires, on part d'une base et on vérifie à chaque nouveau cas non fonctionnel que tout passe comme on veut.

Moi non plus je ne connais pas tous les cas possibles (d'ailleurs j'ai rajouté une remarque dans mon premier post à propos de "xxx-yyy-x" qui ne donnera pas ce que j'imagine que ça devrait donner). Mais le PO, qui aurait pu avoir la politesse de revenir voir si on avait répondu à sa demande (sa dernière connexion date de l'envoi de son post !!!) a quand-même expliqué ce qu'il cherchait avec cette phrase particulière "Est il possible d'intégrer dans ce code une fonction pour obliger les majuscules dans un mot après un tiret ? " que j'ai alors compris comme devant transformer "xxx-yyy" en "Xxx-Yyy" et de là créé mon algo puis mon test unitaire "saint-just-en-chaussée" (test inclus dans mon premier code)

**fred1599** · 08/10/2022, 14h27

Dernier tests, finalement c'est au PO de faire cela

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
BAD = {    
    "de", "du", "en", "le", "la", "les",
    "un", "une", "des", "sur", "sous", "aux"
}
 
 
def capitalize(w): return '-'.join(
    (wd.capitalize() if (
        (wd in BAD and not i) or wd not in BAD) else wd for i,
        wd in enumerate(
            w.split('-'))))
 
 
def find_label(s):
    words = s.split()
    words_transformed = [capitalize(words[0])]
    for word in words[1:]:
        ws = capitalize(word) if word not in BAD else word
        words_transformed.append(ws)
    return ' '.join(words_transformed)

Sve@r

Dans ma vision des choses, je passe alors "bad" (qui se trouvera non pas en globale mais dans la fonction main()) en paramètre à toutes les fonctions qui en ont besoin.

Oui c'est une variable globale dans le namespace de ta fonction main à ton module ... étant donné que cette fonction est la seule exécutée à l'ensemble du projet. Du coup tu t'imposes un paramètre de fonction pour chaque fonction en ayant besoin, alors que l'on pourrait très bien importer d'un module constants.py l'ensemble des constantes du projet par exemple.

"config" contient la configuration, "envp" l'environnement et "bdd" le module d'accès à la bdd. Avec ça, je couvre tous les champs possibles

Oui mais je vois pas le lien avec notre cas, on parle juste d'une constante, toi tu parles de configuration qui a mon sens est liée à des constantes cachées de ta base de données et ton environnement. C'est un fichier qu'on ne présente pas dans un code, alors que des constantes comme BAD ne doivent pas être cachées.

Perso j'utilise des variables d'environnement que j'appelle avec dotenv, mais ce choix est vraiment perso.

**Karybu** · 10/10/2022, 18h37

Bonjour,

D'abord merci beaucoup à tous pour votre aide, je ne m'attendais pas à ce qu'il y ait autant de discussion pas rapport à ce sujet !

Pour répondre à Sve@r

Code :

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

def FindLabel([graphie])

est une expression automatiquement générée par mon logiciel de cartographie, nous sommes obligés de l'utiliser et [graphie] correspond au champs d'une table, notre logiciel utilise cet affichage en crochet, si j'utilises des parenthèses il considère qu'il y a une erreur, je ne sais pas pourquoi...

Je n'ai pas un niveau aussi avancé que les vôtres, donc je ne suis pas sure que j'arriverai à répondre à toutes les subtilités de vos codes, mais j'ai néanmoins réussi à appliquer le premier code d'Hominidé (un peu plus user friendly pour les débutantes comme moi...!

). Mes étiquettes excluent bien la liste des articles tout en forçant la majuscule après le "-".

Est-il possible d'intégrer une liste qui va forcer la majuscule après d'autres éléments (par ex: l' , d', - etc.) ? Au début j'ai notamment essayé d'ajouter un "elif" en plus, en me basant sur celui qui a été crée pour le "-" en le remplaçant par "d'", mais ça n'a pas fonctionné. Je me suis dit ensuite pourquoi pas faire une liste (maj), c'est peut être plus simple que d'ajouter des "elif" à chaque fois mais là encore j'ai un problème d'expression... Ce que j'ai essayé de faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def FindLabel(s):
    out = str()
    bad={"de", "du", "en","le", "la", "les",
         "un", "une", "des","sur", "sous", "aux",
    }
    maj={"-", "d'", "l'"}
    for index, label in enumerate(s.split(" ")):
        if label in bad and index:
            out += label + " "
        elif maj in label:
            out += "-".join(word.capitalize() for word in label.split(maj))
        else:
            out += label.capitalize() + " "
    return out

**Sve@r** · 10/10/2022, 18h54

Envoyé par Karybu

Pour répondre à Sve@r

Code :

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

def FindLabel([graphie])

est une expression automatiquement générée par mon logiciel de cartographie, nous sommes obligés de l'utiliser et [graphie] correspond au champs d'une table, notre logiciel utilise cet affichage en crochet, si j'utilises des parenthèses il considère qu'il y a une erreur, je ne sais pas pourquoi...

Alors ce n'est pas du Python !!!
Nom : VirtualBox_Xubuntu64_10_10_2022_17_45_02.png
Affichages : 640
Taille : 175,7 Ko

C'est peut-être du "python spécifique logiciel carto" (au fait c'est quoi ce logiciel? QGis? Car QGis a été écrit en python) mais si ce "python spécial" a une syntaxe qui n'est pas la syntaxe de base, on aura du mal...

Envoyé par Karybu

Est-il possible d'intégrer une liste qui va forcer la majuscule après d'autres éléments (par ex: l' , d', - etc.) ?

Bien entendu. Mon script n'est peut-être pas user friendly mais justement j'ai expliqué son principe. La seule ligne "un peu" complexe est celle-ci: while (f:=s.find(m)) != -1: s=s[0:f] + s[f].upper() + s[f+1:] et qui se lit "tant que je trouve le mot m dans s à une position f alors je récupère intact tout ce qui se trouve avant f, j'y rajoute la lettre de la position f mise en majuscule et je récupère intact tout ce qui se trouve après f" ce qui en fait, ne fait que mettre la première lettre du mot "m" en majuscule a l'endroit où se trouve cette lettre. Et dans une boucle au cas où il y aurait plusieurs fois le mots.
Elle fait appel à un nouvel opérateur, le ":=" (arrivé avec Python 3.8) et qui permet d'affecter tout en gardant la valeur en "main" pour ensuite la tester (donc la valeur du find() va dans "f" mais est aussi testée sur -1).
Sans cet opérateur, le truc s'écrivait alors ainsi...

Code python :

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

1
2
3
4
5
while True:
	f=s.find(m)
	if f == 1: break
	s=s[0:f] + s[f].upper() + s[f+1:]
# while

... ce qui est probablement plus user friendly.

Mais surtout je l'avais prévu pour le cas quasi certain (tellement courant ici) du "ah au fait j'ai oublié que..."

Code python :

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
import re
 
def FindLabel(s):
	bad={
		"de", "du", "en",
		"le", "la", "les", "l",
		"un", "une", "des", "d",
		"sur", "sous", "aux",
	}
	for m in re.split("[-' ]", s)[1:]:
		if m in bad: continue
		while (f:=s.find(m)) != -1: s=s[0:f] + s[f].upper() + s[f+1:]
	# for
	return s[0].upper() + s[1:]
# FindLabel()
 
print(FindLabel("xxx d'argentière"))
print(FindLabel("xxx de-l'argentière"))

Et si tu regardes bien les différences avec le précédent, elles sont

dans la liste des mots interdits, qui s'est vue rajouter "l", "d"
dans la liste des éléments de séparation, qui est passée de "- " (tiret ou espace) à "-' " (tiret ou apostrophe ou espace)

**robinechuca** · 14/10/2022, 00h33

Salut,

Dans les versions récentes de python, la méthode title des chaînes de caractère fait ce boulot là:

Code :

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

1
2
3
 
>>> "Les gens arc-en-ciel sont d'argentière".title()
"Les Gens Arc-En-Ciel Sont D'Argentière"

Voila! mais c'est intéressant pour l'exercice de se poser la question

**MPython Alaplancha** · 14/10/2022, 07h05

Bonjour,

Envoyé par robinechuca

Salut,

Dans les versions récentes de python, la méthode title des chaînes de caractère fait ce boulot là:

Bien vu

.
Avec la gestion des exclusions:

Code :

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

1
2
3
4
5
6
7
8
9
10
def FindLabel(s):
	bad={
		"de", "du", "en",
		"le", "la", "les", "l",
		"un", "une", "des", "d",
		"sur", "sous", "aux",
	}
	mots = s.title().split()
	return " ".join(mot if mot.lower() not in bad
                         else mot.lower() for mot in mots)

**Karybu** · 18/10/2022, 17h39

Sve@r,

J'utilise le logiciel ArcGIS Pro de la suite d'ArcGIS d'ESRI. J'ai fait quelques recherches, il y a bien un "python spécial" utilisé, voici ce que j'ai trouvé : "Python est le langage de script d'ArcGIS. ArcGIS inclut une API Python, ArcPy, qui vous donne accès à tous les outils de géotraitement, ainsi qu'à des fonctions de script et à des modules spécialisés, qui vous aident à automatiser les tâches SIG. Vous pouvez écrire des scripts qui font appel à ArcPy en synergie avec diverses fonctions apportées par des bibliothèques standard de Python et des bibliothèques tierces."

Et voici l'article si tu veux en savoir plus : https://pro.arcgis.com/fr/pro-app/la...3%A2ches%20SIG.

J'ai testé ton code en l'adaptant avec mon fameux champs [graphie] et il fonctionne. Merci pour toutes tes explications et ta prévenance dans le code pour les ajouts supplémentaires

... Je tâtonne comme je peux en attendant une formation python prévue pour mai 2023 pour le boulot, j'espère pouvoir coder plus facilement après ça. En tout cas, MERCI BEAUCOUP à tous le monde

!

Pour les utilisateurs d'ArcGIS Pro et d'ArcMap, le code suivant a été appliqué sur les étiquettes / labels pour respecter la casse des noms propres (il faut donc remplacer [graphie] par votre champs de nom. Ce dernier est en minuscule) :

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
import re
 
def FindLabel([GRAPHIE]):
    bad={
        "de", "du", "en",
        "le", "la", "les", "l",
        "un", "une", "des", "d",
        "sur", "sous", "aux",
    }
    s=[GRAPHIE]
    for m in re.split("[-' ]", s)[1:]:
        if m in bad: continue
        while (f:=s.find(m)) != -1: s=s[0:f] + s[f].upper() + s[f+1:]
    # for
    return s[0].upper() + s[1:]