De ultieme onderverdeling: Ruby vs. Python

Gelijkenissen

Aangezien deze talen kunnen worden opgenomen in dezelfde categorie van dynamisch getypeerde geïnterpreteerde talen, bestaat er geen twijfel over dat ze vergelijkbaar zijn.

Dynamisch typen

Beide Python en Ruby zijn dynamisch getypeerde talen. Als gevolg hiervan hoeft de programmeur het type van variabelen niet op te geven tijdens het schrijven van de code. Hun type wordt bepaald terwijl het programma draait en kan veranderen. Het type van een variabele wordt afgeleid van de waarde die erin is opgeslagen. De volgende code zal correct werken in deze talen:

 variabele = 1
 variabele += 2.5
 variabele = "voorbeeldtekenreeks
 variabele = [2, 3.5, "voorbeeldtekenreeks"]

Zuivere syntaxis

Dit hangt onder andere samen met het punt hierboven. Omdat het niet nodig is om types te declareren, statements te eindigen met een puntkomma en ook omdat het scripttalen zijn, is zowel het schrijven als het lezen eenvoudig. Goed geschreven code is zelfs leesbaar voor mensen die nog niet eerder met deze talen in aanraking zijn geweest.

Ze hebben interactieve console-interpreters

Als u een eenvoudige bewerking wilt uitvoeren of een stuk code wilt testen, hoeft u geen bestand aan te maken en de code uit te voeren met een speciaal commando. Zowel Ruby als Python hebben interactieve console-interpreters (REPL). Voor Python kunnen we zo'n interpreter uitvoeren met het commando python (ofpython3), terwijl het voor Ruby bijvoorbeeld zou kunnen zijn, irb:

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

Verschillen

Aangezien dit verschillende programmeertalenNatuurlijk moeten ze verschillen hebben (ik weet het, wat een onthullende uitspraak). In het geval van Python en Ruby zijn die verschillen talrijk. Ik zal enkele van de belangrijkste naar mijn mening beschrijven.

Inkepingen

Inspringen is heel belangrijk in Python. Alle codeblokken worden gedefinieerd door inspringing. Het is belangrijk dat elke regel in een blok dezelfde inspringing heeft. Anders krijgen we een IndentationError als we de code proberen uit te voeren. Ruby heeft een andere aanpak. Hier wordt het codeblok beperkt door sleutelwoorden. We maken onderscheid tussen het beginwoord (bijv.begin, als, klasse, def) en het eindwoord einde. Het maakt niet uit hoe de code is ingesprongen binnen het codeblok.

Erfenis

Een van de basisfuncties van objectgeoriënteerd programmeren. In de juiste handen kan het wonderen verrichten. Python ondersteunt multi-base overerving:

 voorbeeld.py
 klasse KlasseA:
     def callA(self):
         print('callA')
 klasse KlasseB:
     def callB(self):
         print('callB')
 Klasse KlasseAB(KlasseA, KlasseB):
     pass
 klasse_inst = KlasseAB()
 klasse_inst.oproepA()
 klasse_inst.oproepB()

Als resultaat krijgen we:

 $ python3 voorbeeld.py
 oproepA
 oproepB

Ruby ondersteunt standaard alleen single-base overerving met de < operator. Het is echter mogelijk om multi-base overerving te simuleren met behulp van modules:

voorbeeld.rb
klasse KlasseA
def calla
puts 'calla'
einde
einde

module moduleB
def callb
puts 'callb'.
einde
einde

Klasse KlasseAB < KlasseA
inclusief moduleB
einde

classinst = ClassAB.new
classinst.calla
klasseinst.oproep_b

Wat geeft ons:

 $ robijn voorbeeld.rb
 oproep_a
 oproep_b

opnemen is slechts een van de mixins die beschikbaar zijn in Ruby. Mixins zijn een manier om extra functionaliteit aan klassen toe te voegen. Er zijn drie mixins in Ruby.

Opnemen

Wanneer we opnemen in de klassedefinitie wordt opgenomen module de directe voorouder van deze klasse. Dit betekent dat elke methode van de module een instantie methode van deze klasse wordt. We kunnen ze overschrijven in de klasse en ook de oorspronkelijke methode (gedefinieerd in de module) aanroepen met behulp van super trefwoord.

voorbeeld.rb
module ModuleA
def print_iets
puts 'Bericht van module'.
einde
einde

KlasseB
inclusief moduleA

def print_iets
puts 'Bericht van klasse'.
super
einde
einde

KlasseB.nieuw.print_iets

Resultaat:

 $ robijn voorbeeld.rb
 Bericht van klasse
 Bericht van module
 

vooraf

Het werkt bijna als opnemenmaar de module die eraan voorafgaat, wordt een directe afstammeling van de klasse. Dit betekent dat we de methode van modules niet kunnen overschrijven in de klasse, maar dat de methode in de module de methode van de klasse kan aanroepen met behulp vansuper trefwoord.

voorbeeld.rb
module ModuleA
def print_iets
puts 'Bericht van module'.
super
einde
einde

KlasseB
moduleA vooraf

def print_iets
puts 'Bericht van klasse'.
einde
einde

KlasseB.nieuw.print_iets 

Resultaat:

 $ robijn voorbeeld.rb
 Bericht van module
 Bericht van klasse

Verleng

Het werkt hetzelfde als include, behalve dat de methodes gedefinieerd in de module klassemethodes van de klasse worden.

Resultaat:

 $ robijn voorbeeld.rb Bericht van module

Functies en blokken

Python heeft functies. Ruby ondersteunt alleen methoden. Wat houdt dit in? Python kan onder andere een functie vasthouden in een variabele en deze als argument doorgeven aan een andere functie. In Ruby kunnen we dat niet zo gemakkelijk. Dit is ook gerelateerd aan de haakjes. Gegeven een functie zonder argumenten in Python, of met standaard argumenten, als je de naam zonder haakjes gebruikt, zal de functie worden teruggegeven. Alleen het toevoegen van de haakjes leidt tot de uitvoering ervan. In Ruby kunnen we functies aanroepen zonder haakjes:

voorbeeld.py
def inner_function():
print('Innerlijke functie')

def wrapper_function(functie):
print('Wrapper functie')
# functie is een variabele die functieobject bevat
function() # innerlijke functie wordt hier aangeroepen

wrapperfunction(innerfunction)

Resultaat:

 $ python3 voorbeeld.py
 Wrapper-functie
 Binnenste functie

In Ruby:

voorbeeld.rb
af innerlijke_functie
puts 'Innerlijke functie
einde

def wrapper_function(functie)
puts 'Wrapper-functie'.
functie
einde

wrapperfunction(innerfunction) # inner_function wordt hier aangeroepen

Resultaat:

 $ robijn voorbeeld.rb
 Binnenste functie
 Wrapper-functie

Natuurlijk kun je in dit geval wat trucjes toepassen in Ruby om het gewenste effect te bereiken. Ten eerste kunnen we het Proc object gebruiken:

voorbeeld.rb
af innerlijke_functie
puts 'Innerlijke functie
einde

def wrapper_function(functie)
puts 'Wrapper-functie'.
functie.aanroepen
einde

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

Resultaat:

 $ robijn voorbeeld.rb
 Wrapper-functie
 Binnenste functie

De tweede benadering is het gebruik van blokken:

voorbeeld.rbuit innerlijke_functie
puts 'Innerlijke functie
einde

def wrapper_functie
puts 'Wrapper-functie'.
geeft
einde

wrapperfunctie doen
binnenfunctie
einde

Resultaat:

 $ robijn voorbeeld.rb
 Wrapper-functie
 Binnenste functie

Lijst begrip

Dit is een heel handige Python-functie. Het bestaat uit het maken van een lijst gebaseerd op een andere lijst. Laten we aannemen dat we zo'n taak hebben: gegeven een lijst met getallen, maak een lijst met kwadraten van oneven getallen. In Python gebruiken we lijstbegrip:

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

Het voordeel is dat we maar twee lijsten in het geheugen hebben.

In Ruby liggen de zaken een beetje anders. Er zijn verschillende manieren om deze taak op te lossen. Ik zal de meest leesbare ervan presenteren:

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

Zoals we kunnen zien, kan het, maar niet zo elegant als in Python.

Alle klassen zijn muteerbaar

In Ruby zijn alle klassen muteerbaar. Wat betekent dat? We kunnen methoden van alle klassen toevoegen of overschrijven, zelfs de ingebouwde. Stel dat we een methode willen die elke letter an in b verandert in de string. We kunnen dit op een eenvoudige manier doen:

voorbeeld.rb
klasse String
def atob!
self.gsub!(/a/, 'b')
einde
einde

string = 'Voorbeeld string met veel a letters'.
puts string
string.atob!
zet string

Resultaat:

 $ ruby voorbeeld.rb
 Voorbeeld string met veel a letters
 Voorbeeld string met mbny b letters

Samenvatting

Webontwikkeling is een dynamisch veld dat voortdurend verschillende vormen aanneemt en vormgeeft programmeertalen om aan zijn behoeften te voldoen. Twee populaire keuzes op dit gebied zijn de Python programmeertaal en Ruby. Beide hebben hun waarde bewezen in webapplicaties bouwen en andere vormen van software, die elk hun unieke voor- en nadelen hebben.

Python is een programmeertaal op hoog niveau vereerd om zijn eenvoud en leesbaarheid van de code, een functie die beginnende programmeurs vaak aanspreekt. De Python programmeertaal is veelzijdig en kan voor verschillende taken worden gebruikt. Deze universele programmeertaal wordt vaak gebruikt op gebieden zoals machinaal leren, big data en met name, webontwikkeling. Een breed gemeenschap van Python-ontwikkelaars draagt bij aan het rijke ecosysteem van bibliotheken en frameworks, waardoor de geschiktheid voor webapplicaties bouwen. Django, Flask en Pyramid behoren tot de verschillende Python webframeworks benut door webontwikkelaars over de hele wereld.

Aan de andere kant is Ruby, een andere universele programmeertaal op hoog niveauschittert door zijn flexibiliteit en expressiviteit. Deze objectgeoriënteerde programmeertaal is de ruggengraat van veel webtoepassingen. De charme van Ruby ligt in het vermogen om webontwikkeling door de Rails raamwerkeen krachtig hulpmiddel voor webapplicaties bouwen snel.

Ruby, hoewel minder populair dan Pythonbeschikt over een actieve en toegewijde Ruby gemeenschap dat voortdurend een assortiment bibliotheken en tools ontwikkelt en onderhoudt, waardoor de ervaring van webontwikkelaars met behulp van deze taal. Als een objectgeoriënteerde taalRuby wordt gewaardeerd om zijn elegantie en de schone, leesbare code die het produceert, waardoor het een geschikte keuze is voor zowel klein- als grootschalig gebruik. webtoepassingen.

Python en Ruby, als objectgeoriënteerde programmeertalendelen veel overeenkomsten. Ze ondersteunen ook functioneel programmerenen biedt programmeurs verschillende stijlen om in te coderen. Python codewordt vooral gewaardeerd om zijn eenvoudige syntaxis, die de nadruk van de taal op eenvoud en leesbaarheid.

Elke taal heeft zijn sterke punten; Python's veelzijdigheid en brede gemeenschap ondersteuning maken het een uitstekend hulpmiddel voor verschillende taken, terwijl Ruby's expressiviteit en de Rails raamwerk maakt het een sterke kanshebber voor webapp ontwikkeling. Het zijn de unieke behoeften en voorkeuren van webontwikkelaars die bepaalt welke taal het beste hun project.

In het rijk van besturingssystemenBeide talen hebben een indrukwekkend niveau van draagbaarheid, waardoor ze nog beter geschikt zijn voor een groot aantal taken, niet beperkt tot webontwikkeling. Daarom is het een uitdaging om een definitieve "winnaar" uit te roepen in dit duel.

Terwijl de Python programmeertaal heeft een groter bereik en grotere gemeenschapDe mogelijkheden van Ruby moeten niet onderschat worden. Om deze talen volledig te kunnen waarderen, moet je je erin verdiepen, de fijne kneepjes ervan begrijpen en ze toepassen waar ze het meest tot hun recht komen. Of je nu webapplicaties maken met Python of Ruby, elk taal biedt een robuust platform om hoogwaardige webapps. Ruby, hoewel minder bekend, verdient zeker de waardering die het verdient in de wereld van programmeertalen.