Imparare Python da Ruby; Differenze e somiglianze

Conosco molto bene Ruby. Credo che potrei aver bisogno di imparare Python al momento. Per coloro che conoscono entrambi, quali concetti sono simili tra i due e quali sono diversi?

Sto cercando un elenco simile a un primer che ho scritto per Learning Lua per JavaScripters : cose semplici come il significato degli spazi bianchi e costrutti in loop; il nome di nilin Python e quali valori sono considerati "veritieri"; è idiomatico usare l'equivalente di mape each, o sono mumble qualcosa che le comprensioni dell'elenco mummano la norma?

Se ricevo una buona varietà di risposte, sono felice di aggregarle in un wiki della community. Oppure tutti voi potete combattere e crogiolarvi l'un l'altro per cercare di creare un vero elenco completo.

Modifica : Per essere chiari, il mio obiettivo è "vero" e idiomatico Python. Se esiste un equivalente di Python inject, ma nessuno lo usa perché esiste un modo migliore / diverso per ottenere la funzionalità comune di iterare un elenco e accumulare un risultato lungo la strada, voglio sapere come fai le cose. Forse aggiornerò questa domanda con un elenco di obiettivi comuni, come li raggiungi in Ruby e chiederò quale sia l'equivalente in Python.

Ecco alcune differenze chiave per me:

1. Ruby ha i blocchi; Python no.

2. Python ha funzioni; Ruby no. In Python, puoi prendere qualsiasi funzione o metodo e passarlo a un'altra funzione. In Ruby, tutto è un metodo e i metodi non possono essere passati direttamente. Invece, devi avvolgerli in Proc per passarli.

3. Ruby e Python supportano entrambe le chiusure, ma in diversi modi. In Python, puoi definire una funzione all'interno di un'altra funzione. La funzione interna ha accesso in lettura alle variabili dalla funzione esterna, ma non accesso in scrittura. In Ruby, definisci le chiusure usando i blocchi. Le chiusure hanno pieno accesso in lettura e scrittura alle variabili dall'ambito esterno.

4. Python ha una comprensione delle liste, che sono piuttosto espressive. Ad esempio, se si dispone di un elenco di numeri, è possibile scrivere

   [x*x for x in values if x > 15]

   per ottenere un nuovo elenco dei quadrati di tutti i valori maggiori di 15. In Ruby, dovresti scrivere quanto segue:

   values.select {|v| v > 15}.map {|v| v * v}

   Il codice Ruby non sembra compatto. Inoltre, non è altrettanto efficiente poiché converte prima l'array di valori in un array intermedio più corto contenente i valori maggiori di 15. Quindi, prende l'array intermedio e genera un array finale contenente i quadrati degli intermedi. L'array intermedio viene quindi eliminato. Quindi, Ruby finisce con 3 array in memoria durante il calcolo; Python necessita solo dell'elenco di input e dell'elenco risultante.

   Python fornisce anche una comprensione simile della mappa.

5. Python supporta le tuple; Ruby no. In Ruby, devi usare le matrici per simulare le tuple.

6. Ruby supporta le istruzioni switch / case; Python no.

7. Ruby supporta l' expr ? val1 : val2operatore ternario standard ; Python no.

8. Ruby supporta solo una singola eredità. Se è necessario imitare l'ereditarietà multipla, è possibile definire i moduli e utilizzare i mix-in per inserire i metodi del modulo in classi. Python supporta l'ereditarietà multipla anziché i mix-in dei moduli.

9. Python supporta solo funzioni lambda a linea singola. I blocchi ruby, che sono una sorta di / sorta di funzioni lambda, possono essere arbitrariamente grandi. Per questo motivo, il codice Ruby è in genere scritto in uno stile più funzionale rispetto al codice Python. Ad esempio, per scorrere su un elenco in Ruby, in genere lo fai

   collection.each do |value|
     ...
   end

   Il blocco funziona in modo molto simile a una funzione passata a collection.each. Se dovessi fare la stessa cosa in Python, dovresti definire una funzione interna denominata e poi passarla alla raccolta ogni metodo (se l'elenco supporta questo metodo):

   def some_operation(value):
     ...
   
   collection.each(some_operation)

   Non scorre molto bene. Quindi, in genere in Python verrebbe utilizzato il seguente approccio non funzionale:

   for value in collection:
     ...

10. L'uso delle risorse in modo sicuro è abbastanza diverso tra le due lingue. Qui, il problema è che si desidera allocare alcune risorse (aprire un file, ottenere un cursore di database, ecc.), Eseguire alcune operazioni arbitrarie su di esso e quindi chiuderlo in modo sicuro anche se si verifica un'eccezione.

    In Ruby, poiché i blocchi sono così facili da usare (vedi # 9), in genere codifichi questo modello come un metodo che accetta un blocco per eseguire l'operazione arbitraria sulla risorsa.

    In Python, passare una funzione per l'azione arbitraria è un po 'più clunkier poiché devi scrivere una funzione interna denominata (vedi # 9). Invece, Python utilizza withun'istruzione per la gestione sicura delle risorse. Vedi Come posso pulire correttamente un oggetto Python? per ulteriori dettagli.

Ho appena trascorso un paio di mesi ad imparare Python dopo 6 anni di Ruby. Non c'è stato davvero un grande confronto là fuori per le due lingue, quindi ho deciso di inventarmi e scriverne uno io. Ora, si occupa principalmente di programmazione funzionale, ma dal momento che menzioni il injectmetodo di Ruby , immagino che siamo sulla stessa lunghezza d'onda.

Spero che questo aiuti: la "bruttezza" di Python

Un paio di punti che ti faranno muovere nella giusta direzione:

• Tutta la bontà della programmazione funzionale che usi in Ruby è in Python ed è ancora più semplice. Ad esempio, puoi mappare le funzioni esattamente come ti aspetteresti:

  def f(x):
      return x + 1
  
  map(f, [1, 2, 3]) # => [2, 3, 4]

• Python non ha un metodo che si comporta come each. Dato che usi solo eachper gli effetti collaterali, l'equivalente in Python è il ciclo for:

  for n in [1, 2, 3]:
      print n

• La comprensione dell'elenco è ottima quando a) devi gestire insieme funzioni e raccolte di oggetti eb) quando devi iterare usando più indici. Ad esempio, per trovare tutti i palindromi in una stringa (supponendo che tu abbia una funzione p()che ritorna vera per i palindromi), tutto ciò di cui hai bisogno è una singola lista di comprensione:

  s = 'string-with-palindromes-like-abbalabba'
  l = len(s)
  [s[x:y] for x in range(l) for y in range(x,l+1) if p(s[x:y])]

Il mio consiglio: non cercare di imparare le differenze. Scopri come affrontare il problema in Python. Proprio come c'è un approccio Ruby per ogni problema (che funziona molto bene dando i limiti e i punti di forza del linguaggio), c'è un approccio Python al problema. sono entrambi diversi. Per ottenere il meglio da ogni lingua, dovresti davvero imparare la lingua stessa e non solo la "traduzione" dall'una all'altra.

Ora, detto questo, la differenza ti aiuterà ad adattarti più velocemente e apportare 1 modifica a un programma Python. E va bene per cominciare a scrivere. Ma prova ad imparare da altri progetti il ​​perché dietro le decisioni di architettura e design piuttosto che il come dietro la semantica del linguaggio ...

Conosco il piccolo Ruby, ma qui ci sono alcuni punti elenco sulle cose che hai menzionato:

• nil, il valore che indica la mancanza di un valore sarebbe None(nota che lo controlli come x is Noneo x is not None, non con ==- o dalla coercizione a booleana, vedi il punto successivo).
• None, Numeri zero esque ( 0, 0.0, 0j(numero complesso)) e raccolte vuoti ( [], {}, set(), la stringa vuota "", ecc) sono considerati falsy, tutto il resto è considerato truthy.
• Per gli effetti collaterali, il forciclo ( -) esplicitamente. Per generare un nuovo gruppo di cose senza effetti collaterali, usa la comprensione delle liste (o i loro parenti - espressioni generatrici per gli iteratori pigri di una volta, comprendi le dettature / imposta per le suddette raccolte).

Per quanto riguarda il looping: sì for, che opera in modo iterabile (! Senza contare) e whileche fa ciò che ti aspetteresti. Il fromer è molto più potente, grazie al vasto supporto per gli iteratori. Non solo quasi tutto ciò che può essere un iteratore invece di un elenco è un iteratore (almeno in Python 3 - in Python 2, hai entrambi e il default è un elenco, purtroppo). Sono numerosi gli strumenti per lavorare con gli iteratori: zipitera in parallelo un numero qualsiasi di iterabili, enumerateti dà (index, item)(su qualsiasi iterabile, non solo su elenchi), anche tagliando iterabili abrasivi (possibilmente grandi o infiniti)! Ho scoperto che questi rendono molte più attività di looping molto più semplici. Inutile dire che si integrano perfettamente con la comprensione dell'elenco, le espressioni del generatore, ecc.

In Ruby, le variabili e i metodi di istanza sono completamente indipendenti, tranne quando li si collega esplicitamente con attr_accessor o qualcosa del genere.

In Python, i metodi sono solo una classe speciale di attributo: uno che è eseguibile.

Quindi per esempio:

>>> class foo:
...     x = 5
...     def y(): pass
... 
>>> f = foo()
>>> type(f.x)
<type 'int'>
>>> type(f.y)
<type 'instancemethod'>

Questa differenza ha molte implicazioni, come ad esempio il fatto che fare riferimento a FX si riferisce all'oggetto metodo, piuttosto che chiamarlo. Inoltre, come puoi vedere, fx è pubblico per impostazione predefinita, mentre in Ruby, le variabili di istanza sono private per impostazione predefinita.