2 lacunes dans mes bases [Résolu]

[Luke spywoker]

Salut les pythons,
Je suis un python connaissant les bases du langage et ayant développer plusieurs applications qui fonctionnent (2000 lignes >) et j'ai donc développer un style et j'ai une petite expérience du python.

Mais je n'arrive pas combler 2 lacunes dans mes bases du langage:
-je n'arrive pas a mémoriser les syntaxes de car je ne les comprend pas:
--1) des fonction lambda.
--2) des listes d'expressions
A chaque fois que je dois utiliser ces notions je suis obliger de me plonger dans la doc après plusieurs échec des tests dans l'interpréteur.

Je sais qu'une fonction lambda est une fonction définis directement pour etre utiliser directement.
Je sais qu'une liste d'expression renvoie une liste en fonction de sa syntaxe.

Si il existe un Python a l'esprit didactique qui peut m'aider sa serai sympa, peut-etre sous forme de mémos écrit en pseudo-code.

Merci pour vos réponses et pour vos contribution a ma culture cybernétique.
Bon python a vous.

[ZZelle]

Pour les fonctions lambda:

Code :

f = lambda a,b: a+b

est équivalent à

Code :

1
2
def f(a,b):
    return a+b

Plus généralement ce qui est entre lambda et ":" définit les arguments de la lambda fonction et ce qui est après définit l'expression retournée par la lambda fonction:

Code :

f = lambda ...: ***

équivalent à

Code :

1
2
def f(...):
    return ***

Après si tu as du mal avec les lambda fonctions, tu peux utiliser des fonctions tout simplement.

Pour les listes d'expressions:
Je ne sais pas de quoi tu parles, ce qui suit c'est ce que tu appelles une liste d'expression ?

Code :

[attr for attr in dir(obj) if attr[0] != '_']

[Luke spywoker]

Merci pour la syntaxe des fonction lambda,
j'appelle une liste d'expression une structure qui commence avec:
en pseudo-code:

Code :

v for v in liste if v opérateur *

par exemple(je sais pas si c'est juste comme syntaxe).
J'ai ces lacunes car dans le livre qui m'a servi a apprendre les syntaxes de ces deux structure n'était que présent que sous forme d'exemple sans formulation syntaxique pure.
Merci pour votre aide.
PS: c'est aussi peut-etre du a l'interpréteur que j'utilise...?

[PsycoPy]

Bonjour,

Voulez-vous parler de List Comprehension ou de Generator Expression ?

[Luke spywoker]

Salut,
c'est de List Comprehension dont je parlais.

[PsycoPy]

Un exemple vaut souvent mieux qu'un long discourt :

Code :

1
2
3
4
ls = list()
for attr in dir(obj):
    if attr != '_':
        ls.append(attr)

Et voici l'équivalant avec une list comprehension :

Code :

ls = [ attr  for attr in dir(obj)  if attr != '_' ]

PS: Merci à ZZelle pour l'inspiration...

[mont29]

En fait, les list comprehensions (ou dict…, ou tuple…, ou set…, maintenant, en py3) ne sont qu’un raccourcis de generator expressions…

Code :

[a for a in range(10)]

est équivalent à…

Code :

list(a for a in range(10))

Et on peut donc les utiliser également pour générer un dict, par exemple:

Code :

{k: v for k, v in (('a', 1), ('b', 2), ('c', 3))}

Les exemples donnés ci-dessus n’ont évidemment pas grand intérêt, mais cette construction permet des conversions ou sélections d’iterables quelconques, relativement complexes, en une seule ligne. Leur expression abstraite est*:

Code :

expression(el1[, el2, …]) for el1[, el2, …] in iterable [if condition1 [if condition2 …]]

expression peut être toute expression python, appel d’une fonction, définition d’une liste/tuple/…, opérateurs comme l’addition/multiplication/etc.

for el1[, el2, …] in iterable est exactement la même chose qu’une boucle for classique*!

[if condition1 [if condition2 …]] sont un ou plusieurs tests – si l’un d’entre eux renvoie False, le ou les éléments en cours sont ignorés, et on passe direct aux suivants.

En forme développée, cela donne, pour une liste comprehension*:

Code :

1
2
3
4
5
6
7
8
lst = []
for el1[, el2, …] in iterable:
    [if condition1:
        continue
    [if condition2:
        continue
    ]]
    lst.append(expression(el1[, el2, …]))

De façon plus générale, une generator expression peut se “développer” comme cela:

Code :

function(expression(el1[, el2, …]) for el1[, el2, …] in iterable [if condition1 [if condition2 …]])

Code :

1
2
3
4
5
6
7
8
9
def gen(iterable):
    for el1[, el2, …] in iterable:
        [if condition1:
            continue
        [if condition2:
            continue
        ]]
        yield expression(el1[, el2, …]))
function(gen(iterable))

Je ne sais pas si c’est suffisamment clair… De toute façon, il en est de ces expressions comme des regex et de beaucoup d’autre chose – la meilleure façon de les comprendre, c’est de les utiliser (en commençant par des cas simples, évidemment).

[wiztricks]

Salut,
Pensez aussi à lire les PEPs:

• PEP255 -- Simple Generators
• PEP 289 -- Generator Expressions
• PEP 342 -- Coroutines via Enhanced Generators

Ils permettent de remettre les choses dans un contexte et décrivent les cas d'utilisation les plus courants.
- W

[Sekigo]

Bonjour.

Alors, j'apporte une petite précision sur les lambdas. Au départ, j'ai eu du mal à saisir le concept. M'en servir, oui, mais leur utilité, je ne comprenais pas.
Jusqu'au jour où j'ai commencé à comprendre la POO de python, et que tout est objet, y compris les fonctions.

Un exemple :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
>>> def myFunction(x):
...     return x*x
... 
>>> f = myFunction
>>> l = lambda x: x*x
>>> f
<function myFunction at 0xb723f144>
>>> l
<function <lambda> at 0xb723f33c>
>>> f(64)
4096
>>> l(64)
4096
>>> dir(l)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']
>>> dir(f)
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__', '__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

Ça peut paraître idiot, ou un truc de base pour n'importe quel programmeur, mais quand j'ai compris cela, j'ai ENFIN commencé à comprendre un peu mieux la POO "hors des classes de base".
Bon, après, on utilise (relativement) rarement les lambdas. Mais c'est toujours mieux de comprendre à quoi ça sert.

Edit : j'ai l'impression en me relisant de parler du seigneur des anneaux...

[tyrtamos]

Bonjour,

Petit complément pour la "list comprehension" (quel nom bizarre...): on peut utiliser plusieurs boucles 'for' à la suite, qui fonctionneront comme des boucles imbriquées:

Code :

1
2
print [ [i,j,k]  for i in range(4) for j in range(8) for k in range(3)]
[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 2, 0], [0, 2, 1], [0, 2, 2], [0, 3, 0], [0, 3, 1], [0, 3, 2], [0, 4, 0], [0, 4, 1], [0, 4, 2], [0, 5, 0], [0, 5, 1], [0, 5, 2], [0, 6, 0], [0, 6, 1], [0, 6, 2], [0, 7, 0], [0, 7, 1], [0, 7, 2], [1, 0, 0], [1, 0, 1], [1, 0, 2], [1, 1, 0], [1, 1, 1], [1, 1, 2], [1, 2, 0], [1, 2, 1], [1, 2, 2], [1, 3, 0], [1, 3, 1], [1, 3, 2], [1, 4, 0], [1, 4, 1], [1, 4, 2], [1, 5, 0], [1, 5, 1], [1, 5, 2], [1, 6, 0], [1, 6, 1], [1, 6, 2], [1, 7, 0], [1, 7, 1], [1, 7, 2], [2, 0, 0], [2, 0, 1], [2, 0, 2], [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 2, 0], [2, 2, 1], [2, 2, 2], [2, 3, 0], [2, 3, 1], [2, 3, 2], [2, 4, 0], [2, 4, 1], [2, 4, 2], [2, 5, 0], [2, 5, 1], [2, 5, 2], [2, 6, 0], [2, 6, 1], [2, 6, 2], [2, 7, 0], [2, 7, 1], [2, 7, 2], [3, 0, 0], [3, 0, 1], [3, 0, 2], [3, 1, 0], [3, 1, 1], [3, 1, 2], [3, 2, 0], [3, 2, 1], [3, 2, 2], [3, 3, 0], [3, 3, 1], [3, 3, 2], [3, 4, 0], [3, 4, 1], [3, 4, 2], [3, 5, 0], [3, 5, 1], [3, 5, 2], [3, 6, 0], [3, 6, 1], [3, 6, 2], [3, 7, 0], [3, 7, 1], [3, 7, 2]]

Ce qui donnera le même résultat que:

Code :

1
2
3
4
5
6
7
8
def toto():
    L = []
    for i in range(4):
        for j in range(8):
            for k in range(3):
               L.append([i,j,k])
    return L
print toto()

Et, puisqu'on parle sur ce fil de la "list comprehension" et de "lambda", il est quelquefois intéressant d'utiliser les 2 en même temps:

Code :

1
2
toto = lambda im, jm, km: [[i,j,k]  for i in range(im) for j in range(jm) for k in range(km)]
print toto(4,8,3)

Ce qui donne encore le même résultat que précédemment.

[Luke spywoker]

Merci pour vos explications et exemples dont certains me dépasse, pour les fonction lambda j'ai saisie la syntaxe de base:

Code :

lambda a b : return a+b

Mais pour les listes de compréhension un truc me dérange dans l'insertion de la syntaxe dans les circuits de ma mémoire:
C'est une boucle coupler avec une structure conditionnelle qui renvoie une liste mais dans cette boucle pourquoi ajouter une variable devant la boucle...?
Faut-il quelle soit la meme que celle dans la boucle ?
Est-ce la valeur retourner en fonction de la condition ?

PS: j'ai déja utilser une liste de compréhension dans un de mes programmmes pour extraire un fichier image, conditionnellement, d'un os.listdir() afin d'avoir le résultat dans une liste directement pour pouvoir directement l'utilser avec avec PIL et Tkinter (la référence a l'objet image doit etre contenus dans un conteneur pour sa pérénité dans l'espace de nom).

Merci pour vos réponses.

[mont29]

On n’“ajoute” pas une variable devant la boucle, on indique à python que faire de ce que la boucle génère. Le cas le plus simple est de l’utiliser tel quel*:

Code :

1
2
>>> [el for el in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Mais tu peux faire des opérations :

Code :

1
2
>>> [el%3 for el in range(10)]
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0]

Appeler des fonctions*:

Code :

1
2
>>> [chr(el) for el in range(48, 58)]
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

etc.

À propos des lambda*:
1) N’oublie pas les virgules séparant les paramètres*!
2) Ne pas utiliser return*! Il est implicite, dans une lambda*:

Code :

lambda a, b: a + b

[Luke spywoker]

Merci cette fois le flux nerveux de la syntaxe des liste d'expression circule dans les méandres de ma mémoire j'ai fait un test qui comme toi a confirmer la supposition que j'ai faite et le test aussi:

Est-ce la valeur retourner en fonction de la condition ?

par:

Code :

1
2
3
4
5
 
a=[('a',1),('b',2),('c',3)]
b=[ v[1] for v in a if v[0] == 'a']
b
[1]

Merci a tous ceux qui ont participer a combler ces lacunes maintenant je crois avoir les bases bien acquis sans lacune aucune.

[fred1599]

Je ferais plutôt cela

Code :

b = [v for u, v in a if u == 'a']

[Luke spywoker]

Je ne savais pas qu'on pouvait donner les éléments des éléments afin itérer dessus a la boucle...?
Je pensais que for devrait itérer sur les tuples mais pas leurs contenus, est-ce-que la boucle analyse le (ici les) paramètre(s) qui lui sont passer...???
Peut tu expliquer la mécanique.
Car normalement en itérant sur la variable a, v devrai prendre la valeur du tuple...??? et comme tu lui donne 2 paramètres je ne vois pas comment, celle-çi qui est censé parcourir la variable a, peut accéder a son sous-contenus automatiquement.
J'aurai fait une double itération pour itérer sur le contenu du tuple ou donner l'indice comme je l'ai fait.
Je me coucherai vraiment moins bete ce soir.

[fred1599]

Tu as une liste de tuples donc à la base on peut faire

Code :

1
2
3
4
5
6
7
8
9
10
11
>>> a=[('a',1),('b',2),('c',3)]
>>> u, v = a[0]
>>> u
'a'
>>> v
1
>>> for u, v in a:
...     if u == 'a':
...         print v
... 
1

[PauseKawa]

Bonsoir,

Petit quizz par rapport à ceci (désolé tyrtamos, c'est l'exemple le plus complet pour un cut/paste...):

Envoyé par tyrtamos

Code :

print [ [i,j,k]  for i in range(4) for j in range(8) for k in range(3)]

...

Code :

...

Code :

Ce qui donne encore le même résultat que précédemment.

Si le résultat est le même le plus lisible n'est il pas préférable ? (import this/pep's)

Pour la performance ? Difficile de faire plus rapide que for/in (et in en général pour le code) pour une itération.
A la limite une closure ?

Bref, il existe des limites aux (object)compréhensions et autres lambda: La lecture du code (quand jeune padawan relira son code plus tard, les cheveux il s'arracheras et sa pythonnerie il regretteras).

Votre avis ?

@+

[fred1599]

Bref, il existe des limites aux (object)compréhensions et autres lambda: La lecture du code

Je ne trouve pas que c'est un frein à la compréhension d'un code. Quand je lis les codes sur le net, beaucoup utilise les lists comprehensions, et ça ne me gêne pas en soi.

Bref, à partir du moment où t'en as bouffé, lire ou écrire vient strictement au même, mais j'avoue très certainement que l'expérience à ce niveau paie.

[dividee]

Bonsoir,

Envoyé par PauseKawa

Si le résultat est le même le plus lisible n'est il pas préférable ? (import this/pep's)

Je suis d'accord, mais lequel est le plus lisible ?
Je suppose que tu trouves le 3ème code moins lisible que les autres, mais il fait "un peu plus" que les autres; il crée une fonction paramétrée. Ce serait inutilement complexe de l'écrire ainsi si la fonction n'était appelée qu'une seule fois, mais sinon c'est utile.
Bien sûr on peut aussi l'écrire:

Code :

1
2
def toto(im, jm, km):
    return [[i,j,k]  for i in range(im) for j in range(jm) for k in range(km)]

Mais est-ce vraiment moins lisible avec lambda ?

Bref, il existe des limites aux (object)compréhensions et autres lambda: La lecture du code (quand jeune padawan relira son code plus tard, les cheveux il s'arracheras et sa pythonnerie il regretteras).

Pour ma part, je trouve que les compréhensions augmentent la lisibilité (en règle générale). Le seul cas où j'évite de les utiliser, c'est avec des effets de bord, par exemple un print() dans une compréhension (ce qui est possible en Python 3), je n'aime pas...

Pour les lambda c'est moins le cas, mais elles ont leur place, par exemple pour préciser l'argument key avec la méthode sort ou pour certains callbacks avec tkinter par exemple.

Et ces constructions ne sont pas nécessaires pour écrire un code illisible

[mont29]

Certes, utiliser ce genre de fonctionnalités “avancées” n’est pas indispensable, et “complique” la lecture pour quelqu’un de moins expérimenté/habitué…

Mais sans même parler de performances, rien que le fait d’utiliser quatre ou cinq lignes de moins, moi, quand je travaille sur de gros fichiers, ça me parle…

Et à choisir, je préfère encore largement une list comprehension, même complexe, à (par exemple) ce truc de l’initialisation par défaut des paramètres optionnels de fonction (qui fait qu’on se retrouve avec le même objet à chaque appel de la fonction…) –*ça c’est un truc vraiment vicieux, à la (re)lecture d’un code… Et pourtant, ça peut être diablement pratique, parfois*!