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

Version imprimable

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:

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)}")

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:

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

Bonjour,

Citation:

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:

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:

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:

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

08/10/2022, 08h01
Sve@r

Citation:

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 :applo:
Enfin ça s'arrange facilement. Suffit de remplacer return s.capitalize() par return s[0].upper() + s[1:] :P

Citation:

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é 8-)
Et puis le PO l'avait importé donc je me suis dit "ok, il a probablement raison, autant que ça serve"... :mrgreen:
08/10/2022, 08h07
MPython Alaplancha

Citation:

Envoyé par Sve@r

Bah pourquoi faire?

histoire de blablater devant un café :zoubi:

Hello,

Voici ma solution,

Code:

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:

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)

08/10/2022, 10h52
Sve@r

Citation:

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"...:aie:
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")

Citation:

Envoyé par fred1599

ou mieux,

Mieux de passer par une globale?

Citation:

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:

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)

Citation:

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)

Citation:

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:

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.

@fred1599
Code:

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:

1 2 find_label('ducey-les-chéris') 'Ducey-les-chéris'
Pas bon non plus

08/10/2022, 12h20
fred1599

Citation:

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 ?

Citation:

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.

Citation:

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:

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 8-)

Citation:

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)

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

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

Citation:

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.

Citation:

"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.

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 ! :D
Pour répondre à Sve@r

Code:

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...! :roll:). 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:

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

1 pièce(s) jointe(s)

Citation:

Envoyé par Karybu

Pour répondre à Sve@r

Code:

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 !!!
Pièce jointe 626993

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...

Citation:

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:

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:

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)

13/10/2022, 23h33
robinechuca

c'est déja implémenté
Salut,

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

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 ;)

Bonjour,

Citation:

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:

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)

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 :roll: ... 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 :ave: !

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:

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:]

18/10/2022, 16h47
Sve@r

Citation:

Envoyé par Karybu

J'utilise le logiciel ArcGIS Pro de la suite d'ArcGIS d'ESRI.

Héhéhé, ArcGIS, le concurrent de QGis (on peut aussi le dire dans l'autre sens :zoubi:)

Citation:

Envoyé par Karybu

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

pourquoi attendre ???