Category Archives: Python

Leggere e scrivere dizionari (e JSON)

Forse ne ho già parlato in passato (ma la memoria…) e non è nemmeno una cosa tanto interessante ma capita e allora ecco 😊

Il dictionary è un tipo che può tornare comodo, spesso. Ci sono diversi modi per creane; copio dalla documentazione:

a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})
a == b == c == d == e
True

Spesso nella pratica succede che la costruzione avviene più gradualmente:

d0.py

dic = {}

dic.update({1:'foo'})
k = 3
v = 'baz'
dic.update({k:v})
k = 'due'
v = 'bar'
dic.update({k:v})

print('dic =', dic)      #1

dic.update({5:'cinque'})
print('dic =', dic)      #2

dic.pop(5)               #3
print('dic =', dic)

Autoevidente ma comunque lo creo vuoto, lo popolo e visaulizzo (#1). Aggiungo un altro elemento (#2), che poi cancello (#3).

Questo è semplice, sarebbe possibile crearlo ogni volta, probabilmente con uno o più cicli leggendo i dati da file.

Ma se il dizionario, costruito in tempi successivi, supera una certa dimensione conviene scriverlo su file e poi rileggerlo quando serve.

Anticamente (non so se c’è anche su questo blog) usavo istruzioni molto semplici.
Per memorizzarlo su file:

d1.py

dic = {1: 'foo', 3: 'baz', 'due': 'bar'} #1
st = str(dic)                            #2
with open('dic', 'w') as f:
    f.write(st)

il dizionario dic in #1 è quello precedentemente costruito. Per scriverlo su file devo conventirlo in stringa (#2).

Successivamente posso leggerlo:

d2.py

with open('dic', 'r') as f:
    st = f.read()            #1

dic = eval(st)               #2
print(dic)
print(type(dic))             #3

lo leggo come stringa (#1) che valuto con eval() (#2) ottenendo quanto voluto (#3).

OK, funziona. Ma si può fare in modo più canonico (Python è un linguaggio ancora in evoluzione, nel senso che si aggiungono moduli a un ritmo sconvolgente).

d3.py

import json                  #1

with open('jdic', 'r') as f: #2
    try:
        dic = json.load(f)
    except ValueError:
        dic = {}

print(dic)

Sì, esiste il modulo json (#1) che fa quello che ci serve. Con un paio di avvertenze:

  • sia le chiavi che i valori devono essere stringhe;
  • occorre usare " come delimitatore di stringa; ' da errore.

Questo è il contenuto del file jdic

La scrittura su file del dizionario via json peraltro non è soggetta alle condizioni necessarie per la lettura; la conversione a stringa di chiavi e valori che si rendessero necessarie è trasparente:

d4.py

import json

dic = {1: 'foo', 3: 'baz', 'due': 'bar'} #1

with open('jdicw', 'w') as f: #2
    json.dump(dic, f)

Il formato JSON è molto popolare, Python si adegua, esiste json.tool che deve essere usato nel terminale:

🤩

Annunci

Non sempre i linguaggi sono uguali

Altro post su cose viste aggiornando script. Non so se interessa ma per me che sono niubbo… 😉

Questa è la versione minima di un codice che non fa quello che dovrebbe fare:

manca-0.py

def pari(n):
    print(n, "è pari")

def dispari(n):
    print(n, "è dispari")

def valeDieci():
    print('Dieci')

def p_d(n):
    ok = False
    if n % 2 == 0:
        ok = True
        pari(n)
    elif n % 2 == 1:
        dispari(n)
    elif ok and (n == 10):
        vale_dieci()

# main

p_d(5)
p_d(8)
p_d(10)

Come si vede la condizione ok and (n == 10) non viene eseguita anche quando il valore del parametro n è quello giusto. Ovvio ok è False, come settato all’inizio della funzione.

Probabilmente nello scrivere il codice si è fatta confusione tra leistruzioni if e switch/case. Quest’ultima è presente in tanti linguaggi (qui, qui e qui). A volte con nome diverso, p.es. case nel Basic, Delphi, Lisp (cond). Ma in questi linguaggi viene eseguito il primo caso vero, e si esce, è una variante di if/else if/.../else.

In Python manca, anche se c’è un modo semplice per costruirla, nella versione non-C.

La differenza fondamentale è che l’if non esamina tutti i casi (elif e else in Python) ma esce appena ne trova un caso vero. Quindi nel nostro caso la condizione eseguita è n % 2 == 0 cioè n è pari.

La correzione è immediata: suddividere l’if in due istruzioni:

manca-1.py

def pari(n):
    print(n, "è pari")

def dispari(n):
    print(n, "è dispari")

def valeDieci():
    print('Dieci')

def p_d(n):
    ok = False
    if n % 2 == 0:
        ok = True
        pari(n)
    elif n % 2 == 1:
        dispari(n)

    if ok and (n == 10):
        vale_dieci()

# main

p_d(5)
p_d(8)
p_d(10)

Uh! errore 💥 Manca la funzione vale_dieci().

Errore mio: l’ho definita come valeDieci(), correggo ed ecco:

manca-2.py

def pari(n):
    print(n, "è pari")

def dispari(n):
    print(n, "è dispari")

def vale_dieci():
    print('Dieci')

def p_d(n):
    ok = False
    if n % 2 == 0:
        ok = True
        pari(n)
    elif n % 2 == 1:
        dispari(n)

    if ok and (n == 10):
        vale_dieci()

# main

p_d(5)
p_d(8)
p_d(10)

OK! 😁

Personalmente non sapevo che l’interprete Python ignora le parti di codice che non deve eseguire immediatamente. Nei casi precedenti la chiamata alla funzione vale_dieci() non era richiesta e la sua mancanza non veniva rilevata. Ho provato con interpreti di altri linguaggi e il comportamento è analogo. Credo che questo non capiti con i linguaggi compilati (ma almeno anticamente il Fortran…), sarebbe da verificare.

Una curiosità: il nome di una funzione in Python è solo una variabile come tutte le altre. Esempio:

rinomina.py

def nome_vero(msg):
    print(msg, "\n")

#main
myfun = nome_vero

myfun("ciao!")
myfun("😊 😊 😊")

Va da sé che per me –sono vecchio– questo, se non per motivi particolari, va evitato.

coreano.py

def 안녕(msg):
    print(msg, "\n")

#main
myfun = 안녕

myfun("ciao! 안녕")
myfun("😊 😊 😊")

Sì in questo caso è OK; ma chi ha scritto quella funzione? E se dico “annyong” vado bene? E com’è che vale per loro ma non per tutti (cioè non per me)?

🤩

Essere semplici

Python è uno dei miei linguaggi preferiti. Recentemente mi è capitato di aggiornare script vecchi, scritti da me e da altri, di parecchi non si conosce l’autore. Ho materiale per un paio di post, oggi comincio con uno elementare ma per me che sono niubbo di una certa importanza.

Mi è successo di trovare, più volte, delle espressioni come queste:

Il risultato è chiaro:

e se ripeto l’istruzione torno al valore precedente

Non so se è corretto ma da noi questo è conosciuto come flip-flop (lo so che è anche un’altra cosa 😋).

Ma –tranne casi particolari– secondo me non si deve usare. Scrivere invece ok = True o ok = False. Il perché è semplice: nel debug (o aggiornamento) non devo ricordarmi il valore corrente per negarlo (ovviamente deve saperlo il programmatore iniziale).

Inoltre c’è il duck typing e Python ne è dentro fino al collo. Una variabile non solo varia (OK, come fanno le variabili ma adesso sono indaffarato con la programmazione funzionale) ma varia anche il tipo. E capitano cose come queste:

Siamo passati in modo trasparente da int a bool.

In certi linguaggi si definisce false come 0 e true come 1, o, –spesso– come non 0. È il nostro caso?

No, non esattamente: c’è identità tra 0 e False e tra 1 e True ma per gli altri valori non si sa.

Non ci limitiamo agli interi

Tra le versioni 2.x e 3.x è cambiata la sintassi per la valutazione dell’ugualianza tra valori. Mentre prima si usava <> per dire diverso adesso si deve scrivere !=

Ma capitano cose impreviste

cioè in questo caso è diverso da entrambi i possibili valori booleani. In questi casi –che non si dovrebbero usare– fare sempre il cast:

Dovrebbe essere possibile anche questo

anche se potrebbero insorgere problemi di arrotondamento.

E si può trafficare anche con le stringhe (ht _s 😁):

Non so se questo post ha una qualche valenza. Ma a me è capitato 😡

🤩

Un mystero pythonico – readline

Ieri Doug Hellmann racconta del suo modulo Python readline, qui: readline — The GNU readline Library.

Non l’ho seguito alla lettera, anzi, non sono così diligente. Però OK, funziona. Adesso vi conto.

Ecco uno script minimo, std.py:

while True:
    line = input('Prompt ("stop" to quit): ')
    if line == 'stop':
        break
    print('ENTERED: {!r}'.format(line))

Provo a eseguirlo…

Ahemmm… come già sapevo i tasti freccia, Home, Fine e simili non funzionano 😡

Ma, dice Doug… modifico lo script, adesso rl.py:

import readline

while True:
    line = input('Prompt ("stop" to quit): ')
    if line == 'stop':
        break
    print('ENTERED: {!r}'.format(line))

ed ecco:

OK! funzionano 😊

Notare che l’unica differenza è l’import di readline. readline non viene usata esplicitamente nel codice. Ma c’è e lavora. Guido, me lo spieghi? Anzi no, ancora più semplice: c’è nel manuale? e se no lo aggiungi? Grazie, nèh.

🤩

Leggere dati in formato CSV con impostazioni locali

Argomento già trattato anche da me in passato ma ogni tanto torna d’attualità.
Necessita di qualche istruzione collegata alle impostazioni locali e altre legate a preferenze personali. Per esempio non usare SciPy, anche se si usa Python, perché poi finisce su Windows. In compenso vale (dovrebbe, spero) sia per M$ Excel che per i fogli di calcolo FOSS; io uno Libre Office.

Ecco un file di dati in formato CSV (dati.csv), salvato con queste impostazioni

1;2;3;4;5,6;"sette";"più parole"
"04/10/17";"questa è la data";"e con separatore migliaia";1.234.567,89;;;
"fine";;;;;;

Nella shell IPython (ma sono OK tutte le altre) ecco, apro il file [1], leggo la prima riga [2] ed elaboro:

Si rende necessario togliere l’a-capo [4]; notare che le stringhe in Python sono immutabili quindi salvo l’elaborazione in sts, st resta invariata; questo anche successivamente passando da sts a stn.

Devo poi importare il modulo re [6], quello delle espressioni regolari che uso [7] per sostiture il separatore decimale virgola con il punto.

Dalla stringa ottengo gli elementi componenti, numeri interi e float e testo con split [9]

I componenti della lista **lst sono stringhe [13, 17] e devono essere convertiti con int [14] per gli interi e float [18] per o floating-point.

Passo ora alla seconda riga.

La data è semplicemente una stringa, sta al programmatore riconoscerla come tale.

Il numero in formato “valuta” non ci consente più di usare la regexp di prima per via della presenza del punto (separatore di migliaia) che si confonderebbe con il separatore decimale che vogliano ottenere. Dobbiamo pertanto eliminarlo [24] (non siamo contabili!) prima di regolarizzare il separatore decimale [25].

Attenzione: il punto per regexp significa “ogni carattere” per cui si è reso necessario “escaparlo [30] così: “\.“.

le liste derivanti da un file CSV hanno tutte la stessa lunghezza, con elementi vuoti corrispondenti alle celle non definite [35].

Facile, vero? 😊

🤢

SymPy – 26 – conclusioni

Continuo da qui.

L’esame di SymPy finisce qui. La documentazione continua, anzi entra nel vivo dopo il tutorial che ho esaminato. Ma (il bello di essere ormai fuori dal mondo del lavoro) ci sono altre cose –über-sexy– da seguire, prossimamente.

SymPy è OK. Essere integrato con Python, anzi essere Python, è un punto a suo favore (anzi di più!). Essere gestibile all’interno della REPL è un’altro punto. Per quel che ho visto conviene usare la REPL di Python o quella di IPython (come faccio io) e non quella integrata nel Web disponibile sul sito di SymPy: non è aggiornata e soggetta a rallentamenti non dovuti alla connessione.

Uno dei motivi che mi hanno portato alla scoperta di SymPy è la possibilità di visualizzare i risultati in formato LaTeX; quasi, c’è bisogno di qualche edizione dell’output.

Occorre usare l’output di print().

Si può inserire in WordPress in questa forma:

f{\left (x \right )} - 2 \frac{d}{d x} f{\left (x \right )} + 
\frac{d^{2}}{d x^{2}} f{\left (x \right )} = \sin{\left (x \right )}

tra i tag $latex#formula#$ e appare così:

f{\left (x \right )} - 2 \frac{d}{d x} f{\left (x \right )} + \frac{d^{2}}{d x^{2}} f{\left (x \right )} = \sin{\left (x \right )}

In alternativa si può utilizzare LaTeX Equation Editor.

Si può quindi scaricare l’immagine, cosa che faccio abitualmente (non sono tanto bravo con LaTeX), dopo aver modificato le opzioni come indicato in figura.

Un’alternativa (über-sexy, anzi di più) è Maxima (e wxMaxima, o GMaxima, o …); ne ho accennato in passato, sarebbe un’altra cosa da approfondire. Avendo tempo.

🤢

SymPy – 25 – manipolazione avanzata di espressioni – 3

Continuo da qui, copio qui.

Percorrere l’albero (tree)
With this knowledge [post precedente], let’s look at how we can recurse through an expression tree. The nested nature of args is a perfect fit for recursive functions. The base case will be empty args. Let’s write a simple function that goes through an expression and prints all the args at each level.

See how nice it is that () signals leaves in the expression tree. We don’t even have to write a base case for our recursion; it is handled automatically by the for loop.

Let’s test our function.

Can you guess why we called our function pre? We just wrote a pre-order traversal function for our expression tree. See if you can write a post-order traversal function.

Such traversals are so common in SymPy that the generator functions preorder_traversal and postorder_traversal are provided to make such traversals easy. We could have also written our algorithm as

Prevenire la valutazione dell’espressione
There are generally two ways to prevent the evaluation, either pass an evaluate=False parameter while constructing the expression, or create an evaluation stopper by wrapping the expression with UnevaluatedExpr.

If you don’t remember the class corresponding to the expression you want to build (operator overloading usually assumes evaluate=True), just use sympify and pass a string:

Note that evaluate=False won’t prevent future evaluation in later usages of the expression:

That’s why the class UnevaluatedExpr comes handy. UnevaluatedExpr is a method provided by SymPy which lets the user keep an expression unevaluated. By unevaluated it is meant that the value inside of it will not interact with the expressions outside of it to give simplified outputs. For example:

The x remaining alone is the x wrapped by UnevaluatedExpr. To release it:

Other examples:

A point to be noted is that UnevaluatedExpr cannot prevent the evaluation of an expression which is given as argument. For example:

Remember that expr2 will be evaluated if included into another expression. Combine both of the methods to prevent both inside and outside evaluations:

UnevalutedExpr is supported by SymPy printers and can be used to print the result in different output forms. For example

In order to release the expression and get the evaluated LaTeX form, just use doit():

Uhmmmm… un po’ pasticciato ma OK 😊

:mrgreen:

SymPy – 24 – manipolazione avanzata di espressioni – 2

Continuo da qui, copio qui.

Ricorsione attraverso l’albero delle espressioni
Now that you know how expression trees work in SymPy, let’s look at how to dig our way through an expression tree. Every object in SymPy has two very important attributes, func, and args.

func
func is the head of the object. For example, (x*y).func is Mul. Usually it is the same as the class of the object (though there are exceptions to this rule).

Two notes about func. First, the class of an object need not be the same as the one used to create it. For example

We created Add(x, x), so we might expect expr.func to be Add, but instead we got Mul. Why is that? Let’s take a closer look at expr.

Add(x, x), i.e., x + x, was automatically converted into Mul(2, x), i.e., 2*x, which is a Mul. SymPy classes make heavy use of the __new__ class constructor, which, unlike __init__, allows a different class to be returned from the constructor.

Second, some classes are special-cased, usually for efficiency reasons [note 3].

Note 3: Classes like One and Zero are singletonized, meaning that only one object is ever created, no matter how many times the class is called. This is done for space efficiency, as these classes are very common. For example, Zero might occur very often in a sparse matrix represented densely. As we have seen, NegativeOne occurs any time we have -x or 1/x. It is also done for speed efficiency because singletonized objects can be compared by is. The unique objects for each singletonized class can be accessed from the S object.

For the most part, these issues will not bother us. The special classes Zero, One, NegativeOne, and so on are subclasses of Integer, so as long as you use isinstance, it will not be an issue.

args
args are the top-level arguments of the object. (x*y).args would be (x, y). Let’s look at some examples

From this, we can see that expr == Mul(3, y**2, x). In fact, we can see that we can completely reconstruct expr from its func and its args.

Note that although we entered 3*y**2*x, the args are (3, x, y**2). In a Mul, the Rational coefficient will come first in the args, but other than that, the order of everything else follows no special pattern. To be sure, though, there is an order.

Mul’s args are sorted, so that the same Mul will have the same args. But the sorting is based on some criteria designed to make the sorting unique and efficient that has no mathematical significance.

The srepr form of our expr is Mul(3, x, Pow(y, 2)). What if we want to get at the args of Pow(y, 2). Notice that the y**2 is in the third slot of expr.args, i.e., expr.args[2].

So to get the args of this, we call expr.args[2].args.

Now what if we try to go deeper. What are the args of y. Or 2. Let’s see.

They both have empty args. In SymPy, empty args signal that we have hit a leaf of the expression tree.

So there are two possibilities for a SymPy expression. Either it has empty args, in which case it is a leaf node in any expression tree, or it has args, in which case, it is a branch node of any expression tree. When it has args, it can be completely rebuilt from its func and its args. This is expressed in the key invariant.

Key invariant
Every well-formed SymPy expression must either have empty args or satisfy expr == expr.func(*expr.args).

(Recall that in Python if a is a tuple, then f(*a) means to call f with arguments from the elements of a, e.g., f(*(1, 2, 3)) is the same as f(1, 2, 3).)

This key invariant allows us to write simple algorithms that walk expression trees, change them, and rebuild them into new expressions. Tutto questo nel prossimo post.

:mrgreen:

SymPy – 23 – manipolazione avanzata di espressioni – 1

Continuo da qui, copio qui.

In this section, we discuss some ways that we can perform advanced manipulation of expressions.

Capire l’albero delle espressioni
Before we can do this, we need to understand how expressions are represented in SymPy. A mathematical expression is represented as a tree. Let us take the expression 2x+xy, i.e., 2**x + x*y. We can see what this expression looks like internally by using srepr.

Quick Tip: To play with the srepr form of expressions in the SymPy Live shell, change the output format to Repr in the settings.

The easiest way to tear this apart is to look at a diagram of the expression tree:

Note: The above diagram was made using Graphviz and the dotprint function.

First, let’s look at the leaves of this tree. Symbols are instances of the class Symbol. While we have been doing

x = symbols('x')

we could have also done

x = Symbol('x')

Either way, we get a Symbol with the name “x” [We have been using symbols instead of Symbol because it automatically splits apart strings into multiple Symbols. symbols('x y z') returns a tuple of three Symbols. Symbol('x y z') returns a single Symbol called x y z]. For the number in the expression, 2, we got Integer(2). Integer is the SymPy class for integers. It is similar to the Python built-in type int, except that Integer plays nicely with other SymPy types.

When we write 2**x, this creates a Pow object. Pow is short for “power”.

We could have created the same object by calling Pow(2, x)

Note that in the srepr output, we see Integer(2), the SymPy version of integers, even though technically, we input 2, a Python int. In general, whenever you combine a SymPy object with a non-SymPy object via some function or operation, the non-SymPy object will be converted into a SymPy object. The function that does this is sympify [Technically, it is an internal function called sympify, which differs from sympify in that it does not convert strings. x + '2' is not allowed].

We have seen that 2**x is represented as Pow(2, x). What about x*y? As we might expect, this is the multiplication of x and y. The SymPy class for multiplication is Mul.

Thus, we could have created the same object by writing Mul(x, y).

Now we get to our final expression, 2**x + x*y. This is the addition of our last two objects, Pow(2, x), and Mul(x, y). The SymPy class for addition is Add, so, as you might expect, to create this object, we use Add(Pow(2, x), Mul(x, y)).

SymPy expression trees can have many branches, and can be quite deep or quite broad. Here is a more complicated example

Here is a diagram

This expression reveals some interesting things about SymPy expression trees. Let’s go through them one by one.

Let’s first look at the term x**2. As we expected, we see Pow(x, 2). One level up, we see we have Mul(-1, Pow(x, 2)). There is no subtraction class in SymPy. x - y is represented as x + -y, or, more completely, x + -1*y, i.e., Add(x, Mul(-1, y)).

Next, look at 1/y. We might expect to see something like Div(1, y), but similar to subtraction, there is no class in SymPy for division. Rather, division is represented by a power of -1. Hence, we have Pow(y, -1). What if we had divided something other than 1 by y, like x/y? Let’s see.

We see that x/y is represented as x*y**-1, i.e., Mul(x, Pow(y, -1)).

Finally, let’s look at the sin(x*y)/2 term. Following the pattern of the previous example, we might expect to see Mul(sin(x*y), Pow(Integer(2), -1)). But instead, we have Mul(Rational(1, 2), sin(x*y)). Rational numbers are always combined into a single term in a multiplication, so that when we divide by 2, it is represented as multiplying by 1/2.

Finally, one last note. You may have noticed that the order we entered our expression and the order that it came out from srepr or in the graph were different. You may have also noticed this phenomenon earlier in the tutorial. For example

This because in SymPy, the arguments of the commutative operations Add and Mul are stored in an arbitrary (but consistent!) order, which is independent of the order inputted (if you’re worried about noncommutative multiplication, don’t be. In SymPy, you can create noncommutative Symbols using Symbol('A', commutative=False), and the order of multiplication for noncommutative Symbols is kept the same as the input). Furthermore, as we shall see in the next section, the printing order and the order in which things are stored internally need not be the same either.

In general, an important thing to keep in mind when working with SymPy expression trees is this: the internal representation of an expression and the way it is printed need not be the same. The same is true for the input form. If some expression manipulation algorithm is not working in the way you expected it to, chances are, the internal representation of the object is different from what you thought it was.

Quick Tip: The way an expression is represented internally and the way it is printed are often not the same.

OK (quasi) panico 😯

:mrgreen:

SymPy – 22 – matrici – 2

Continuo da qui, copio qui.

Metodi avanzati
determinante
To compute the determinant of a matrix, use det.

reduced row echelon form (RREF)
To put a matrix into reduced row echelon form, use rref. rref returns a tuple of two elements. The first is the reduced row echelon form, and the second is a tuple of indices of the pivot columns.

Note: The first element of the tuple returned by rref is of type Matrix. The second is of type list.

nullspace
To find the nullspace of a matrix, use nullspace. nullspace returns a list of column vectors that span the nullspace of the matrix.

columnspace
To find the columnspace of a matrix, use columnspace. columnspace returns a list of column vectors that span the columnspace of the matrix.

aurovalori, autovettori e diagonalizzazione
To find the eigenvalues of a matrix, use eigenvals. eigenvals returns a dictionary of eigenvalue:algebraic multiplicity pairs (similar to the output of roots).

This means that M has eigenvalues -2, 3, and 5, and that the eigenvalues -2 and 3 have algebraic multiplicity 1 and that the eigenvalue 5 has algebraic multiplicity 2.

To find the eigenvectors of a matrix, use eigenvects. eigenvects returns a list of tuples of the form (eigenvalue:algebraic multiplicity, [eigenvectors]).

This shows us that, for example, the eigenvalue 5 also has geometric multiplicity 2, because it has two eigenvectors. Because the algebraic and geometric multiplicities are the same for all the eigenvalues, M is diagonalizable.

To diagonalize a matrix, use diagonalize. diagonalize returns a tuple (P,D), where D is diagonal and M=PDP−1.

Note that since eigenvects also includes the eigenvalues, you should use it instead of eigenvals if you also want the eigenvectors. However, as computing the eigenvectors may often be costly, eigenvals should be preferred if you only wish to find the eigenvalues.

If all you want is the characteristic polynomial, use charpoly. This is more efficient than eigenvals, because sometimes symbolic roots can be expensive to calculate.

Quick Tip: lambda is a reserved keyword in Python, so to create a Symbol called λ, while using the same names for SymPy Symbols and Python variables, use lamda (without the b). It will still pretty print as λ. (Unicode per λ: 955 0x3bb).

:mrgreen: