Aide pour écrire des fonctions en Python

[LegoTheoCrush]

Bonjour.

Je débute en Python et je dois programmer des fonctions en utilisant des listes.
On s'intéresse aux applications allant de E = [0;n-1] vers E (ce sont des entiers naturels) et on considère pour toute partie A de N la liste lA de longueur n telle que pour tout i de E on ait :
lA= (1 si i appartient à A) (0 si i n'appartient pas à A) (en gros c'est une espèce de fonction indicatrice)

À toute application f allant de E dans E on associe la liste l_f = [f(0),f(1),...,f(n-1)] avec pour tout i appartenant à [0;n-1] (entier) on ait l_f=f(i).

J'aimerais savoir comment on peut écrire facilement une fonction imagedirecte et une fonction imagereciproque prenant en argument la liste l_f associée à une application f de lA qui retourne la liste correspondant à l'image directe f(A) de A par f. De même pour l'image réciproque, je veux obtenir la liste associée à l'image réciproque f-1(A) de A par f.

Merci par avance pour votre aide.

[X2017]

J'ai pas trop compris mais peut-être tu recherches map(f, liste) qui renvoi une liste où f a été appliquée à tous les éléments

[LegoTheoCrush]

En fait, j'ai simplement l_f une liste donc les éléments sont les images de chaque élément de E par f, comme je l'ai défini, c'est effectivement f appliquée à chaque élément de la liste.

[left_shift]

Je pense que ce dont tu as besoin, c'est de la notion de liste définie par compréhension.

Considère l'exemple suivant :

E = range(10)
f = [4, 6, 7, 4, 2, 0, 1, 3, 6, 8]

Nous avons ici n = 10 et f(0) = 4, f(1) = 6, f(2) = 7, ... f(9) = 8.

On définit les deux fonctions :

def image_directe(f, A):
....return [f[x] for x in A]

def image_reciproque(f, B):
....return [x for x in E if f[x] in B]

(Ces deux fonctions renvoient des listes définies par compréhension.)

Par exemple, si A = {1, 5, 3, 2} on obtient :

>>> image_directe(If, [1, 2, 3, 5])
[6, 7, 4, 0]

Si B = {3, 4, 5} on obtient :

>>> image_reciproque(If, [3, 4, 5])
[0, 3, 7]

[LegoTheoCrush]

D'accord, merci, c'est très clair.
Je peux alors étendre cette écriture au cas général ? (Pour un ensemble et des fonctions quelconques)

[left_shift]

Oui bien sur, la notion de liste par compréhension est vraiment très proche de la notation mathématique correspondante. Voici par exemple une définition de la liste des triplets pythagoriciens inférieurs ou égaux à 100 :

[(x, y, z) for x in range(1, 101) for y in range(x, 101) for z in range(y, 101) if x*x + y*y == z*z]

Un autre exemple amusant mais plus compliqué à comprendre pour définir la liste des nombres premiers inférieurs ou égaux à 100 :

noprimes = [j for i in range(2, 10) for j in range(2*i, 100, i)]
primes = [p for p in range(2, 100) if p not in noprimes]

[LegoTheoCrush]

Cette écriture est-elle valable également dans le cadre de la composition de fonctions ?
Par exemple, si pour faire la composée de deux fonctions, je veux le faire avec des listes, si je comprends bien, ça donne quelque chose comme ça :
L = []
For i un range (0,n-1):
L.append(f(g(i)))

Ça le fait ?

[fakbill]

Non pas du tout
On te parlait de list comprehension.

Là, tu nous mets juste une liste et un append en boucle.
Ton code produit une liste qui est formé des f(g(i)) mais il est assez mauvais car il fait une boucle explicite avec un append. C'est nettement plus "python" de faire ça avec une comprehension list genre [f(g(i)) for i in range(n-1)]
AU fait, en info on commence TOUJOURS par compter à partir de 0 donc on ne le met pas dans le range.

[LegoTheoCrush]

Donc j'écris :
def Composition(l_f,l_g):
....L=[]
....return[f(g(i)) for i un range(n-1)]

[left_shift]

Plutôt, compte tenu de la représentation choisie (une fonction est représentée par la liste des valeurs prises sur [0,n-1]) :

def composition(I_f, I_g):
....return [I_f[I_g[x]] for x in E]

Toujours en ayant posé E = range(n)

ou plus simplement encore :

def composition(I_f, I_g):
....return [I_f[y] for y in I_g]

(mais cette solution ne fonctionnera pas si E est différent de range(0, n)).