comment guider un apprenti

Version imprimable

27/03/2019, 18h33
nipocham

comment guider un apprenti

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.
27/03/2019, 20h33
wiztricks

Salut,

Citation:

Envoyé par nipocham

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.

Citation:

Envoyé par nipocham

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
27/03/2019, 21h40
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 ?
27/03/2019, 21h55
fred1599

Bonsoir,

Citation:

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.
27/03/2019, 22h12
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
28/03/2019, 09h44
BufferBob

salut,

Citation:

Envoyé par 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.

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 :)).
28/03/2019, 16h19
wiztricks

Salut,

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

Citation:

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
28/03/2019, 19h57
Sve@r
Bonjour

Citation:

Envoyé par nipocham

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.

Citation:

Envoyé par nipocham

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.

Citation:

Envoyé par nipocham

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

Citation:

Envoyé par nipocham

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.
28/03/2019, 23h36
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:

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 ?

problème mal résolu

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:

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:

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

29/03/2019, 07h59
wiztricks
Salut,

Citation:

Envoyé par nipocham

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:

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:

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
29/03/2019, 09h16
Sve@r
Citation:

Envoyé par nipocham

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
Citation:
Envoyé par nipocham

Code:

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:

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

Envoyé par nipocham

Mais ce qui vient de Bistouille m'est obscur

Normal

Citation:

Envoyé par nipocham

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.
29/03/2019, 20h00
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:

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

merci à toi Sve@r
Code:

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.

29/03/2019, 22h19
wiztricks

Citation:

Envoyé par nipocham

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
29/03/2019, 22h36
Sve@r
Citation:

Envoyé par nipocham

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)
Citation:
Envoyé par nipocham

votre code est :

Code:

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

Citation:

Envoyé par nipocham

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.

Citation:

Envoyé par nipocham

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.

Citation:

Envoyé par nipocham

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

Citation:

Envoyé par nipocham

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).
30/03/2019, 00h15
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 ...
30/03/2019, 02h58
Sve@r
Citation:
Envoyé par nipocham

ton code est bref :

Code:

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

Citation:

Envoyé par nipocham

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:

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

Envoyé par nipocham

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:

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:

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:

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:

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

Salut,

Relisez l'énoncé:

Citation:

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:

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:

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:

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

30/03/2019, 12h19
Sve@r

Citation:

Envoyé par wiztricks

Relisez l'énoncé

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