Discussion :

[Lolo78]

Pour trouver une minuscule suivant une espace suivant un point, tu peux essayer la regex suivante

Code :

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

1
2
 
$minuscule = $1 if $string =~ /\. ([a-z])/;

Mais cela ne trouvera pas les lettres minuscules accentuées. Tu peux éventuellement les ajouter à la classe de caractères, par exemple:

Code :

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

1
2
 
$minuscule = $1 if $string =~ /\. ([a-zàéèùâêîôûç])/;

Ou alors, essayer les classes Posix: [:lower:]

[Emycherie02]

Merci.
Je comprends l'expression régulière mais je ne comprends pas $minuscule = $1.
Quelle est son utilité ?

[Emycherie02]

si je veux que ce soit aussi après un ? et un !
je peux indiquer ceci : if $string =~ /\.?! ([a-z])/; ?

merci

[joel.drigo]

En typographie française, il y a une astuce pour connaitre la présence d'espace autour des signes de ponctuation (et que l'on peut utiliser comme règle) : les signes de ponctuation à un symbole (point, virgule) sont entouré d'un seul espace (après le signe), tandis que les signes à deux symboles (deux points, point-virgule, points d'interrogation ou d'exclamation, ...) sont entourés de deux espaces (un avant et un après le signe).

Oui. Attention toutefois, l'espace devant le signe peut être fine (devant deux-points et point-virgule, en l'occurance), et doit être insécable dans tous les cas.

[Lolo78]

$1 récupère la "capture, c'est à dire le caractère reconnu par ce qui est entre parenthèses dans l'expression régulière, autrement dit, ici, la lettre minuscule suivant l'espace après le point.

Pour essayer plusieurs signes de ponctuations, utilise une autre classe de caractères:

Code :

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

1
2
 
$minuscule = $1 if $string =~ /[.?!] ([a-z])/;

Ce qui veut dire: soit un ".", soit un "?", soit un "!", suivi d'un espace, suivi d'une lettre comprise entre a et z.

[Philou67430]

C'est même encore plus compliqué, car la règle s'applique au français de France, pas complètement au français du Québec ou de Suisse.

Pour l'expression régulière, le recherche d'espace devrait à mon sens contenir un quantifieur (au moins un). Dans le dernier exemple de Lolo, ça donnerait :

Code :

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

$minuscule = $1 if $string =~ /\. +([a-zàéèùâêîôûç])/;

D'ailleurs, en supposant qu'il puisse y avoir plusieurs erreurs de typo (manque l'espace après le . et minuscule après un point), il faudrait être encore plus laxiste et accepter zéro ou plus d'espaces :

Code :

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

$minuscule = $1 if $string =~ /\. *([a-zàéèùâêîôûç])/;

Ensuite, il faut aussi prévoir que ligne de texte puisse contenir plusieurs fois la même erreur de typo (manque d'une majuscule par exemple) et dans ce cas, soit prévoir une regexp avec l'option /g (et sans doute une boucle for ou foreach, bien que cela puisse parfois être évité), soit une boucle while avec une regexp sans l'option /g.

[Lolo78]

J'avais bien pensé aux espaces doubles, mais comme la série d'expressions régulières retire les doubles espaces, la recherche d'éventuels espaces doublés après les signes de ponctuation n'était à mon avis pas nécessaire (à condition bien sûr de faire les choses dans le bon ordre).

Pour l'éventuelle absence d'espace entre la ponctuation et la lettre qui suit, ce n'est effectivement sans doute pas superflu, mais je le ferais avant dans une autre regex, afin de corriger également les ponctuations suivies immédiatement d'une lettre capitale.

[Emycherie02]

J'ai en effet réalisé une expression régulière pour mettre un espace après les points, points d'interrogation et points d'exclamation.
Merci pour toutes ces explications !
Je me lance dans les espaces entre les chiffres maintenant, j'aurai encore sûrement des questions !!

[Emycherie02]

Je voudrais espacer mes chiffres par un point : 123.456.789
Je pensais spliter mes chiffres dans un tableau soit sur un espace, soit sur rien (123 456 789 ou 123456789)
et puis les rassembler 3 par 3 avec un point en commençant par la droite.
Est-ce que ça vous semble faisable ?
merci

[joel.drigo]

Je voudrais espacer mes chiffres par un point : 123.456.789

Normalement c'est une espace insécable.

Je pensais spliter mes chiffres dans un tableau soit sur un espace, soit sur rien (123 456 789 ou 123456789)
et puis les rassembler 3 par 3 avec un point en commençant par la droite.

Attention aux nombres à virgules (1235,50253428 => 1 235,502 534 28).

[Philou67430]

Voici peut-être une uniligne qui t'aidera peut-être à trouver une solution pour l'espaçage des nombres :

Code :

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

1
2
$ perl -E '$a = "1254654.232"; while ($a =~ s/(\d)(\d{3})(\D|$)/$1 $2$3/) {} ; say $a'
1 254 654.232

Attention, elle ne fonctionne pas si les chiffres après la virgules sont plus nombreux que 3 :

Code :

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

1
2
$ perl -E '$a = "1254654.25216532"; while ($a =~ s/(\d)(\d{3})(\D|$)/$1 $2$3/) {} ; say $a'
1 254 654.25 216 532

[Emycherie02]

Merci joel.drigo pour la correction.
Philou67430, peux-tu m'expliquer l'expression, principalement cette partie-ci \D|$)/$1 $2$3/)
Est-ce que s'il n'y a que 4 chiffres 1 234 ou 7 chiffres 1 234 567, ça fonctionne aussi ?

[Philou67430]

L'expression régulière (s/(\d)(\d{3})(\D|$)/$1 $2$3/) que j'ai écrite fonctionne ainsi : elle cherche une série de 4 chiffres consécutifs suivi d'un caractère quelconque qui n'est pas un chiffre (cela peut être un espace, une virgule, un point ou même un pseudo-caractère fin de chaine ($).
Le premier chiffre de la série de 4 recherchée est "rangé" dans une variable de recherche à l'aide des parenthèses capturantes (il se retrouvera dans $1). La série de 3 chiffres suivant se retrouve dans une deuxième variable $2, et le caractère non numérique qui suit sera quant à lui rangé dans une troisième variable, toujours grâce aux parenthèses capturantes ($3).
Ensuite, on reconstruit la chaine de remplacement en insérant une espace entre la première et la deuxième capture.

En relisant, je m'aperçois qu'il est possible de simplifier en capturant dans une unique variable les trois chiffres et le "non-chiffre" qui suit :
s/(\d)(\d{3}(?:\D|$))/$1 $2/

Ensuite, comme on boucle tant qu'il existe des suites de 4 chiffres dans la chaine, on traitre tous les nombres de plus quatre chiffres au moins (la substitution se réalise alors à partir de la droite de tous les nombres d'une chaine en commençant par la nombres les plus à gauche. Exemple des itérations :

Code :

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

1
2
3
4
5
Valeur initiale :
12345678 toto 987654
itération 1 : 12345 678 toto 987654
itération 2 : 12 345 678 toto 987654
itération 3 : 12 345 678 toto 987 654

On pourrait ajouter l'option /g à l'expression régulière, ainsi, tous les nombres seraient traités lors d'une itération :

Code :

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

1
2
3
4
Valeur initiale :
12345678 toto 987654
itération 1 : 12345 678 toto 987 654
itération 2 : 12 345 678 toto 987 654

Je n'ai aucune idée si ce serait plus rapide que la méthode précédente.

[Emycherie02]

Il parait qu'il existe un module qui gère ce genre de chose ?
on me suggère de procéder comme suit :
1/ placez les chiffres individuellement dans un tableau;
2/ Parcourez le tableau de la fin vers le début;
(alternative peut-être plus simple : inversez le tableau et parcourez-le du
début à la fin)
3a/ Concaténez chaque chiffre à une chaîne de caractères et,
3b/ tous les trois chiffres, concaténez une espace insécable
(Pour identifier ces séquences de trois chiffres, vous pouvez utiliser un
compteur et un modulo).

Je trouvais ton expression régulière, Philou67430, assez claire !
Quelle est la différence entre les deux méthodes ?

[Philou67430]

L'expression régulière est concise et intègre l'algorithme complet de parcours, d'extraction, de transformation des nombres et de ré-intégration dans la chaine. L'alternative demande de tout écrire "à la main". L'inconvénient de l'expression régulière, c'est qu'elle nécessite une certaine expertise pour être comprise et maintenue, et dans le cas présent, qu'elle ne fonctionne pas sur les nombres décimaux. Pour l'écriture "à la main", l'avantage est que l'on maitrise totalement l'implémentation et que l'on peut donc définir le fonctionnement comme on le souhaite, l'inconvénient majeur est qu'il nécessite un effort de développement (conceptions, déverminage et tests fonctionnels plus poussés qu'avec l'expression régulière).

Une autre alternative est effectivement d'utiliser un module (du CPAN par exemple) qui fasse la conversion : Number::Format.
Cette dernière alternative a de nombreux avantages : ne nécessite aucune expertise sur le formatage des nombres, l'implémentation d'un algorithme, la gestion de la locale (c'est à dire de la langue dans laquelle les nombres doivent être représentés).
Regarde particulièrement le formatage avec THOUSANDS_SEP (qu'il est possible de passer en paramètre au constructeur du convertisseur ; je n'ai pas réussi à faire fonctionner la locale "fr" pour que THOUSANDS_SEP contienne automagiquement un espace).

[Lolo78]

Bonjour,

une solution intermédiaire entre une regex unique et une décomposition plus poussée, en découpant préalablement le nombre en entrée entre sa partie entière et sa partie fractionnaire. Et ça paraît marcher pour les chiffres après la virgule. La démonstration est faite ici sous le debugger Perl:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  DB<1>  $a = "1254654.23245678";
 
  DB<2> ($b, $c) = split /\./, $a;
 
  DB<3> $b = reverse $b;
 
  DB<4> s/(\d{3})/$1 /g for ($b, $c)
 
  DB<5> $d = reverse($b) .  ".$c";
 
  DB<6> p $d
1 254 654.232 456 78

J'ai préféré ici faire un reverse sur la partie entière, car cela permet d'utiliser la même regex très simple sur les deux morceaux. On pourrait ne pas faire de reverse et utiliser deux regex différentes.

Sinon, une autre méthode possible pour un nombre entier:

Code :

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

1
2
3
 
$ perl -e ' $c = reverse "1234567891012"; print scalar  reverse  join "",   map  { s/(\d{3})/$1 /gr  } ($c); '
1 234 567 891 012

[Emycherie02]

Merci Lolo78, ça a l'air de bien fonctionner mais il y a beaucoup de choses que je n'ai pas vues au cours et je ne peux pas les utiliser :/

Je cherche des infos pour concaténer un chiffre à une chaine de caractère.
Quelqu'un a une idée ?

[Philou67430]

La concaténation se fait soit à l'aide de l'opérateur . (point), soit à l'aide d'une chaine littérale interpolée ("" ou opérateur qq() ) :

Code :

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

1
2
3
my $chiffre = 1;
my $chaine = "toto";
say join "\n", $chaine.$chiffre, "$chaine$chiffre", qq($chaine$chiffre);

Sinon, la solution proposée par Lolo implique d'avoir extrait le nombre de la chaine initiale, et de le remplacer ensuite par la chaine additionnée des espaces (et là, le plus pratique reste tout de même, me semble-t-il, la substitution par regexp).

Mis à part cela, il est à noter que les décimales d'un nombre à virgule ne sont pas impactées par la fonction de formatage numérique du module Number::Format. Je ne suis pas loin de penser que ce n'est pas requis (mais je n'ai pas suffisamment d'expertise en typographie pour l'affirmer).

Code :

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

1
2
$ perl -MNumber::Format -E '$n = Number::Format->new(-thousands_sep => " ", -decimal_digits => 10); say $n->format_number(10000.45498)'
10 000,45498

[Emycherie02]

Bonjour,
j'ai quelques lignes de code qui sont apparemment en Python, je voudrais les transposer en Perl.
Pouvez-vous m'aider ?
Merci !


my $ct_num =~ /^\d+$/
my @tab = split (/.||/, my $ct_num);
my @tab_invers = reverse @tab;
my $i = 0;
my nb = "";

foreach my $chiffre ( @tab_invers ){
$nb = $nb . $chiffre;
i++;
print $nb;
if $i == 3 {
$nb = $nb . " ";
i = 0;

}
}

[Emycherie02]

J'avais suivi vos recommandations mais apparemment, la syntaxe est défaillante ???

$minuscule = $1;


if ( my $string =~ /[.?!] ([a-zàéèùâêîôûç])/g ) {


say (<check type="majuscule">$minuscule</check>);
}