Création d'un programme basique

Bonjour a tous,

J'ai commencé a apprendre Python il y a quelque jours et j'ai un petit exercice a faire,
Je dois créer un programme et je suis bloqué: je dois faire un programme qui demande à l'utilisateur d'insérer un caractère et si c'est une lettre, il doit changer la case (genre majuscule/minuscule) sinon dire que c'est pas une lettre. J'ai commencé a créer étape par étape:

Code:

---

1 2 3 4 5 6 7 8 9

lettre=str(input("Saisir une lettre\n")) if lettre == lettre.upper() : print("Vous avez saisi la lettre majuscule",lettre) print("Après transformation en minuscule, on obtient la lettre",lettre.lower())   elif lettre == lettre.lower() : print("Vous avez saisi la lettre minuscule",lettre) print("Après transformation en majuscule, on obtient la lettre",lettre.upper())

---

J'ai reussi a créé la partie qui change la case, mais je veux que mon programme reconnait la difference entre une lettre (comme "a") et un symbole (comme "$") et que si un symbole est inséré, il print une phrase en disant

Code:

---

print("Vous avez saisi le caractère",lettre,"ce n'est pas une lettre.")

---

Comment je peux ajouter un autre "elif" qui va filtrer la difference entre les lettres et le reste ?

Citation:

---

Envoyé par wow1605

Bonjour a tous,

je veux que mon programme reconnait la difference entre une lettre (comme "a") et un symbole (comme "$")

---

Bonjour,

Code:

---

1 2 3 4 5

>>> "a".isalpha() True >>> "$".isalpha() False >>>

---

Bonjour,

Pour commencer, on peut envisager de créer un alphabet :

Code:

---

1 2 3 4 5 6 7

>>> alphabet = "abcdefghijklmnopqrstuvwxyz" >>> lettre = 'E' >>> lettre.lower() in alphabet True >>> lettre = '$' >>> lettre.lower() in alphabet False

---

Citation:

---

Envoyé par wow1605

Bonjour a tous,

---

Salut

Citation:

---

Envoyé par wow1605

Comment je peux ajouter un autre "elif" qui va filtrer la difference entre les lettres et le reste ?

---

La solution de Hominidé utilise une méthode spéciale attachée aux strings. La solution de f-leb est plus généraliste: tester si l'élément saisi appartient ou n'appartient pas à un ensemble d'éléments autorisés. A toi de voir laquelle convient à ton énoncé (as-tu le droit de passer par des outils déjà existants ou bien te demande-t-on de les réécrire pour mieux t'imprégner de leurs façons de faire).

Si d'ailleurs on te demande de les réécrire, alors je ne pense pas que tu aies le droit de passer par str.upper() et/ou str.lower(). Ceci dit c'est bien ce que tu as écrit. Mais si ton prof n'accepte pas... :aie:

Il y a une façon de faire plus basique: passer par le fait que les caractères se suivent tous dans la table unicode. Ainsi si 'c' se trouve deux rangs plus haut que 'a', alors 'C' se trouvera deux rangs plus haut que 'A'. Et si 'a' se trouve à 32 rangs de 'A', alors 'c' se trouvera aussi à 32 rangs de 'C'.

Ainsi convertir une lettre depuis les minuscules vers les majuscules peut se faire de cette façon: chr(ord(lettre) - ord('a') + ord('A')). Et l'inverse se fera ainsi: chr(ord(lettre) - ord('A') + ord('a')). Et tester si une lettre est minuscule (majuscule) peut se faire ainsi: 'a' <= lettre <= 'z' (resp. 'A' <= lettre <= 'Z').

Salut,

Citation:

---

Envoyé par wow1605

Comment je peux ajouter un autre "elif" qui va filtrer la difference entre les lettres et le reste ?

---

Vous n'avez pas besoin d'ajouter un elif mais d'ajouter un else pour traduire ce que vous écririez en français:

Code:

---

1 2 3 4 5 6

si minuscule alors: ... sinon si majuscule: ... sinon: le reste.

---

Vous pouvez aussi vous rappeler que les caractères ASCII sont ordonnés: une minuscule (majuscule) sera plus grande que 'a' (ou 'A') et plus petite que 'z' (ou 'Z').

- W

J'ai trouvé, merci a tous pour vos conseil:

Code:

---

1 2 3 4 5 6 7 8 9

lettre=input("Saisir une lettre\n") if(lettre>='A' and lettre<='Z'): print("Vous avez saisi la lettre majuscule",lettre) print("Après transformation en minuscule, on obtient la lettre",lettre.lower()) elif (lettre>='a' and lettre<='z'): print("Vous avez saisi la lettre minuscule",lettre) print("Après transformation en majuscule, on obtient la lettre",lettre.upper()) else: print("Vous avez saisi le caractère",lettre,"ce n'est pas une lettre.")

---

Citation:

---

Envoyé par wow1605

if(lettre>='A' and lettre<='Z')

---

Pas besoin de parenthèses, et espacer ne coûte pas plus cher tout en améliorant la lisibilité => if lettre >= 'A' and lettre <= 'Z'.
Et tu n'as pas vu mon exemple qui évite de devoir répéter "lettre" ? => if 'A' <= lettre <= 'Z'.

Remarque : on parle de "casse" et non de "case".

Slt !

Lol, je découvre que l'on peut tester si une lettre est inférieure ou supérieure à une autre. :aie:

Moi je proposerais d'utiliser string :

Code:

---

1 2 3 4 5 6 7 8

import string def test(x): if x in string.ascii_lowercase: print("x is lower") elif x in string.ascii_uppercase: print("x is upper") else: print("x is a symbol")

---

C'est on ne peut plus simple et clair.

Citation:

---

Envoyé par LeNarvalo

C'est on ne peut plus simple et clair.

---

ça revient à comparer le caractère à tous ceux des chaînes de caractères que sont string.ascii_lowercase et string.ascii_uppercase. Çà fonctionne mais c'est inefficace.

Des lettre.islower()/lettre.isupper() sont bien plus efficaces et fonctionnent avec tous les caractères (pas seulement le sous ensemble ASCII).

Citation:

---

Envoyé par LeNarvalo

je découvre que l'on peut tester si une lettre est inférieure ou supérieure à une autre.

---

Une lettre est juste la représentation d'un nombre (qui sont ordonnés).

- W

Citation:

---

Envoyé par wiztricks

Les lettre.lower()/lettre.upper() utilisés par le PO dans son post initial sont bien plus efficaces et fonctionnent avec tous les caractères (pas seulement le sous ensemble ASCII).
- W

---

Oui mais je ne pense pas que le PO veuille savoir quel est la majuscule de µ par exemple ?
>>> "µ".islower()
True
>>> "µ".upper()
'Μ'
>>> 'Μ'.lower()
'μ'
>>> 'M'.lower()
'm'
:P

Côté efficacité ça devrait être suffisant :
1 000 000 de test("µ")
Durée : 0.176 sec

Avec islower() / isupper() :
Durée : 0.103 sec

Avec la méthode de Sve@r ("a" <= letter <= "z"):
Durée : 0.172 sec

Je m'attendais à une différence beaucoup plus grande !

Bonjour,

Citation:

---

Envoyé par wow1605

J'ai trouvé, merci a tous pour vos conseil:

Code:

---

1 2 3 4 5 6 7 8 9

lettre=input("Saisir une lettre\n") if(lettre>='A' and lettre<='Z'): print("Vous avez saisi la lettre majuscule",lettre) print("Après transformation en minuscule, on obtient la lettre",lettre.lower()) elif (lettre>='a' and lettre<='z'): print("Vous avez saisi la lettre minuscule",lettre) print("Après transformation en majuscule, on obtient la lettre",lettre.upper()) else: print("Vous avez saisi le caractère",lettre,"ce n'est pas une lettre.")

---

---

Dans l'exercice, si l'utilisateur saisit une lettre non-ASCII, faut-il la rejeter ?

• Si oui, alors, pour tester que c'est une lettre ASCII, il faut aussi vérifier la condition len(lettre) == 1 et, quand ce n'est pas une lettre ASCII, il faut changer le texte "ce n'est pas une lettre" en "ce n'est pas une lettre ASCII".
• Sinon, alors l'exercice ne s'adresse pas à des débutants en Python.
• Si l'exercice ne précise pas l'encodage, alors son auteur manque de rigueur.

En Unicode, rien n'est simple. (Je sens que ça va être mon nouveau slogan favori, la précédente occurrence étant ici.)

En Unicode, on n'a pas seulement deux casses (lowercase et uppercase). On en a aussi une 3e : titlecase.
Les catégories correspondantes sont Ll (Letter, lowercase), Lu (Letter, uppercase) et Lt (Letter, titlecase).

Cela conduit à des subtilités comme celle qui est décrite dans la documentation de str.upper() :

Citation:

---

Return a copy of the string with all the cased characters 4 converted to uppercase. Note that s.upper().isupper() might be False if s contains uncased characters or if the Unicode category of the resulting character(s) is not “Lu” (Letter, uppercase), but e.g. “Lt” (Letter, titlecase).

The uppercasing algorithm used is described in section 3.13 of the Unicode Standard.

---

D'ailleurs, pour vérifier qu'une chaîne est alphabétique, str.isalpha() vérifie si tous ses points de codage ont une catégorie parmi Ll (Letter, lowercase), Lu (Letter, uppercase), Lt (Letter, titlecase), Lm (Letter, modifier) et Lo (Letter, other).

Du coup, si je fais lettre = "e" + chr(0x301), cela crée un e accent aigu, mais lettre.isalpha() vaut False, car le point de codage COMBINING ACUTE ACCENT (U+0301) est dans la catégorie Mn (Mark, nonspacing).

Bref, il faudrait que les exercices soient rigoureux dans leurs énoncés et précisent qu'ils se restreignent à l'ASCII.
Depuis Unicode, manipuler des chaînes de caractères, c'est devenu trop compliqué, même pour des développeurs professionnels.

Citation:

---

Envoyé par Pyramidev

Bref, il faudrait que les exercices soient rigoureux dans leurs énoncés et précisent qu'ils se restreignent à l'ASCII.
Depuis Unicode, manipuler des chaînes de caractères, c'est devenu trop compliqué, même pour des développeurs professionnels.

---

Peut-être que le prof a simplement voulu donner un exercice qui permette de s'exercer aux blocs conditionnels sans penser à mal ni à toutes ces subtilités que tu décris si bien mais qui sont peut-être au dessus de la compréhension d'un débutant :aie:
J'ai testé x="e"+chr(0x301) de ton autre lien puis "+".join(x*3). Amusant 8-)

Je suis même aller plus loin dans mon programme, si je veux par exemple qu'il change la casse aussi pour les lettres comme "é" ou "ù", j'ai fais comme sa:

Code:

---

1 2 3 4 5 6 7 8 9

lettre=str(input("Saisir une lettre\n")) if (lettre == lettre.upper() == lettre.lower()) : print("Vous avez saisi le caractère",lettre,"ce n'est pas une lettre.") elif (lettre == lettre.upper() and lettre != lettre.lower()): print("Vous avez saisi la lettre majuscule",lettre) print("Après transformation en minuscule, on obtient la lettre",lettre.lower()) elif (lettre == lettre.lower() and lettre != lettre.upper()): print("Vous avez saisi la lettre minuscule",lettre) print("Après transformation en majuscule, on obtient la lettre",lettre.upper())

---

La première ligne concerne l'entrée de la lettre en question
Première condition, si le caractère est le même en minuscule et majuscule, alors c'est surement un symbole comme "$" ou "%"
Deuxième et troisième condition change la casse si c'est un caractère qui a une forme différente en majuscule ou minuscule

Citation:

---

Envoyé par wow1605

Je suis même aller plus loin dans mon programme, si je veux par exemple qu'il change la casse aussi pour les lettres comme "é" ou "ù", j'ai fais comme sa:

---

Tu connais la comptine "sur le pont d'Avignon"? A un moment il est dit "les beaux messieurs font comme ça". Mais si tu ne sais pas l'écrire, alors tu peux écrire à la place "comme cela". Ce n'est pas parce qu'on est en informatique que l'orthographe est à oublier.

Citation:

---

Envoyé par wow1605

Première condition, si le caractère est le même en minuscule et majuscule, alors c'est surement un symbole comme "$" ou "%"

---

Déjà les parenthèses sur des cas simples ne sont pas nécessaires. Et moi j'aurais simplement dit "caractère pas entre 'a' et 'z' ni entre 'A' et 'Z'' => if (lettre < 'a' or lettre > 'z') and (lettre < 'A' or lettre > 'Z').

Citation:

---

Envoyé par wow1605

Deuxième et troisième condition change la casse si c'est un caractère qui a une forme différente en majuscule ou minuscule

---

Hum... et le cas "else" éventuel il regrouperait quelle population ?
Attention le trop est l'ennemi du bien. Partir sur des conditions "exotiques" peut avoir des risques de rater un cas très particulier. Restes-en aux solutions simples qui fonctionnent.

@Pyramidev Très intéressant, je ne connaissais pas ces autres casses ! A partir du moment où il y a un input dans le code, on peut peut-être mettre de côté tous les caractères non présent sur nos claviers AZERTY ? ^^

Citation:

---

Envoyé par LeNarvalo

A partir du moment où il y a un input dans le code, on peut peut-être mettre de côté tous les caractères non présent sur nos claviers AZERTY ? ^^

---

Tout dépend de ton but. Si tu veux faire un outil international (incluant le russe, le chinois et le japonais) te faudra voir à gérer plus finement ce qui est "inputé()" que l'éliminer définitivement....

Citation:

---

Envoyé par wow1605

Je suis même aller plus loin dans mon programme, si je veux par exemple qu'il change la casse aussi pour les lettres comme "é" ou "ù", j'ai fais comme sa:

Code:

---

1 2 3 4 5 6 7 8 9

lettre=str(input("Saisir une lettre\n")) if (lettre == lettre.upper() == lettre.lower()) : print("Vous avez saisi le caractère",lettre,"ce n'est pas une lettre.") elif (lettre == lettre.upper() and lettre != lettre.lower()): print("Vous avez saisi la lettre majuscule",lettre) print("Après transformation en minuscule, on obtient la lettre",lettre.lower()) elif (lettre == lettre.lower() and lettre != lettre.upper()): print("Vous avez saisi la lettre minuscule",lettre) print("Après transformation en majuscule, on obtient la lettre",lettre.upper())

---

La première ligne concerne l'entrée de la lettre en question
Première condition, si le caractère est le même en minuscule et majuscule, alors c'est surement un symbole comme "$" ou "%"
Deuxième et troisième condition change la casse si c'est un caractère qui a une forme différente en majuscule ou minuscule

---

Il faudrait un peu revoir la logique. La double condition lettre == lettre.upper() == lettre.lower() se réduit à lettre.upper() == lettre.lower().
Si cette condition est vraie, on va exécuter le bloc qui dit "ce n'est pas une lettre" et ignorer les autres branches du if elif...

Si cette condition est fausse, on va aller au premier elif ou la condition sera juste lettre == lettre.upper() car le premier test ayant attrapé tout ce qui n'est ni majuscule ou minuscule, on sait, arrivé là, que c'est soit une majuscule soit une minuscule (et rien d'autre). Conséquence le 2ème elif et la condition associées peuvent être remplacées par un else.

Citation:

---

Envoyé par LeNarvalo

Oui mais je ne pense pas que le PO veuille savoir quel est la majuscule de µ par exemple ?

---

Tout jeune déjà j'avais du mal a discerner .lower de .islower :calim2: J'ai corrigé.

- W

Salut,

Citation:

---

Envoyé par f-leb

Pour commencer, on peut envisager de créer un alphabet :

Code:

---

>>> alphabet = "abcdefghijklmnopqrstuvwxyz"

---

...

---

Citation:

---

Envoyé par Sve@r

Et tester si une lettre est minuscule (majuscule) peut se faire ainsi: 'a' <= lettre <= 'z' (resp. 'A' <= lettre <= 'Z').

---

A votre avis, quelle méthode est plus rapide ? La double comparaison ou le test avec l’alphabet (if lettre in alphabet) ?

Et la méthode avec une regex ?

Citation:

---

Envoyé par Beginner.

A votre avis, quelle méthode est plus rapide ? La double comparaison ou le test avec l’alphabet (if lettre in alphabet) ?

---

L'intuition me fait dire la double comparaison. Il ne s'agit pour le processeur que de 2 tests d'égalité. L'opération "in" implique fatalement une boucle. Dans ce cas précis la boucle ne concerne que 26 éléments donc elle peut être rapide mais si on prend un cas plus général...

Citation:

---

Envoyé par Beginner.

Et la méthode avec une regex ?

---

Et si nous regardions ensembles...:chin:

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

#!/usr/bin/env python3 # coding: utf-8   import random import timeit import re from functools import partial   # Les fonctions à tester def fct_in(l): t="abcdefghijklmnopqrstuvwxyz" for x in l: x in t   def fct_eq(l): for x in l: "a" <= x <= "z"   def fct_re(l): t="abcdefghijklmnopqrstuvwxyz" for x in l: re.search(x, t)   fct={ "in" : fct_in, "equal" : fct_eq, "regex" : fct_re, }   # Initialisation random random.seed()   # Les données à traiter (début, milieu, fin, autre) data="amz0"   # Le nombre de répétitions (les moyennes se feront sur cette valeur) repeat=100   # Appel des fonctions dans un ordre aléatoire et affichage du chrono print("start=%s, repeat=%d" % (data, repeat)) for (k, v) in random.sample(fct.items(), len(fct)): t=timeit.Timer(partial(v, data)).repeat(repeat=repeat, number=100_000) print("%s: min=%f, max=%f, avg=%f" % (k, min(t), max(t), sum(t)/len(t))) # for

---

Pour être honnête, le "égal" et "in" sont quasiment équivalents. Parfois c'est le "égal" qui devance, parfois c'est le "in". Mais le regex lui est carrément à la rue *10. C'est compréhensible, c'est un truc énorme le regex (mais peut-être j'ai pas pris la bonne méthode)...

Salut,

Citation:

---

Envoyé par Sve@r

Pour être honnête, le "égal" et "in" sont quasiment équivalents.

---

Déjà çà mesure le temps mis pour exécuter toute la fonction et ce qu'on cherche à mesurer (le test de casse) s'exécutera autant de fois qu'il y a de caractères dans la chaîne passées en argument.

Avec 4 caractères, si on noie le pouième qu'on cherche à mesurer dans l'overhead , il n'est pas anormal de trouver des temps semblables.

- W

Salut,

Citation:

---

Envoyé par Sve@r

Pour être honnête, le "égal" et "in" sont quasiment équivalents. Parfois c'est le "égal" qui devance, parfois c'est le "in". Mais le regex lui est carrément à la rue *10. C'est compréhensible, c'est un truc énorme le regex (mais peut-être j'ai pas pris la bonne méthode)...

---

Merci pour le test. Oui effectivement avec la regex c'est beaucoup plus long mais il y a peut-être des fonctions plus rapides, certaines fonctions font peut-être plus de choses (comme fournir les positions des éléments trouvés) que juste chercher ce qui expliquerait en partie qu'elles soient plus longues...

Enfin je ne connais pas les fonctions python je parle en général par rapport à d'autres langages.

Et aussi apparemment pour la regex, tu as utilisé une chaine de caractère mais je me demande si ce ne serait pas plus rapide avec un intervalle : [a-z]. La regex c'est une boite noire mais on peut penser que ce serait optimisé dans ce cas c'est-à-dire que cela se rapprocherait de la double comparaisons puisque là aussi on a les deux extrémités d'un intervalle.

Je vois parfois qu'on peut compiler une regex, peut-être que c'est plus rapide une fois compilé ?

Citation:

---

Envoyé par Sve@r

Il ne s'agit pour le processeur que de 2 tests d'égalité. L'opération "in" implique fatalement une boucle. Dans ce cas précis la boucle ne concerne que 26 éléments donc elle peut être rapide mais si on prend un cas plus général...

---

Oui il doit y avoir une boucle quelque part et du coup cela complique l'analyse car je suppose que la rapidité de la double comparaison doit être la même quelque soit la lettre testée alors qu'avec le in cela dépendra de la lettre : le plus rapide pour la lettre a et le plus lent pour la lettre z.

Citation:

---

Envoyé par Beginner.

Je vois parfois qu'on peut compiler une regex, peut-être que c'est plus rapide une fois compilé ?

---

C'est une bonne remarque. Indépendamment du langage, quand une même expression régulière est utilisée plusieurs fois, il vaut mieux la compiler une seule fois.

Comment Python gère-t-il la compilation des expression régulières ? Pour ceux que ça intéresse, il faut regarder le code source.
En haut de la documentation du module re, il y a un lien vers le code source du module.

La fonction re.search est définie ici :

Code:

---

1 2 3 4

def search(pattern, string, flags=0): """Scan through string looking for a match to the pattern, returning     a Match object, or None if no match was found.""" return _compile(pattern, flags).search(string)

---

_compile équivaut à re.compile :

Code:

---

1 2 3

def compile(pattern, flags=0): "Compile a regular expression pattern, returning a Pattern object." return _compile(pattern, flags)

---

Quand une même expression régulière est utilisée plusieurs fois, il vaut mieux appeler une seule fois re.compile.
Par exemple, de mon côté, quand une expression régulière est statiquement connue, je la compile au moment de l'import avec re.compile et je mets le résultat dans une variable globale.

Cela dit, en pratique, si on regarde le code source de _compile, on voit qu'il y a de la mémoïsation : jusqu'à 512 résultats de _compile sont gardés en mémoire, les plus récents étant prioritaires sur les plus anciens. Du coup, en vrai, si on appelle re.search en boucle avec la même expression régulière, même si la fonction _compile sera appelée inutilement en boucle, l'expression régulière ne sera pas compilée en boucle.

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

_cache = {} # ordered!   _MAXCACHE = 512 def _compile(pattern, flags): # internal: compile pattern if isinstance(flags, RegexFlag): flags = flags.value try: return _cache[type(pattern), pattern, flags] except KeyError: pass if isinstance(pattern, Pattern): if flags: raise ValueError( "cannot process flags argument with a compiled pattern") return pattern if not sre_compile.isstring(pattern): raise TypeError("first argument must be string or compiled pattern") p = sre_compile.compile(pattern, flags) if not (flags & DEBUG): if len(_cache) >= _MAXCACHE: # Drop the oldest item try: del _cache[next(iter(_cache))] except (StopIteration, RuntimeError, KeyError): pass _cache[type(pattern), pattern, flags] = p return p

---

Merci.

Citation:

---

Envoyé par Pyramidev

Comment Python gère-t-il la compilation des expression régulières ? Pour ceux que ça intéresse, il faut regarder le code source.
En haut de la documentation du module re, il y a un lien vers le code source du module.

---

Ah je ne savais pas qu'il y avait le code source...

Mais du coup je me demande si il existe des outils qui permettent de voir comment telle ou telle regex est exécutée. C'est-à-dire est-il possible de connaitre l'algorithme correspondant à une regex ? Cela permettrait de savoir comment optimiser l'écriture de notre regex.

Exemple concret, je me demande si il y a une différence entre [a-z] et [abcdefghijklmnopqrstuvwxyz] ? Ou entre [0-9] et [0123456789] ?

Un site comme regex101 permet de tester ses expressions régulières et de les optimiser.

Citation:

---

Envoyé par Beginner.

Et aussi apparemment pour la regex, tu as utilisé une chaine de caractère mais je me demande si ce ne serait pas plus rapide avec un intervalle : [a-z]. La regex c'est une boite noire mais on peut penser que ce serait optimisé dans ce cas c'est-à-dire que cela se rapprocherait de la double comparaisons puisque là aussi on a les deux extrémités d'un intervalle.

Je vois parfois qu'on peut compiler une regex, peut-être que c'est plus rapide une fois compilé ?

---

Ok, en avant pour la compilation
Petite modification du code donc...

Code:

---

1 2 3

comp=re.compile("[a-z]") def fct_re(l): for x in l: comp.search(x)

---

Résultat: on gagne un *2 par rapport aux premiers tests mais ça reste quand-même plus long *5 par rapport aux tests simples.

Citation:

---

Envoyé par Beginner.

Oui il doit y avoir une boucle quelque part et du coup cela complique l'analyse car je suppose que la rapidité de la double comparaison doit être la même quelque soit la lettre testée alors qu'avec le in cela dépendra de la lettre : le plus rapide pour la lettre a et le plus lent pour la lettre z.

---

Sans oublier quand la lettre n'y est pas (ie "0" dans mon test)...

Citation:

---

Envoyé par Arioch

Un site comme regex101 permet de tester ses expressions régulières et de les optimiser.

---

Joli :applo: lui je le mets dans mes favoris

Citation:

---

Envoyé par Sve@r

Ok, en avant pour la compilation
Petite modification du code donc...

Code:

---

1 2 3

comp=re.compile("[a-z]") def fct_re(l): for x in l: comp.search(x)

---

Résultat: on gagne un *2 par rapport aux premiers tests mais ça reste quand-même plus long *5 par rapport aux tests simples.

---

Ah quand même c'est un bon gain... Mais c'est vrai ça reste mauvais comparé aux autres méthodes...

Du coup je commence à me demander si la méthode sans les regex est plus performante même dans les autres types de recherche...

J'ai vu qu'il y avait des choses pour optimiser mais bon...

Citation:

---

Envoyé par Beginner.

Du coup je commence à me demander si la méthode sans les regex est plus performante même dans les autres types de recherche...

---

Ah personnellement la regex je ne m'en sers que si je ne peux pas faire autrement. Une recherche sur une string un peu exotique ou une substitution un peu complexe ok mais si la chaine à filtrer est une simple chaine lambda...

Attention avec la comparaison letter.upper() == letter.lower() pour déterminer si un caractère est une lettre ou pas. Si on prend l'eszett allemand, la version minuscule est ß, mais la version majuscule est soit ẞ, soit SS. Or si on teste le changement de casse sur la version minuscule, on obtient (Python 3.6.9):

Code:

---

1 2 3 4 5 6

>>> 'ß'.upper() 'SS' >>> 'ß'.lower() 'ß' >>> 'ß'.upper() == 'ß'.lower() False

---

D'autre part, il existe des lettres n'ayant pas de version majuscule ou de version minuscule.

https://www.unicode.org/reports/tr21/tr21-5.html

Bonjour,
Je suis etudiant et nous avons un cours de python, j'avoue que j'y vois du noir est ce que quelqu'un peut m'assister?

Citation:

---

Envoyé par Christianbash

Bonjour,
Je suis etudiant et nous avons un cours de python, j'avoue que j'y vois du noir est ce que quelqu'un peut m'assister?

---

Ben ouvre un ou plusieurs fil pour poser tes questions... Parce qu'ici tu seras hors-sujet...