Lopullinen hajoaminen: Ruby vs. Python

Samankaltaisuudet

Koska nämä kielet voidaan sisällyttää samaan dynaamisesti tyypitettyjen tulkattujen kielten luokkaan, ei ole epäilystäkään siitä, että ne ovat samankaltaisia.

Dynaaminen kirjoittaminen

Molemmat Python ja Ruby ovat dynaamisesti tyypitettyjä kieliä. Tämän seurauksena ohjelmoijan ei tarvitse määritellä muuttujien tyyppiä kirjoittaessaan koodi. Niiden tyyppi määritetään ohjelman ollessa käynnissä, ja se voi muuttua. Muuttujan tyyppi saadaan siihen tallennetusta arvosta. Seuraava koodi toimii oikein näillä kielillä:

 muuttuja = 1
 muuttuja += 2.5
 muuttuja = 'sample string'
 muuttuja = [2, 3.5, 'sample string']

Puhdas syntaksi

Tämä liittyy muun muassa edellä mainittuun kohtaan. Koska tyyppejä ei tarvitse ilmoittaa, lauseita ei tarvitse päättää puolipisteeseen ja koska ne ovat skriptikieliä, sekä kirjoittaminen että lukeminen on helppoa. Hyvin kirjoitettu koodi on luettavissa myös sellaisille ihmisille, jotka eivät ole aiemmin olleet tekemisissä näiden kielten kanssa.

Niillä on interaktiiviset konsolitulkit

Kun haluat suorittaa yksinkertaisen toiminnon tai testata koodia, sinun ei tarvitse luoda tiedostoa ja suorittaa koodia erityisellä komennolla. Sekä Rubyssä että Python:ssä on interaktiiviset konsolitulkit (REPL). Python:ssä voimme ajaa tällaisen tulkin komennolla python (taipython3), kun taas Rubyn tapauksessa se voisi olla esimerkiksi, irb:

 $ irb
 2.5.8 :001 > tulos = 2 + 1
 => 3
 2.5.8 :002 > tulos += 3.5
 => 6.5

Erot

Koska nämä ovat erilaisia ohjelmointikielet, tietysti heillä on oltava eroja (tiedän, mikä paljastava lausunto). Python:n ja Rubyn tapauksessa nämä erot ovat lukuisia. Kuvailen joitakin mielestäni merkittävimpiä niistä.

Syvennykset

Syvennys on erittäin tärkeä Python:ssä. Kaikki koodilohkot määritellään sisennyksillä. On tärkeää, että tietyn lohkon jokaisella rivillä on sama sisennys. Muuten koodia yritettäessä saadaan IndentationError. Ruby käyttää erilaista lähestymistapaa. Siinä koodilohko rajataan avainsanoilla. Erottelemme alkusanan (esim.begin, if, class, def) ja loppusana loppu. Sillä ei ole merkitystä, miten koodi on sisennetty koodilohkon sisällä.

Perinnöllisyys

Yksi oliopohjaisen ohjelmoinnin perusominaisuuksista. Oikeissa käsissä se voi tehdä ihmeitä. Python tukee monipohjaista periytymistä:

 example.py
 class ClassA:
     def callA(self):
         ): print('callA')
 class ClassB:
     def callB(self):
         print('callB')
 class ClassAB(ClassA, ClassB):
     pass
 class_inst = ClassAB()
 class_inst.callA()
 class_inst.callB()

Tämän seurauksena saadaan:

 $ python3 example.py
 callA
 callB

Ruby tukee oletusarvoisesti vain yhden perustan periytymistä <-operaattorin avulla. On kuitenkin mahdollista simuloida monipohjaista periytymistä moduuleja käyttämällä:

example.rb
luokka ClassA
def calla
puts 'calla'
end
end

moduuli ModuleB
def callb
puts 'callb'
end
end

class ClassAB < ClassA
include ModuleB
end

classinst = ClassAB.new
classinst.calla
classinst.call_b

Mikä antaa meille:

 $ ruby example.rb
 call_a
 call_b

sisällyttää on vain yksi Rubyn käytettävissä olevista mixineistä. Mixins on tapa lisätä luokkiin lisätoimintoja. Rubyssa on kolme mixiniä.

Sisällytä

Kun soitamme sisällyttää luokan määrittelyssä, sisällytetystä moduulista tulee tämän luokan suora esi-isä. Se tarkoittaa, että moduulin jokaisesta metodista tulee tämän luokan instanssimetodi. Voimme korvata ne luokassa ja kutsua myös alkuperäistä (moduulissa määriteltyä) metodia käyttämällä komentoa super avainsana.

example.rb
moduuli ModuleA
def print_something
puts 'Viesti moduulilta'
end
end

luokka ClassB
include ModuleA

def print_something
puts 'Viesti luokalta'
super
end
end

ClassB.new.print_something

Tulos:

 $ ruby example.rb
 Luokan viesti
 Viesti moduulilta
 

Prepend

Se toimii melkein kuin sisällyttää, mutta edeltävästä moduulista tulee luokan suora jälkeläinen. Se tarkoittaa, että emme voi ohittaa moduulin metodia luokassa, mutta moduulin metodi voi kutsua luokan metodia käyttämällä komentoasuper avainsana.

example.rb
moduuli ModuleA
def print_something
puts 'Viesti moduulilta'
super
end
end

luokka ClassB
prepend ModuleA

def print_something
puts 'Viesti luokalta'
end
end

ClassB.new.print_something 

Tulos:

 $ ruby example.rb
 Moduulin viesti
 Viesti luokasta

Laajenna

Se toimii samalla tavalla kuin include, paitsi että moduulissa määritellyistä metodeista tulee luokan metodeja.

Tulos:

 $ ruby example.rb Moduulin viesti

Toiminnot ja lohkot

Python:ssä on toimintoja. Ruby tukee vain metodeja. Mitä siitä seuraa? Python voi muun muassa pitää funktiota muuttujassa ja siirtää sen argumenttina toiselle funktiolle. Rubyssä emme voi tehdä sitä yhtä helposti. Tähän liittyvät myös sulkeet. Jos annat funktion, jolla ei ole argumentteja Python:ssä tai jolla on oletusargumentit, jos käytät sen nimeä ilman sulkuja, funktio palautetaan. Vasta sulkujen lisääminen johtaa sen suorittamiseen. Rubyssä voimme kutsua funktioita ilman sulkuja:

example.py
def inner_function():
): print('Inner function')

def wrapper_function(function):
print('Wrapper function')
# function on muuttuja, joka sisältää funktion objektin
function() # sisäistä funktiota kutsutaan tässä.

wrapperfunction(innerfunction)

Tulos:

 $ python3 example.py
 Käärefunktio
 Sisäinen funktio

Rubyssä:

example.rb
def sisäinen_funktio
puts 'Sisäinen funktio'
end

def wrapper_function(function)
puts 'Wrapper function'
function
end

wrapperfunction(innerfunction) # inner_function kutsutaan tässä.

Tulos:

 $ ruby example.rb
 Sisäinen funktio
 Käärefunktio

Tässä tapauksessa voit tietysti tehdä joitakin temppuja Rubyssä halutun vaikutuksen saavuttamiseksi. Ensinnäkin voimme käyttää Proc-objektia:

example.rb
def sisäinen_funktio
puts 'Sisäinen funktio'
end

def wrapper_function(function)
puts 'Wrapper function'
function.call
end

func = Proc.new { innerfunction }
wrapperfunction(func)

Tulos:

 $ ruby example.rb
 Wrapper-funktio
 Sisäinen funktio

Toinen lähestymistapa on käyttää lohkoja:

example.rbdef inner_function
puts 'Sisäinen funktio'
end

def wrapper_function
puts 'Käärefunktio'
yield
end

wrapperfunction do
innerfunction
end

Tulos:

 $ ruby example.rb
 Wrapper-funktio
 Sisäinen funktio

Luettelon ymmärtäminen

Tämä on erittäin hyödyllinen Python:n ominaisuus. Se koostuu luettelon luomisesta toisen luettelon pohjalta. Oletetaan, että meillä on tällainen tehtävä: kun meillä on lista numeroita, tee lista parittomien numeroiden neliöistä. Python:ssä käytämme listan ymmärtämistä:

 numbers = [1, 3, 4, 7, 8, 12, 15]
 tulos = [num*num for num in numbers if num % 2]

Etuna on, että meillä on muistissa vain kaksi luetteloa.

Rubyssä asiat ovat hieman toisin. On olemassa useita tapoja ratkaista tämä tehtävä. Esittelen niistä luettavimman:

 numbers = [1, 3, 4, 7, 8, 12, 15]
 result = []
 numbers.each { |num| result << num * num if num.odd? }

example.rb
luokka String
def atob!
self.gsub!(/a/, 'b')
end
end

string = 'Esimerkki merkkijono, jossa on monta a-kirjainta'
puts string
string.atob!
puts string

 $ ruby example.rb
 Esimerkki merkkijono, jossa on monta a-kirjainta
 Esimerkki merkkijono, jossa on mbny b-kirjaimia