Category Archives: Python

NumPy – 6 – IPython e i comandi della shell

nikon-small-world-a-daisys-central-disc-pattern-of-tiny-unopened-flowers

Continuo da qui a copiare qui.

When working interactively with the standard Python interpreter, one of the frustrations is the need to switch between multiple windows to access Python tools and system command-line tools. Si riferisce agli utenti normali; io invece ho sempre almeno due terminali aperti. Vi ho mai raccontato di quando il terminale era solo alfanumerico, niente finestre e allora si usava & –e ph (phantom) sul Pr1me–, scomodo ma bei tempi, ero giovane. CMQ… IPython bridges this gap, and gives you a syntax for executing shell commands directly from within the IPython terminal. The magic happens with the exclamation point: anything appearing after ! on a line will be executed not by the Python kernel, but by the system command-line.

Introduzione rapida alla shell
Mi sa che salto, niente di nuovo, anzi… come dicevo 😊

Comandi di shell in IPython
Shell commands can not only be called from IPython, but can also be made to interact with the IPython namespace. For example, you can save the output of any shell command to a Python list using the assignment operator:

np34

Note that these results are not returned as lists, but as a special shell return type defined in IPython:

np35

Sembra una lista ma ha funzionalità in più come si può scoprire nell’help di IPython.

Communication in the other direction–passing Python variables into the shell–is possible using the {varname} syntax:

np36

The curly braces contain the variable name, which is replaced by the variable’s contents in the shell command.

Comandi magici relativi alla shell
Non si può usare !cd perché i comandi sono eseguiti in una sub-shell. Ma se proprio vuoi c’è %cd

np37

In fact, by default you can even use this without the % sign:

np38

This is known as an automagic function, and this behavior can be toggled with the %automagic magic function.

Besides %cd, other available shell-like magic functions are %cat, %cp, %env, %ls, %man, %mkdir, %more, %mv, %pwd, %rm, and %rmdir, any of which can be used without the % sign if automagic is on. This makes it so that you can almost treat the IPython prompt as if it’s a normal shell: This access to the shell from within the same terminal window as your Python session means that there is a lot less switching back and forth between interpreter and shell as you write your Python code.

Chissà se funziona anche per gli aliases? No, non esattamente come vorrei: non considera quelli definiti da me. E poi, dai, basta avere un altro terminale aperto; io ne ho sempre almeno due, senza contare quello di tilda 😊

np39

Uh! funziona con gli shell scripts 😄

:mrgreen:

NumPy – 5 – Input, output e history di IPython

cuvyveqviaajb2

Continuo da qui a impratichirmi con la REPL di IPython copiando qui. Non ho ancora capito come fare a dirgli di considerare che voglio Python 3 e non il 2.x ma no credo dipenda da me. Il tempo aggiusterà tutto, spero  😊

Abbiamo visto che i comandi precedenti sono accessibili con i tasti freccia o C-p e C-n (d’ora in poi userò le abbreviazioni Emacs), ma ce ne sono altre.

Gli oggetti In e Out di IPython
I comandi precedenti sono memorizzati in In e gli output in Out, esempio:

np28

sì, version 2.7; lo stesso con Out:

np29

Note that not all operations have outputs: for example, import statements and print statements don’t affect the output. The latter may be surprising, but makes sense if you consider that print is a function that returns None; for brevity, any command that returns None is not added to Out.

Questo può tornare utile, per esempio:

np30

Uso di _ come e outputs precedenti
A differenza della REPL nativa di Python che consente di richiamare con _ solo l’ultimo output con IPython ci sono tutti, aumentando il numero di _:

np31

Sopprimere l’output
Sometimes you might wish to suppress the output of a statement (this is perhaps most common with the plotting commands that we’ll explore in Introduction to Matplotlib). Or maybe the command you’re executing produces a result that you’d prefer not like to store in your output history, perhaps so that it can be deallocated when other references are removed. The easiest way to suppress the output of a command is to add a semicolon to the end of the line:

np32

se l’è presa, non volevo, ancora ‘mici? 🌷 😊

Comandi magici relativi

np33

Notare che quanto detto sopra per i comandi non memorizzati vale solo per la versione 3.x di Python.

Other similar magic commands are %rerun (which will re-execute some portion of the command history) and %save (which saves some set of the command history to a file).

OK 😊 ma quando arriviamo alle cose sexy? 😀

:mrgreen:

NumPy – 4 – Comandi “magici” di IPython

nikon-small-world-algae-cells

Continuo da qui a copiare qui.

Oltre a tutto quanto visto finora ci sono i comandi magici, quelli che iniziano con %. Magic commands come in two flavors: line magics, which are denoted by a single % prefix and operate on a single line of input, and cell magics, which are denoted by a double %% prefix and operate on multiple lines of input.

Incollare testo con %paste e %cpaste
C’è il problema dell’indentazione quando si copia di brutto e allora ecco:
Abbiamo il seguente codice da copiare

def donothing(x):
    return x

se lo faccio con copia+incolla ottengo

np20

che ovviamente non va! invece copio e poi

np21

A command with a similar intent is %cpaste, which opens up an interactive multiline prompt in which you can paste one or more chunks of code to be executed in a batch.

Eseguire codice esterno con %run

Avendo il file square.py:

def square(x):
    """square a number"""
    return x ** 2

for N in range(1, 4):
    print(N, "squared is", square(N))

si può eseguire all’interno di IPython

np22

OKkatz! 👿 Ipython usa la versione 2.x, guarda qui:

def square(x):
    """square a number"""
    return x ** 2

for N in range(1, 4):
    print N, "squared is", square(N)

np23

Questa cosa andrà chiarita e corretta prima di continuare 😜 –da fare per il prossimo post.

Tempo di esecuzione con %timeit
Another example of a useful magic function is %timeit, which will automatically determine the execution time of the single-line Python statement that follows it. For example, we may want to check the performance of a list comprehension:

np24

e si può fare anche

np25

Help per le funzioni magiche ?, %magic e %lsmagic

? genera uno spiegone kilometrico

np26

Si può chiedere l’help per le singole funzioni magiche, p.es. ? %timeit.

%lsmagic lista le funzioni magiche disponibili

np27

E ce ne sono anche altre, raccontate prossimamente.

:mrgreen;

NumPy – 3 – Scorciatoie da tastiera nella REPL di IPython

luna

Proseguo da qui, copiando qui.

Tutti (ahemmm… kwasy) conoscono e usano le keyboard shortcuts scorciatoie da tastiera; qualcuno poi esagera vi, Emacs con vantaggi considerevoli, ma roba da nerds terminali 😉

The IPython shell doesn’t go this far, but does provide a number of keyboard shortcuts for fast navigation while typing commands. These shortcuts are not in fact provided by IPython itself, but through its dependency on the GNU Readline library: as such, some of the following shortcuts may differ depending on your system configuration. Also, while some of these shortcuts do work in the browser-based notebook, this section is primarily about shortcuts in the IPython shell.

Quelle usuali:

np14

e le entry

np15

e quelle dell’history

np16

The reverse-search can be particularly useful. Recall that in the previous section we defined a function called square. Let’s reverse-search our Python history from a new IPython shell and find this definition again. When you press Ctrl-r in the IPython terminal, you’ll see the following prompt:

np17

cominci a scrivere e puoi continuare con Ctrl-R sino a quando trovi quello che cerchi:

np18

poi premi Invio e ci sei 😀

Altre scorciatoie

np19

While some of the shortcuts discussed here may seem a bit tedious at first, they quickly become automatic with practice. Once you develop that muscle memory, I suspect you will even find yourself wishing they were available in other contexts. Certo Jake, grazie 😀

:mrgreen:

NumPy – 1 – oltre Python

nikon-small-world-ammonite-shell
Inizio (come annunciato qui) con Python Data Science Handbook di Jake VanderPlas. In particolare seguo (ahemmm… copio) la Jupyter notebook version. Mi sembra che Jake lo consenta, Jake rockz! 😀 e allora sono pronto per iniziare, qui: IPython: Beyond Normal Python.

Partiamo dall’inizio, dice, io uso IPython e un text-editor.
L’editor che usa Jake è più lussuoso di quello che uso io —gedit— e se posso non lo cambio, per ragioni di compatibilità con i miei contatti e poi perché sono vecchio e ai miei tempi l’editor faceva solo l’essenziale; prima del vi.

Invece come ambiente (environment, quello che io chiamo di solito REPL) Jake usa e raccoanda IPython, mi adeguo, anche perché sì rockz! 😀

IPython is about using Python effectively for interactive scientific and data-intensive computing. This chapter will start by stepping through some of the IPython features that are useful to the practice of data science, focusing especially on the syntax it offers beyond the standard features of Python. Next, we will go into a bit more depth on some of the more useful “magic commands” that can speed-up common tasks in creating and using data science code. Finally, we will touch on some of the features of the notebook that make it useful in understanding data and sharing results.

IPython può essere usato in due modi, shell e notebook; prendere quell più conveniente caso per caso, intanto vediamoli.

Lanciare la shell di Ipython
This chapter, like most of this book, is not designed to be absorbed passively. I recommend that as you read through it, you follow along and experiment with the tools and syntax we cover: the muscle-memory you build through doing this will be far more useful than the simple act of reading about it. Start by launching the IPython interpreter by typing ipython on the command-line.
C’è anche l’help, sempre di Jake: Help and Documentation in IPython.
Siccome scrivere ogni volta ipython sarebbe troppo lungo, anche perché al solito io lo faccio con opzioni, prima di subito mi sono creato l’alias:

np0

sì, lo so, ho qualche settaggio non a posto –who cares. E anche

np1

e così via 😀

Lanciare il Jupyter Notebook
The Jupyter notebook is a browser-based graphical interface to the IPython shell, and builds on it a rich set of dynamic display capabilities. As well as executing Python/IPython statements, the notebook allows the user to include formatted text, static and dynamic visualizations, mathematical equations, JavaScript widgets, and much more. Furthermore, these documents can be saved in a way that lets other people open them and execute the code on their own systems.

np2

Figo Fine, ma sapete io sono vecchio, solitario, per adesso so che c’è poi chissà… Le previsioni riguardo al futuro… (inizio-cit).

OK, per oggi basta. Anche perché –sapete– c’è sempre il rischio 😉
:mrgreen:

NumPy – inizio, sarà lunga – 0

numpy_logoUn amico prof al Poli, qualche anno più di me, me l’aveva consigliato caldamente quando stavo per partire con la telenovela Octave mi aveva kwasy sgridato: “vai su MatPlotLib!”. Per fortuna che gli esami al Poli li avevo finiti, da tempo 😀
E ora — forse — chissà — probabilmente…

Devo scegliere un testo da seguire, ci sono diversi candidati:

Rougier da per scontato cose; non riesco a far girare gli esempi che ho provato perché mancano moduli e non ho capito quali. Per esempio che differenza c’è tra i vari timeit? Peccato perché sembra bello. Uh! timeit è in tkinter, scoperto leggendo Jake.
Ha una ricca bibliografia, articoli e libri (per lo più non online).

Jake –lo seguo da sempre sui social– sembra ottimo.
Di Jake c’è anche A Whirlwind Tour of Python, da considerare.

Aaron Meurer e Ondřej Čertík (anche lui presente nel paper) sono i principali artefici di Sympy.

Allora, dopo una scorsa, provando a campione alcuni script mi sembra che sia possibile partire seguendo Jake Vanderplas. Sarà una serie di post quasi solo per me, per vedere come fanno i nerds (über) per cercare di superare il mio stato di aspirante n00b 😉
Non è detto che finisca ma ci provo. mettendocela tutta 😀
Intanto sto facendo altro, completamente differente. Ma questo non lo racconto (per adesso) 😉

:mrgreen:

SICP in Python

nikon-small-world-glycerin-based-soapy-solution
Cosa non si trova ontehtoobz!
Recentemente José Alonso posta questo cinguettio: SICP (Structure and Interpretation of Computer Programs) in Python.
Non è una novità assoluta, l’ho anche inserito nella pagina dei manuali di OKp: Composing Programs.
Ma siccome SICP è uno dei miei tormentoni preferiti oggi guardo e riferisco. Viene da uno corso (uno di quelli iniziali) per gli informatti, giù a Berkeley. Seguendo i link si trovano cose interessanti, p.es.:

This semester, 61A will be taught using the Python 3 programming language. Python is a popular language in both industry and academia. It is also particularly well-suited to the task of exploring the topics taught in this course. It is an open-source language developed by a large volunteer community that prides itself on the diversity of its contributors.

In previous semesters, this course was taught using the Scheme language, a dialect of Lisp, which itself dates back to 1958, making it the second-oldest “higher-level” programming language that is still in use (after Fortran). Lisp and Python are similar in many ways. In fact, Lisp popularized many of the features that make Python a great language. Python has excellent library support for a vast range of application areas. Knowing Python will help you pursue your future programming interests, wherever they may lead you.

E anche

Learning Cooperatively
With the obvious exception of exams, we encourage you to discuss all of the course activities with your friends and classmates as you are working on them. You will definitely learn more in this class if you work with others than if you do not. Ask questions, answer questions, and share ideas liberally.

Since you’re working collaboratively, keep your project partner and TA informed. Questa è scontata ma forse –OK, perso[nale], non leggete il mio commento.

Cooperation has a limit, however, and in 61A that limit is code. Homework problems should be completed and turned in individually. Feel free to discuss the problems with others beforehand; just submit your own work in the end. Parole sante! valgono anche per me quando affronto gli esercizi di SICP.

Copying all or part of another person’s work [… is a form] of cheating and will not be tolerated.

Rather than copying someone else’s work, ask for help. You are not alone […]!

Peccato non essere un giovane pischello californiano! 😦

OK, ma il manuale?
Non l’ho esaminato in dettaglio; non ho fatto gli esempi proposti (anche perché mi sembrano chiari e non sono difficili, almeno all’inizio).
Per non auto-spoilerarmi (ahemmm… a volte seguo la moda della post-truth) non sono andato oltre al cap. 1. Nel PDF c’è qualche codice HTML che è rimasto invece di essere interpretato, ma sono pochissimi e facili da sgamare.
Segue abbastanza fedelmente l’originale in Scheme, in qualche punto è aggiornato; in qualche punto Python impone di scostarsi, comunque è fatto bene.

Forse per quanto detto nell’intro al corso (e da me riportato sopra) mancano gli esercizi che il SICP originale propone.

Mi sembra usabile per imparare sia la programmazione (un po’, mica tutto) sia Python (un po’, mica tutto). E gli esercizi mancanti andate a recuperarli di là e fateli. Io invece continuo per la vecchia via, sono vecchio e abitudinario.

Anche se c’è sempre il solito rischio.

:mrgreen:

Traduzioni da un linguaggio a un altro – 2

system76

Il titolo è fuorviante ma è quello per via che sto continuando a qui.
Ho semplificato troppo parlando del passaggio dei parametri a funzione; dando la colpa al Fortran che passa tutto per indirizzo ho messo su questo esempio:

*     main
      n = 5
      call foo(n, nq)
      print *, n, nq
      call foo(n, nq)
      print *, n, nq
      call foo(n, nq)
      print *, n, nq
      end
      
      subroutine foo(k, l)
      k = k + 1
      l = k ** 2
      end

pass

che con Python può diventare

def foo(k):
      k = k + 1
      l = k ** 2
      return l

#  main
n = 5
nq = foo(n)
n += 1
print(n, nq)
n += 1
nq = foo(n)
print(n, nq)
n += 1
nq = foo(n)
print(n, nq)

py-pass2

Però non è sempre così semplice! 😦 Sono stato richiamato, redarguito e allora tento di rimediare.
Inoltre il caso è più generale, non riguarda solo le traduzioni tra linguaggi.

Invece di rifare l’esempio precedente eccone uno nuovo. Secondo me l’esempio dev’essere il più piccolo possibile, eliminare tutto quanto non strettamente necessario; ovvio che poi risulti banale.
Ne approfitto per trattare anche il caso degli arrays; in realtà con Python forse sono meglio le liste. Questione che meriterebbe più attenzione, p.es. ecco i primi due risultati alla query a Stack OverFlow: uno e due.

Supponiamo di avere una serie di dati di temperature relative al processo [fate voi, non sono tanto bravo a inventare]. Purtroppo la macchina è ‘mericana e usa i gradi fahrenheit, quelli che usano solo loro (e, purtroppo, usano solo quelli). Devo inoltre calcolare il valore medio (e in un caso più realistico scarto quadratico e altri valori ancora, l’esempio dev’essere semplice). Ecco come –secondo me– si può fare in modo semplice.

def conv(f):
    return round((f - 32) * 5 / 9, 1)

def celsius(a):
    n = 0
    for c in a:
        a[n] = conv(c)
        n += 1
    media = round(sum(a) / len(a), 1)
    #print(a)
    #print(media)
    r = [a, media]
    return r

#main
t = [120, 110, 112, 125, 113, 117, 109, 121]
retval = celsius(t)
#print(retval)
tc = retval[0]
media = retval[1]
print("temperature:", tc)
print("media: ", media)

f2c

Ho lasciato commentate le print() provvisorie, di debug.

Ma un pythonista serio non scriverebbe mai codice come quello 😦 c’è la list comprehension, più chiara, compatta ed efficiente, ecco la nuova versione (il nuovo è indicato con il commento # ****):

def conv(f):
    return round((f - 32) * 5 / 9, 1)

def celsius(a):
    a = [conv(n) for n in a]           # ***
    media = round(sum(a) / len(a), 1)
    #print(a)
    #print(media)
    r = [a, media]
    return r

#main
t = [120, 110, 112, 125, 113, 117, 109, 121]
retval = celsius(t)
#print(retval)
tc = retval[0]
media = retval[1]
print("temperature:", tc)
print("media: ", media)

:mrgreen:

Traduzioni da un linguaggio a un altro

btf3

Un discorso che devo prendere un po’ alla lunga, da lontano, roba di prima di voi giovani, ma poi arrivo al dunque, cioè all’oggi, promesso.

In Fortran π, pi, il rapporto tra le misure della circonferenza e il raggio non è definito. Ma tutti sanno che l’arcotangente di 1 rad vale π/4.
E allora diventa tutto semplice, gli antichi (non gli antichissimi ma non cambia molto) usavano il Fortran 77 (1978).
Vediamo se ricordo bene perché possono esserci diversi modi di scrivere, tenendo presente che i tipi sono impliciti e allora

      pi1 = 4.0 * atan(1.0)
      pi2 = 4.0 * atan(1)
      pi3 = 4 * atan(1.0)
      pi4 = 4.0 * datan(1.0)
      
      print *, pi1, pi2, pi3, pi4
      end

ap0

Partito molto male: 2 errori –no uno solo in 2 varietà– correggo.

La riga pi2 = 4.0 * atan(1) è irrecuperabile, a correggerla diventa uguale alla precedente.
La riga pi4 = 4.0 * datan(1.0) è più intrigante. Intanto la D iniziale sta per double precision, quello che in C si chiama double.

      pi1 = 4.0 * atan(1.0)
      pi3 = 4 * atan(1.0)
      pi4 = 4.0 * datan(1.d0)
      pi5 = 4.0d0 * datan(1.d0)
      pi6 = 4.0d0 * datan(dble(1.0))
      
      print "(f12.10)" , pi1, pi3, pi4, pi5, pi6
      end

ap1

OK, ottengo gli stessi valori. Notare la promozione a double nella moltiplicazione per il calcolo di pi4. Notare anche la funzione dble, cast a double direbbe il C-ista.

Ma non va come previsto: otteniamo sempre lo stesso numero di cifre corrette, sia usando i real*4 che i real*8 corrispondenti a float e double del C.
Devo dichiarare il tipo quando non rientra in quelli di default. Infatti questo viene automaticamente assegnato a integer (2 bytes nel Fortran IV, 4 nel 77) se la prima lettera della variabile è nell’intervallo [I-N], real*4 per tutte le altre. Si ricorda inoltre che al di fuori delle stringhe quotate si ha una conversione automatica al maiuscolo.
Ecco:

      double precision pi4
      real * 8 pi6

      pi1 = 4.0 * atan(1.0)
      pi3 = 4 * atan(1.0)
      pi4 = 4.0 * datan(1.d0)
      pi5 = 4.0d0 * datan(1.d0)
      pi6 = 4.0d0 * datan(dble(1.0))
      
      print "(f12.10)", pi1, pi3, pi4, pi5, pi6
      end

ap2

OK 😀 Ah! dimenticavo: gli spazi non sono significativi, real*8 e real * 8 sono sinonimi, lo sarebbe pure r e a l * 8.

Lo so che nessuno usa più il Fortran, neanch’io, ma devo raccontare questo altrimenti poi non si capisce.

Neanche e, quella di Euler, dei logaritmi naturali, è predefinita. Ma facciamo come per π:

      real * 8 e2

      e1 = exp(1.0)
      e2 = dexp(1.d0)      

      print "(f12.10)", e1, e2
      end

ae

OK 😀 notare che al posto di 1.0 posso scrivere 1. come posso scrivere .1 per 0.1; i vecchi lo facevano sempre.

Finora niente di sconvolgente ma ecco un passo ancora

      e = exp(1.0)
      pi = 4.0 * atan(1.0)
      ie2 = 2 * e
      ipi2 = 2 * pi
        
      print *, e, pi
      print *, ie2, ipi2
      end

app

OK, i cast a integer*4 tronca i real*4. Ma attenzione, questo avviene –ovviamente– dopo la moltiplicazione. Ovviamente è diverso da questo caso:

      e = exp(1.0)
      pi = 4.0 * atan(1.0)
      ie = e
      ipi = pi
      ie2 = 2 * ie
      ipi2 = 2 * ipi
        
      print *, e, pi
      print *, ie2, ipi2
      end

iapp

Se si vuole l’arrotondamento all’intero più vicino ci sono due modi:

      e = exp(1.0)
      ie1 = e + 0.5
      ie2 = int(e + 0.5)
      ie3 = nint(e)

      print *, ie1, ie2, ie3
      end

round

Siccome la conversione da real a integer avviene automaticamente per troncamento i vecchi usavano sommare 1/2 al valore da convertire. La funzione int() in questo caso è implicita per ie1 e esplicita per ie2. Esiste la funzione di arrotondamento nint() ma è usata raramente (mai).

Finora ho barato; no, non barato ma omesso di dire tutta la verità. Alcune funzioni intrinseche del Fortran sono da sempre (OK, quasi) polimorfe.
Già vista datan() ma risulta più chiaro con la funzione max():

      m1 = max(3, 1, 4, 1, 5)
      m2 = max0(3, 1, 4, 1, 5)
      m3 = max1(3.0, 1.0, 4.0, 1.0, 5.0)
      rm2 = amax0(3, 1, 4, 1, 5)
      rm3 = amax1(3.0, 1.0, 4.0, 1.0, 5.0)
      print *, m1, m2, m3
      print *, rm2, rm3
      end

fsp

Sì, conta la lettera iniziale (A per i real, D per i double) e l’eventuale numero finale (0 per integer, 1 per real). Come se non fosse abbastanza ci sono state variazioni (tante) tra le versioni 77 e 90 (e successive), RTFM (cit.).

Ci sarebbe da raccontare molto su common ma salto.
Come pure salto tutto il capitolo sulle matrici, c’è Octave visto recentemente.

Invece una cosa sempre in agguato: il passaggio di variabili ai sottoprogrammi. In Fortran ci sono le function, funzioni come quelle di C e Python e quasi tutti i linguaggi. Ma ci sono anche le subroutines –anzi sono nate prima– sottoprogrammi chiamate con la keyword call che non ritornano un valore come le funzioni ma modificano i dati passati. Tutti, perché vengono passati per indirizzo (questo è vero solo per le versioni non nuovissime ma il codice è spesso piuttosto attempato). Un esempio minimo:

*     main
      n = 5
      call foo(n, nq)
      print *, n, nq
      call foo(n, nq)
      print *, n, nq
      call foo(n, nq)
      print *, n, nq
      end
      
      subroutine foo(k, l)
      k = k + 1
      l = k ** 2
      end

pass

Sembra facile, traduco in Python:

### versione iniziale, non funziona

def foo(k, l):
      k = k + 1
      l = k ** 2

#  main
n = 5
foo(n, nq)
print(n, nq)
foo(n, nq)
print(n, nq)
foo(n, nq)
print(n, nq)

py-pass

Ehmmm… no; non basta aggiustare la sintassi delle singole righe. Il valore di l | nq dev’essere ritornato espressamente. Inoltre è inutile passarlo tra gli argomenti:

### ancora non funziona

def foo(k):
      k = k + 1
      l = k ** 2
      return l

#  main
n = 5
nq = foo(n)
print(n, nq)
nq = foo(n)
print(n, nq)
nq = foo(n)
print(n, nq)

py-pass1

No! non ci sono ancora: ovvio, gli passo sempre lo stesso parametro n = 5; la modifica all’interno di foo() è locale e in main non viene vista, correggo:

def foo(k):
      k = k + 1
      l = k ** 2
      return l

#  main
n = 5
nq = foo(n)
n += 1
print(n, nq)
n += 1
nq = foo(n)
print(n, nq)
n += 1
nq = foo(n)
print(n, nq)

py-pass2

OK! ma il codice è orrendo! Non voglio vedere niente di simile 😦

Come visto anche per un caso molto banale la traduzione automatica, riga per riga non è possibile. Ci sarebbe da dare la colpa al fortrainer che se avesse fatto le cose per bene… scrivendo la subroutine foo() così:

      subroutine foo(k, l)
      j = k + 1
      l = j ** 2
      end

la variabile k sarebbe stata solo di input –o anche intent(in) per le versioni nuove del Fortran– non sarebbe ritornata modificata e il main avrebbe dovuto essere scritto meglio.

Adesso provate –Gedankenexperiment– ad applicare questo a codice reale 👿 Ma secondo me va fatto. Prima o poi. Non necessariamente da me.
:mrgreen:

Valutare XKCD con Windows? Si può fare!

nm0

Nel post precedente si valutava l’ipotesi che XKCD sia collegato a La Risposta, come –forse– un giorno grazie all’AI si riuscirà finalmente a provare, trovando –finalmente– La Domanda.
Nel post precedente (devo ricordarmi di non cominciare una frase nello stesso modo della precedente) eravamo in un ambiente adatto con tutti i tools che possono tornare utili disponibili e pronti fin da subito, anzi da prima (quando ero ggiovane ricordo che un giorno è arrivato UNIX (allora si scriveva così, tutto maiuscolo e bisognava dire che UNIX is a trademark of Bell Laboratories, Inc.)) ma come e cosa si può fare in ambienti meno friendly amichevoli. O –a volte– decisamente ostili, per esempio quello con la finestra storta, com’è già che si chiama?

Anche per loro ci sono strumenti [1] grazie a FOSS, come vedremo.
Oggi useremo Python, 3.x, costruendo il comando passo-passo.

x6

Fin qui niente di speciale, è una stringa. Per il nostro scopo possiamo usare list():

x7

Dalla lista c possiamo passare a quella dei valori ASCII (o Unicode, in questo caso coincidono) v.

x8

Lo so che non si devono fare cicli in questo modo [2] ma è provvisorio, solo per la costruzione.
Usiamo la funzione ord().
Abbiamo così la lista dei valori; troppo grossi però. Dovrebbe valere 1 per A, 2 per B e così via.
Beh, facile basta applicare un offset, questo:

x9

e riscrivere il loop precedente così:

x10

Non ci resta che fare la somma, via sum():

x11

OK! Adesso l’unione degli snippets [3] precedenti ed ecco:

x12

Resta un ultimo step: [4]

x13

Fatto! In fondo era semplice [5] 😀


[1] Mi dice Sole (sì, è tornata) che non devo usare “tools”; e non fare i prulari.
[2] prima vennero per il GOTO ma non era per me, poi vennero per… (quasi-cit.).
[3] frammenti, mi dicono.
[4] passo. (Devo smetterla che si sta –come dire– potrebbe diventare pericoloso per me e per il ‘puter).
[5]
mom:mrgreen: