Essayez d'attribuer ou de changer avec Python: lambda

Ceci est le premier message. J'ai hâte de travailler avec vous.

Je vais toucher Python pour la première fois depuis longtemps avec RaspberryPi, et prendre note des résultats que j'ai poursuivis pour me faciliter la tâche.

Je ne suis pas particulièrement orienté vers la soi-disant obscurité. Alors faites-moi savoir si vous ne pouvez rien faire.

Et lambda? Pouvez-vous l'utiliser?

Je ne savais pas comment utiliser lambda avant. Je pense que j'aime le fait qu'il existe actuellement diverses restrictions. Je veux écrire tout ce qui est possible en lambda.

Prenons un exemple de tri rapide. Tout d'abord, en def?

def qs( xs ) :
        le = [x for x in xs[1:] if x<=xs[0] ]
        gt = [x for x in xs[1:] if x>xs[0] ]
        if xs == []:
                return []
        else:
                return qs( le ) + [ xs[0] ] + qs( gt )

Est-ce que c'est comme ça?

Pouvez-vous remplacer?

Si vous écrivez normalement avec lambda,

qs=(lambda xs :
	[] if xs == [] else
    qs( [x for x in xs[1:] if x<=xs[0] ] ) + [ xs[0] ] 
    + qs( [x for x in xs[1:] if x>xs[0] ] )
)

Pas mal, mais c'est long et désordonné. Je me demande si ce serait déf. Après tout. Il n'est pas possible d'affecter à une variable au milieu, mais il semble qu'elle puisse être liée à un nom et définie.

qs=(lambda xs :
    (lambda 
    	le = [x for x in xs[1:] if x<=xs[0] ] ,
    	gt = [x for x in xs[1:] if x>xs[0] ] :
            [] if xs == [] else
            qs( le ) + [ xs[0] ] + qs( gt )
    )()
)

N'est-il pas normal d'être propre? Je l'aime car il n'y a pas de retour ... Créez une autre expression lambda à l'intérieur et exécutez-la avec les arguments par défaut. Cela signifie que les arguments par défaut que vous définissez peuvent être utilisés comme variables, non?

À partir de l'expression lambda interne, vous pouvez utiliser des arguments et des variables en dehors de vous-même. Si vous faites quelque chose comme lambda x = 1, y = x:, y cherchera x à l'extérieur de vous au lieu du x = 1 suivant. Les arguments qui ne sont pas liés se trouvent dans la même expression lambda. S'il existe une relation de référence, modifiez l'étape. Le nombre d'étapes augmentera ou diminuera selon les besoins.

À propos, il semble préférable de ne pas définir d'arguments par défaut dynamiques autres que des constantes pour les arguments les plus externes. La valeur par défaut lorsqu'elle a été générée pour la première fois est enregistrée et ne fonctionne généralement pas comme prévu.

Changer, exécuter séquentiellement ...

Après tout, ce que tu veux faire avec lambda

1. Branche selon la condition dérivée de l'argument
2. Impur? Lors de l'exécution des opérations (entrée / sortie, affichage, etc.) de manière séquentielle
3. Faites un calcul pur et renvoyez la valeur.

J'ai l'impression d'être là-dessus. C'est un peu pénible de ne pouvoir utiliser que ~ if ~ else ~ quand il y a beaucoup de branches. Je veux d'abord écrire la condition et l'opération plus tard!

• Quelque chose comme un interrupteur (comme le garde d'Haskell)
• Parmi eux, celui qui renvoie une valeur lors de l'exécution séquentielle

Je voulais y arriver. Cependant, il n'a pas beaucoup de technologie, alors je l'ai abordé avec une apparence trompeuse.

Préparez-vous d'abord.

box=lambda *x:x
unbox=lambda x:x[-1]
    
do=box             
switch=unbox

Lors de l'utilisation

switch(
	(Condition 1)    and do(Formule d'exécution 1a,Formule d'exécution 1b,...)
	or (Condition 2) and do(Formule d'exécution 2a,Formule d'exécution 2b,...)
	...
	or            do(Dernier exécutable a,Dernier exécutable b,...)
)

Cela branchera conditionnellement, passera le résultat sous forme de taple à switch () tout en évaluant les expressions dans l'ordre avec do (), et switch () retournera le dernier élément du tapple. Le do () final est l'expression lorsque toutes les conditions sont fausses.

Le but de le mettre dans et hors du taple est d'empêcher la valeur de retour de l'expression d'exécution d'affecter le contrôle de et / ou.

Il n'y a pas de signification particulière à changer et à faire. Je pensais que ça pourrait être comme ça pour les humains, alors je l'ai changé. Il n'y a aucune fonction à imaginer à partir du nom.

• La fonction de dérivation est et / ou l'évaluation des courts-circuits.
• Boîte pour s'assurer que cela fonctionne
• Exécution séquentielle utilisant le fait que les arguments sont évalués lorsque la boîte de fonction est exécutée en même temps.
• Unbox pour récupérer la valeur de retour La fonction souhaitée est réalisée en combinant chaque élément. Cependant, s'il y a un commutateur ou écrit dans cette zone, il serait plus facile à lire et à écrire. Est-ce cool d'utiliser un garde ou un cond? motel?

Dans l'exemple de tri rapide

qs=(lambda xs :
    (lambda 
        le = [x for x in xs[1:] if x<=xs[0] ] , 
        gt = [x for x in xs[1:] if x>xs[0] ] :
        switch(
            xs == [] and do( [] )  
            or do( qs( le ) + [ xs[0] ] + qs( gt ) )
        )
    )()
)

Le nombre de personnages a un peu augmenté, mais d'une manière ou d'une autre, le sens semble être transmis. Je ne pense pas que je ferai une erreur.

Au fait, si vous écrivez la même chose normalement

qs=(lambda xs :
    (lambda 
        le = [x for x in xs[1:] if x<=xs[0] ] , 
        gt = [x for x in xs[1:] if x>xs[0] ] :
        (
            xs == [] and ( [], )  
            or ( qs( le ) + [ xs[0] ] + qs( gt ) ,)
        )[-1]
    )()
)

C'est bien avec ça. C'est un Han. Mais je ne suis pas sûr de ce que je fais, et quand je l'écrirai, j'oublierai [-1] et les virgules.