Dichiarazione "con as" di Python in Julia, JavaScript, Lua e altri linguaggi

Una delle sfide per me nell'afferrare la with asfunzionalità in Python, la sua necessità non è evidente a meno che tu non abbia una comprensione più profonda dei limiti del linguaggio Python.

Ad esempio, uno sviluppatore Ruby, Julia, Lua, Go, JavaScript o Swift non avrebbe bisogno di aggiungere questa affermazione. Perché?

Al centro del problema c'è una caratteristica apprezzata da molti sviluppatori Python: l'uso dell'indentazione per indicare i blocchi di codice.

In JavaScript potrei scrivere ad es

openfile('foobar.txt', function(file) {
  // called after file has been opened
  // file is a handle to the open file
  read_data(file)
  ...
});

openfile("foobar.txt", function(file)
  -- called after file has been opened
  -- file is a handle to the open file
  read_data(file)
  ...
end)

openfile("foobar.txt", def (file):
  # called after file has been opened
  # file is a handle to the open file
  read_data(file)
  ...

Illustra il vantaggio di avere un simbolo per segnalare la fine di un blocco di codice piuttosto che un cambiamento nel rientro.

Utilizzo di funzioni di ordine superiore con chiusure per l'allocazione e la pulizia delle risorse

Entriamo un po' nei dettagli dei vantaggi di avere una sintassi amichevole per le chiusure multilinea in linea. Illustrerò con un esempio di codice Julia, anche se JavaScript, Lua e molti altri linguaggi funzionerebbero altrettanto bene.

function openfile(callback, filename::String)
		file = open(filename)
    callback(file)
    close(file)
end

openfile(file -> print(readline(file)), "foobar.txt")

openfile("foobar.txt") do file
		print(readline(file))
end

Il bello di questo modo di aprire e chiudere i file è che non ti dimenticherai di chiudere il file.

La soluzione Python

Come spiegato, è difficile ottenere lo stesso risultato in Python nella sua sintassi. Così with-asè stato inventato. Lascia che ti mostri come l'esempio precedente verrebbe implementato in Python.

class openfile:
   def __init_(self, filename):
       self.filename
   def __enter__(self):
       self.file =  open(self.filename)
       return file
   def __exit__(self, exc_type, exc_val, exc_tb):
       close(self.file)

Possiamo usare questa classe per aprire e leggere da un file in questo modo:

with openfile("foobar.txt") as file:
  print(readline(file))

1. Per prima cosa viene chiamato il costruttore della openfileclasse e memorizziamo il nome del file che vogliamo aprire.
2. Un'istanza della openfileclasse viene passata al with-ascostrutto, che fa sì che il suo __enter__metodo venga chiamato. Dovrebbe acquisire le nostre risorse desiderate. Un handle di file in questo caso.
3. L'oggetto restituito diventa l'argomento di as. Quindi as filesi riferisce all'oggetto restituito da __enter__. I nomi non devono corrispondere. Avremmo potuto scrivere as foobarinvece.
4. Quando tutto il codice all'interno del with-asblocco è stato eseguito, Python invocherà __exit__per rilasciare le risorse. Questo verrà anche chiamato nel caso in cui vengano generate eccezioni.

Ci sono molte variazioni nel modo in cui è possibile creare queste classi di gestione del contesto , sia tramite sottoclassi che utilizzando decoratori.