Discussion :

[nipocham]

Bonsoir. Voici un pb que je viens juste de découvrir. Ce que je vous propose, si vous en avez le temps, c'est de me guider dans ma recherche, de telle sorte que je trouve le plus vite possible. Voici ce que je comprends : il y a besoin d'une fonction qui puisse être appelée pour tester les éléments d'une liste selon qu'ils sont des réponses vraies ou fausses à des fonctions du type : est un nombre premier,


Ecrivez une fonction my_filter qui prend une liste lst et une fonction booléenne f en paramètres.
Cette fonction renverra une nouvelle liste constituée des éléments de la liste lst pour lesquels la fonction f renvoie True.
Note:
Pour les tests, UpyLaB utilise les fonctions Python lambda. Cela permet de définir au moment même une fonction anonyme avec un ou plusieurs paramètres
Ainsi :
lambda e: isinstance(e, int)
donne une fonction à un paramètre, qui teste si ce paramètre est de type entier.

[wiztricks]

Salut,

Voici ce que je comprends : il y a besoin d'une fonction qui puisse être appelée pour tester les éléments d'une liste selon qu'ils sont des réponses vraies ou fausses à des fonctions du type : est un nombre premier

Tout à fait... maintenant que vous avez compris, vous devriez pouvoir écrire un premier code et voir s'il fonctionne.

c'est de me guider dans ma recherche, de telle sorte que je trouve le plus vite possible.

Le but de ce genre d'exercice est de vous obliger à pratiquer la programmation: écrire quelques instructions, les lancer, comprendre les messages d'erreurs s'il y en a, vous poser des questions sur les instructions que vous avez écrites si vous n'obtenez pas le résultat attendu.


- W

[nipocham]

vous dites en somme qu'il faut se jeter à l'eau pour apprendre à nager. Et je serais d'un avis éloigné du vôtre. Une langue, si l'on veut l'apprendre, on doit s'en servir réellement, c'est l'idée de se jeter à l'eau. Seulement voilà : mieux on aura préparé méthodiquement les choses à faire et à ne pas faire, plus vite cela ira.
Le peu que je vois de l'enseignement du python sur Internet, me parait mal foutu. On pourrait faire cela plus rationnellement, en perdant moins de temps à chercher.
Tout cela est empirique. Des recettes que l'on applique au prix d'une longue pratique. Ou bien, la programmation d'un ordi est empirique ou bien elle est mathématique. Non ?

[fred1599]

Bonsoir,

On pourrait faire cela plus rationnellement, en perdant moins de temps à chercher.

Ça va plus loin que ça, il faut chercher et tester. Beaucoup tester sur son interpréteur, sinon comment voir les résultats des codes que vous avez trouvé ou lu sur des forums.

L'interpréteur permet de tester ligne par ligne des fonctions, ... et ces résultats vont rester en mémoire, car vous vous êtes donné le mal de chercher et avez pris le temps.

[daniel-12]

Salut, comme toi je débute

regarde là, c'est un bon début
http://python.jpvweb.com/python/mesr...id=est_premier

[BufferBob]

salut,

vous dites en somme qu'il faut se jeter à l'eau pour apprendre à nager. Et je serais d'un avis éloigné du vôtre.

la différence c'est que -en toute logique- ceux qui préconisent de te jeter à l'eau savent, eux, de quoi ils parlent...

l'énoncé de ton problème est assez clair; tu dois écrire une fonction en python

nous pour continuer de t'aider on attend que tu nous montre un début de code (histoire qu'on ait pas l'impression de faire le boulot à ta place gratos tandis que tu philosophes sur le bas coté par exemple)

la dynamique est alors assez évidente... lance toi, code, montre ton code, et on t'aide à le corriger. dans ce sens (et ça fonctionne bien, promis ).

[wiztricks]

Salut,

Moi je me contente de lire l'énoncé:

Ecrivez une fonction my_filter qui prend une liste lst et une fonction booléenne f en paramètres.
Cette fonction renverra une nouvelle liste constituée des éléments de la liste lst pour lesquels la fonction f renvoie True.

c'est écrit en français et il faut le traduire en instructions Python.

Puisque c'est un exercice, on suppose que vous savez écrire une fonction, ce qu'est une liste, une boucle... et donc que vous êtes capable d'écrire un minimum de ce qui est demandé.
Sinon il faut revoir les chapitres de votre tuto. qui présentent ces notions là.

Après çà fonctionne (ou pas), vous avez des difficultés à traduire tel aspect,...et demander qu'on essaie de vous expliquer. Ce qui suppose que vous avez commencé à essayer de coder quelque chose.

- W

[Sve@r]

Bonjour

vous dites en somme qu'il faut se jeter à l'eau pour apprendre à nager.

Exactement. D'ailleurs quand on apprend à nager, à un moment donné on de jette effectivement à l'eau.

Le peu que je vois de l'enseignement du python sur Internet, me parait mal foutu.

C'est un avis personnel. Qui provient soit

• du fait que t'as peu cherché
• du fait que, malgré ta recherche, t'as peu trouvé
• du fait que tu t'es peu impliqué dans ce que tu as trouvé

Dans le doute, je préfère penser que t'as cherché mais peu trouvé. Je te propose donc le Swinnen. C'est la référence en matière d'apprentissage Python. Suffit de taper "swinnen" et "python" dans ton moteur de recherche favori. C'est par exemple ce que j'ai utilisé quand j'ai voulu apprendre ce langage. Et tu verras que, en dehors de moi, il est recommandé dans tout ce forum. Mais un tuto ne permet d'apprendre que si on le lit et qu'on fait les exercices proposés.

On pourrait faire cela plus rationnellement, en perdant moins de temps à chercher.

Oui. C'est le but des exercices corrigés des tutoriels. Ils te permettent de faire le lien entre "problème X" et "façon de trouver la solution X" afin que de toi-même tu puisses ensuite faire le lien entre "problème Y" et "solution Y". Si par exemple un tuto t'apprend à compter les valeurs d'une liste (itérer et additionner), alors traiter une liste pour n'extraire que ce que la fonction renvoie True n'est pas beaucoup plus compliqué (itérer, envoyer à la fonction, tester le retour).

Voici ce que je comprends : il y a besoin d'une fonction qui puisse être appelée pour tester les éléments d'une liste selon qu'ils sont des réponses vraies ou fausses à des fonctions du type : est un nombre premier,

Commence alors par écrire la fonction est_premier(). Teste-là et reviens nous montrer ton code.

[nipocham]

je vous remercie pour vos réponses.
dès que j'aurai fini avec le mook que je fais, j'irai voir ce fameux Swinnen. Merci de ce conseil.
le code, je l'ai trouvé vite, contrairement à un précédent :

Code :

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

1
2
3
4
5
6
def my_filter(m,f):
        z=[]
        for e in m:
            if f(e)==True:
                z.append (e)
        return z

où ai-je ici des pb de compréhension ? la boucle for dit que pour chaque e de la liste, si f(e) répond True, alors la liste z sera augmenté de cette variable e.
je me demande ceci : un boucle for fonctionne nécessairement avec une variable e et un "in" qui la place nécessairement dans un contenant ?

[nipocham]

voilà un problème avec une solution très moche, faite pour convenir à l'exerciseur :
Enoncé
On se donne une liste qui encode une séquence. Chaque élément de cette liste est un tuple de deux éléments: le nombre de répétitions successives de l'élément dans, et l'élément lui-même. Les éléments successifs répétés forment la séquence
Ecrivez une fonction décompresse, qui reçoit une telle liste en paramètre et renvoie la séquence sous forme d'une nouvelle liste.

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
def decompresse(l):
    z = []
    for v in l:
        x = v[0]
        y = v[1]
        y = str(y)
        if y == 'b':
            c = 'b' * 4
            z.append(c)
        if y == 'j':
            c = 'j' * 3
            z.append(c)
        if len(y) == 1 and y != 'j' and y != 'b':
            c = (",".join(x * y))
            z.append(c)
        if len(y) > 1:
            c = y * x
            z.append(c)
 
    l2 = []
    for n in z:
        s = n.split(',')
        if len(s) <0:
            try:
                s = map(int, s)
            except:
                pass
            l2.extend(s)
        if len(s) > 1:
            try:
                s = map(int, s)
            except:
                pass
            l2.extend(s)
        else:
            ln = len(n)
            li = 1
            while True:
                base = n[0:li]
                for i in range(li, ln, li):
                    if n[i:i + li] != base:
                        li += 1
                        break
                else:
                    break
            l2.extend(n[i:i + li] for i in range(0, ln, li))
    return l2

Ce code, m'a pris un temps fou. Sans Bistouille, j'y serais encore.
Mais ce qui vient de Bistouille m'est obscur : d'abord :

Code :

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

1
2
3
4
5
6
7
8
9
10
 z=['11111', 'bonjourbonjour', 'bbbb']
 l2 = []
    for n in z:
        s = n.split(',')
        if len(s) <0:
            try:
                s = map(int, s)
            except:
                pass
            l2.extend(s)

pour tout n de z, s est un --?--- issu de la séparation de n, si la longueur de n est < 0 , try (…?): s est un ….?...map ….?....(entier, s), except ….?....pass ….?....j'accrois l2 de s

[wiztricks]

Salut,

Enoncé
On se donne une liste qui encode une séquence. Chaque élément de cette liste est un tuple de deux éléments: le nombre de répétitions successives de l'élément dans, et l'élément lui-même. Les éléments successifs répétés forment la séquence
Ecrivez une fonction décompresse, qui reçoit une telle liste en paramètre et renvoie la séquence sous forme d'une nouvelle liste.

Je ne sais pas trop dans quel délire, vous êtes parti mais çà s'écrit:

Code :

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

1
2
3
4
5
def decompresse(liste):
      nliste = []
      for count, texte in liste:
           nliste.append( texte * count)
      return nliste

ce qui est proche de:

Code :

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

1
2
3
4
5
6
def my_filter(m,f):
        z=[]
        for e in m:
            if f(e)==True:
                z.append (e)
        return z

puisque dans les deux cas, on fabrique une nouvelle liste à partir d'une liste...

- W

[Sve@r]

voilà un problème avec une solution très moche, faite pour convenir à l'exerciseur :

Très moche en effet. Déjà pourquoi 'b' et 'j' sont traités différemment ? En tout cas, rien dans l'énoncé n'en parle.
Mais qu'est ce qui fait la mocheté du truc ? A mon avis c'est la démultiplication de variables et de lignes. Exemple

Code python :

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

1
2
3
4
5
6
x = v[0]
y = v[1]
y = str(y)                 # Horrible !!!
if y == 'b':
    c = 'b' * 4
    z.append(c)

Tout ça, ça peut se réécrire

Code python :

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

1
2
if v[1] == 'b':
    z.append('b' * 4)

Mais ce qui vient de Bistouille m'est obscur

Normal

pour tout n de z, s est un --?--- issu de la séparation de n, si la longueur de n est < 0 , try (…?): s est un ….?...map ….?....(entier, s), except ….?....pass ….?....j'accrois l2 de s

Ca fait appel à des notions que tu n'as pas forcément vu. try permet d'exécuter une action mais de se rattrapper si l'action n'est pas possible (exemple division par i et i qui atteint 0). map() applique une fonction à chaque élément d'un tableau et retourne le tableau qui en résulte.

[nipocham]

merci à vous wiztricks
vous utilisez for avec count: je ne connais pas cette utilisation. Pourriez-vous me dire où il est possible de trouver un topo exhaustif sur chaque élément de base du langage python, avec toutes ses utilisations en relation avec d'autres éléments ?

votre code est :

Code :

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

1
2
3
4
5
6
7
8
def decompresse(liste):
    n = []
    for count, t in liste:
        n.append(t * count)
    return n
ça donne ceci 
m=decompresse([('b',4), (7,4), ('bon',3)])
print(m)

['bbbb', '7777', 'bonbonbon'], mais l'exerciseur attend : ['b','b','b', 7,7,7,7,7, 'bon', 'bon']

[nipocham]

merci à toi Sve@r

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
def decompresse(l):
    z = []
    for v in l:
        x = v[0]
        y = v[1]
        y = str(y)
        if y == 'b':
            c = 'b' * 4
            z.append(c)
        if len(y) == 1:
        c = (",".join(x * y))
        z.append(c)

pour tout v d'une liste du genre [ (4,'b'), (3,'7')], je vais remplir une liste avec le résultat d'un produit prenant le premier terme comme multiplicateur et le second comme caractère répété x fois. Il faut bien que je dise : c=x*y. Donc au préalable que je dise ce qu'est x et y. Je présente donc x et y en tant que partie de v que je n'ai pas besoin de présenter puisqu'il est, de toute évidence une partie constitutive de la boucle for.
Ensuite je dois dire à l'exerciseur : si y est 'b' écrire 4 fois b. Car mon code ne permet pas de prendre en compte le cas (4,'e')
Il faut que je précise que y est un caractère : y = str(y)
D'une façon générale, je patauge toujours dès que je dois dire : soit a un entier, soit a une liste….Ca ne marche pas comme ça Python, il me semble.

[wiztricks]

Pourriez-vous me dire où il est possible de trouver un topo exhaustif sur chaque élément de base du langage python, avec toutes ses utilisations en relation avec d'autres éléments ?

Dans la documentation... et pour la boucle for c'est ici.

- W

[Sve@r]

merci à vous wiztricks
vous utilisez for avec count: je ne connais pas cette utilisation.

Non. Il a utilisé une variable qu'il a appelé "count". Ok, peut-être pas une super idée (moi je l'aurais nommée "cpt") mais ça reste compréhensible. Ceci dit, il a commis deux erreurs d'inattention

1. il a inversé car si "count" est le nombre de répétitions, l'instruction aurait dû être for (t, count) in liste (je trouve que les parenthèses aident à la lisibilité)
2. le chiffre "7" multiplié par 4 donne 28 et non "7777". L'instruction doit être n.append(str(t) * count)

votre code est :

Code :

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

1
2
3
4
5
6
7
8
def decompresse(liste):
    n = []
    for count, t in liste:
        n.append(t * count)
    return n
ça donne ceci 
m=decompresse([('b',4), (7,4), ('bon',3)])
print(m)

['bbbb', '7777', 'bonbonbon'], mais l'exerciseur attend : ['b','b','b', 7,7,7,7,7, 'bon', 'bon']

Remplace n.append(t * count) par n.extend((t for x in range(count))).

Et à la limite, la fonction toute entière peut alors s'écrire ainsi: decompresse=lambda liste: [tuple(t for (t, cpt) in liste for x in range(cpt))].

pour tout v d'une liste du genre [ (4,'b'), (3,'7')], je vais remplir une liste avec le résultat d'un produit prenant le premier terme comme multiplicateur et le second comme caractère répété x fois. Il faut bien que je dise : c=x*y. Donc au préalable que je dise ce qu'est x et y.

Quand tu as des pièces dans la poche gauche, est-ce que tu les transfères dans la poche droite avant de les utiliser pour te payer une glace ?
Tu as x qui est égal à v[0]. "égal à" !!! Tu sens la signfication de ce mot ??? v[0] contient déjà ce que tu veux utiliser. Pourquoi alors le copier dans "x" ? Si v[0] ne change pas, alors pas besoin de le copier ailleurs pour utiliser sa valeur.

Ensuite je dois dire à l'exerciseur : si y est 'b' écrire 4 fois b. Car mon code ne permet pas de prendre en compte le cas (4,'e')

Mouais. Là je ne pige pas. Rien dans l'énoncé ne précise que tu dois traiter différemment "b" et/ou "e". Bon, c'est toi qui voit.

Il faut que je précise que y est un caractère : y = str(y)

Déjà str() ne signifie pas "caractère" mais "chaine". Et si "y" est déjà une chaine (ce qui est le cas puisque y c'est v[1] et que "v" est une chaine) alors pas besoin. Mais admettons. Toutefois l'horreur ne se situait pas dans cette ligne mais dans l'ensemble des deux lignes combinées y = v[1] puis y = str(y) => y = str(v[1]) (utilisation intelligente d'une notion apprise en 6°: la transitivité => eh oui, ce n'est pas parce que ça a été appris à l'école que ça ne doit pas servir dans la vie) !!!

D'une façon générale, je patauge toujours dès que je dois dire : soit a un entier, soit a une liste….Ca ne marche pas comme ça Python, il me semble.

Non. Python fait du typage dynamique en fonction de ce qu'il reçoit. Si tu écris a=123 alors "a" sera "int". A la limite, tu utilises le cast uniquement pour changer si ce comportement par défaut ne te convient pas (comme en début de mon post où j'écris n.append(str(t) * count) parce que, quand la fonction reçoit 7, elle le prend comme un int alors que je veux le traiter comme une chaine).

[nipocham]

merci pour ta réponse

ton code est bref :
#def f(m):
n = []
for (t, c) in liste:
n.extend((t for x in range(c)))
return n
Il n'y a donc pas besoin de présenter ni le type d'éléments, ni la multiplication.
la boucle for prend deux éléments t et c dans ce que la fonction impose comme contenant :m
Elle ajoute à la liste n, t pour x dans …. et là je ne pige pas ...

[Sve@r]

ton code est bref :

Code python :

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

1
2
3
4
5
#def f(m):
    n = []
    for (t, c) in m:
        n.extend((t for x in range(c)))
    return n

Il n'y a donc pas besoin de présenter ni le type d'éléments, ni la multiplication.

Le souci de la multiplication tel que montré par wiztricks, c'est qu'elle garde le type de l'élément multiplié tel quel. Si tu multiplies 7 (un int) par 4, tu obtiens 28 (un int). Et si tu multiplies "b" (un str) par 4, tu obtiens "bbbb" (un str). Or toi, tu veux "b", "b", "b", "b" c'est à dire 4 str. Et pour çà, la multiplication ne peut pas s'appliquer.
Donc ce que je fais; je répète "c" fois l'action d'ajouter "t" dans le tableau

la boucle for prend deux éléments t et c dans ce que la fonction impose comme contenant :m

m contient une suite de tuples ('b',4), (7,4), ('bon',3). Le "for" permet de les séquencer un par un (donc d'abord ('b',4) puis (7,4) puis ('bon',3)) et de dispatcher à chaque itération chaque tuple dans "t" et "c". Un raccourci correspondant à une écriture plus classique

Code python :

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

1
2
3
for element in m:
    t=element[0]
    c=element[1]

Elle ajoute à la liste n, t pour x dans …. et là je ne pige pas ...

Il s'agit d'une forme d'écriture condensée appelée "liste en intensions" (qui caractérise une liste par sa définition et qui s'oppose à la liste en "extension" qui caractérise une liste par l'exemple) et qui se veut similaire à la notation mathématique des ensembles. Ainsi une écriture de ce style

Code python :

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

1
2
3
tab=[]
for x in range(10):
    tab.append(x)

s'écrira tab=[x for x in range(10)]. Plus simple à coder et à relire surtout que ça peut gérer plusieurs niveaux d'imbrication

Code python :

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

1
2
3
4
tab=[]
for i in range(10):
    for j in range(20):
        tab.append(i * j)

=> tab=[i*j for i in range(10) for j in range(20)]. Et si la liste n'a pas besoin d'évoluer ensuite, alors elle peut être remplacée par un tuple => tab=tuple(i*j for i in range(10) for j in range(20)).



Dans l'autre sens, cette écriture n.extend((t for x in range(c))) pourra s'écrire

Code python :

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

1
2
3
4
tmp=[]
for x in range(c):
    tmp.append(t)              # Stockage "c" fois de la chaine "t" dans "tab"
n.extend(tmp)              # On rajoute le tableau "tmp" au tableau "n"

Ceci dit, "tmp" n'est pas vraiment utile...

Code python :

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

1
2
for x in range(c):
    n.append(t)              # Rajout "c" fois la chaine "t" dans "n"

[wiztricks]

Salut,

Relisez l'énoncé:

On se donne une liste qui encode une séquence. Chaque élément de cette liste est un tuple de deux éléments: le nombre de répétitions successives de l'élément dans, et l'élément lui-même. Les éléments successifs répétés forment la séquence
Ecrivez une fonction décompresse, qui reçoit une telle liste en paramètre et renvoie la séquence sous forme d'une nouvelle liste.

Donc votre liste est de la forme [(nombre, élément), (nombre, élément),...]
Et la boucle qui parcours ces couples sera:

Code :

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

1
2
3
4
5
6
def decompresse(liste):
      nliste = []
      for count, element in liste:
           for z in range(count):
                nliste.append(element)
      return nliste

Reste que vous êtes supposé écrire cela avec le Python que vous avez appris. Donc si vous ne connaissez que les boucle while:

Code :

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

1
2
3
4
5
6
7
8
9
10
def decompresse(liste):
      nliste = []
      i, n = 0, len(liste)
      while i < n:
           count, element = liste[i]
           while count > 0:
                 nliste.append(element)
                 count = count+1
           i = i + 1
      return nliste

Et si vous connaissez les compréhensions de listes, vous pourriez écrire cela ainsi:

Code :

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

1
2
def decompresse(liste):
      return [ v for c, v in liste for _ in range(c) ]

- W

[Sve@r]

Relisez l'énoncé

Exact. J'avais pas regardé. Ton code était bon concernant l'ordre des éléments à récupérer. Désolé.