Tech-Talk: Python vs. Ruby

Python vs. Ruby

Tobias Schlauch <Tobias.Schlauch@dlr.de>
Tech-Talk, DLR Braunschweig, 23.03.2010

Übersicht

Motivation
Die Kontrahenten im Überblick
Syntax
Spracheigenschaften
Objektorientierung
Strings
Werkzeugunterstützung
Performance
Verwendung
Fazit

Folie 2
The DLR Software Engineering Network > Schlauch, T.

Motivation

Eine Vielzahl so genannten Skriptsprachen – existiert
Beispiele: Python, Ruby, Groovy, Perl, PHP, LISP, Tcl, …
Gemeinsamkeiten:
Implizite Variablendeklaration
Dynamische Typisierung
Interpretiert
Automatische Speicherbereinigung

Welche Sprache ist für mich die richtige?
Hängt von der Anforderungen ab und erfordert Kenntnisse der
jeweiligen Spezifika.
Deshalb hier ein Vergleich der populären Skriptsprachen
Python und Ruby

Folie 3

Python (1/2)

Entwicklung Anfang der 1990er Jahre durch
Guido van Rossum am Zentrum für Mathematik und
Informatik in Amsterdam als Ersatz der
Programmierlehrsprache ABC

Philosophie - Auszug aus dem Python-Zen:
Explicit is better than implicit.
Simple is better than complex.
Readability counts.
There should be one -- and preferably only one --
obvious way to do it.
If the implementation is hard to explain, it's a bad
idea.

Folie 4

Python (2/2)

Weiterentwicklung der Referenzimplementierung durch die
Python Software Foundation
Referenzimplementierung: CPython
Aktuelle Version: 3.1.2 (21. März 2010)
2.6.5 (19. März 2010)

Weitere Implementierungen: Jython, IronPython, PyPy,
Parrot, Stackless Python

Lizenz: Python License

Projektseite: http://python.org/

Folie 5

Ruby (1/2)

Entwicklung Mitte der 1990er Jahre aus Unzufriedenheit
über verfügbare Skriptsprachen durch
Yukihiro Matsumoto

Verbreitung zunächst nur in Japan, seit 2000
Bemühungen zur Verbreitung über Japan hinaus
ausgeweitet

Philosophie: Principle of Least Surprise

„ Ruby is two parts Perl, one part Python,
and one part Smalltalk” - Colin Steele

Folie 6

Ruby (2/2)

Weiterentwicklung durch Yukihiro Matsumoto und andere Entwickler
Referenzimplementierung: CRuby
Aktuelle Version: 1.9.1-p378 (10. Januar 2010)
1.8.7-p249 (10. Januar 2010)

Weitere Implementierungen: JRuby, IronRuby, Rubinius, Cardinal,
MacRuby, Ruby Enterprise Edition, …

Lizenz: Ruby License, GPL

Projektseite: http://www.ruby-lang.org/de/

Folie 7

Syntax
Gemeinsamkeiten

Anweisungen enden ohne Semikolon

Viele Schlüsselworte sind ähnlich

Erzeugung von Listen per []

Erzeugung von Hashes/Dictionaries per {}

Kürzere Quelltexte als vergleichbare Java/C++-Programme

Folie 8

Syntax
„Hello World!“ - Python
knownGreetings = {"german": ["Hallo Welt!", "Super hier!"],
"english": ["Hello World!", "Cool here"]}

def extendedGreetings(language):
result = ""
if language in knownGreetings:
for greet in knownGreetings[language]:
result += greet + " "
return result

print extendedGreetings("german") liefert: "Hallo Welt! Super hier!"
print extendedGreetings("english") liefert: "Hello World! Cool here"
print extendedGreetings("unknown") liefert: ""

Folie 9

Syntax
„Hello World!“ - Ruby
$knownGreetings = {"german" => ["Hallo Welt!", "Super hier!"],
"english" => ["Hello World!", "Cool here"]}

def extendedGreetings(language)
result = ""
if $knownGreetings.has_key? language
$knownGreetings[language].each do |greet|
result += greet + " "
end
end
result
end

puts extendedGreetings("german") liefert: "Hallo Welt! Super hier!"
puts extendedGreetings("english") liefert: "Hello World! Cool here"
puts extendedGreetings("unknown") liefert: ""

Folie 10

Syntax
Unterschiede zu Python

Einrückung ist freiwillig => Beendung mehrzeiliger Anweisungen
durch end
Flexibel einsetzbare Code-Blöcke
Aufruf von Methoden ohne Klammern
Alles ist ein Ausdruck
Implizites return
Erzwungene Namenskonventionen für Klassen, Variablen, …
true, false, nil entspricht True, False, None
Nur nil und false werden negativ in Bedingungen ausgewertet
Keyword-Argumente werden durch Hashes emuliert
Verknüpfung von Namesspaces durch den ::-Operator

Folie 11

Spracheigenschaften
Gemeinsamkeiten

Multiparadigmenunterstützung
Prozedural, Funktional, Objektorientiert
Durch und durch objektorientiert - Alles ist ein Objekt!
Variablen sind Referenzen auf Objekte
Dynamische, starke Typisierung – a.k.a „Duck Typing“
Beliebige Erweiterbarkeit von Klassen
Definition von Methoden auf Klassen- und Objektebene
Unterstützung von Introspektion und Metaprogrammierung
Exception-Unterstützung (andere Syntax)

Folie 12

Spracheigenschaften
Unterschiede zu Python

Starke Unterscheidung der Realisierung der Konzepte Klasse, Attribut
und Methode
Zugriff erfolgt ausschließlich auf Methoden
Python-artige Properties durch optionale Klammerung
Einschränkung der Sichtbarkeit durch public, protected, private
Mixins anstatt von Mehrfachvererbung
Unterstützung von globalen Variablen - $globalVar
Existenz eines Listentyps, der als Tupel, Liste, Queue, Stack verwendet
wird
Modul- und Pakethierarchien existieren nur per Konvention

Folie 13

Objektorientierung
Klassen, Attribute, Methoden in Python (1/2)
class Test(object):
classVar = 1

def __init__(self, instanceVar):
self.__instanceVar = instanceVar

def doSomething(self):
print "I do it.. %i" % self.__instanceVar
self.__class__.classVar += 1

def _doSomething(self):
print "I am protected."

def __doSomething(self):
print "I am private."

Folie 14

Objektorientierung
Klassen, Attribute, Methoden in Python (2/2)
t1 = Test(1)
t2 = Test(2)

print Test.classVar liefert: "1"

t1.doSomething() liefert: "I do it.. 1"
print Test.classVar, Test.classVar liefert: "3, 3"

t1._doSomething() liefert: "I am protected."

t1.__doSomething() liefert: "AttributeError: 'Test' object
has no attribute
'__doSomething'"

Folie 15

Objektorientierung
Klassen, Attribute, Methoden in Ruby (1/2)
class Test
@@classVar = 1

def initialize(instanceVar)
@__instanceVar = instanceVar
end

def doSomething
puts "I do it.. %i" % @__instanceVar
@@classVar += 1
end

def _doSomething
puts "I am protected."
end
protected :_doSomething

...

Folie 16

Objektorientierung
Klassen, Attribute, Methoden in Ruby (2/2)
def __doSomething
puts "I am private."
end
private :__doSomething
def self.classVar
@@classVar
end
end
t1 = Test(1)
t2 = Test(2)
print Test.classVar liefert: "1"
print Test.classVar, Test.classVar liefert: "3n3"
t1._doSomething() liefert: "protected m...(NoMethodError)"
t1.__doSomething() liefert: "private m...(NoMethodError)"

Folie 17

Objektorientierung
Mehrfachvererbung in Python
class A(object):
def a(self):
print "Instance of A"

class B(object):
def b(self):
print "Instance of B"

class C(A, B):
def c(self):
self.a()
self.b()

c = C()
c.c() liefert: "Instance of AnInstance of B"

Folie 18

Objektorientierung
Einfachvererbung und Mixins in Ruby
class A
def a
puts "Instance of A"
end
end
module B Mixin
def b
puts "Instance of B"
end
end
class C < A
include B
def c
a
b
end
end
c = C.new
c.c() liefert: "Instance of AnInstance of B"

Folie 19

Objektorientierung
„Duck Typing“ in Python (1/2)
class Bird(object):

def __init__(self, name):
self.name = name

def __str__(self):
return self.name

class Duck(Bird):
def quak(self):
print "quak"

Folie 20

Objektorientierung
„Duck Typing“ in Python (2/2)
for duck in [Bird("Tweety"), Duck("Dagobert"), object()]:
try:
duck.quak()
except AttributeError:
print "Is not a duck: ", duck

Liefert:

Is not a duck: Tweety
quak
Is not a duck: #<Object:0xd1329>

Folie 21

Objektorientierung
„Duck Typing“ in Ruby (1/2)
class Bird
def initialize(name)
@name = name
end

def to_s
@name
end
end

class Duck < Bird
def quak
puts "quak"
end
end

Folie 22

Objektorientierung
„Duck Typing“ in Ruby (2/2)
[Bird.new("Tweety"), Duck.new("Dagobert"), Object.new()].each do |duck|
begin
duck.quak
rescue NoMethodError
puts "Is not a duck: %s" % duck
end
end

Liefert:

Is not a duck: Tweety
quak
Is not a duck: #<Object:0xd1329>

Folie 23

Strings

Python
Unterscheidung von 8-Bit-(binär)- und Unicode-Strings
Strings sind generell immutable
Unicode-Support ist nativ implementiert

Ruby
Unterscheidung von Strings (mutable) und Symbols (immutable)
Ab Version 1.9 encoding-Methode hinzugefügt und Behandlung
von Strings mit unterschiedlichen Encodings verbessert
Separater Unicode-Support (Typ) als Zusatzmodul prototypisch
realisiert

Folie 24

Lieferumfang der Referenzimplementierung
Python
Interaktiver Interpreter (python) – GIL!
Umfangreiche Standardbibliothek (+)
pydoc als Dokumentationswerkzeug (kaum akzeptiert)
Alternativen: Doxygen, Epydoc
Distutils als Paketverwaltungswerkzeug
Alternative: setuptools
Ruby
Interaktiver Interpreter (irb) – GIL, Garbage Collector!
Umfangreiche Standardbibliothek
RDoc und ri als Dokumentationswerkzeuge (+)
RubyGems (gems) als Paketverwaltungswerkzeug mit
Versionierungsunterstützung (+)

Folie 25

Integrierte Entwicklungsumgebungen

Für Python und Ruby existieren Integrationen in Eclipse, Netbeans,
Komodo sowie weitere Thrid-Party-IDEs existieren
Test der Eclipse-Plugins
Python (PyDev)
Performance höher
Autovervollständigung präziser
Debugger-Handling
Interaktive Konsole
Ruby (Aptana RadRails)
Refactoring-Unterstützung kompletter
Unittest-Integration grafisch unterstützt
Insgesamt für beide zur professionellen Entwicklung geeignet

Folie 26

Unittests / Code-Coverage / Code-Style
Unittests
Eingebaute Unittest-Frameworks sind vorhanden und machen
einen guten Eindruck
Code-Coverage
Verschiedene Projekte existieren/existierten in Python
coverage.py mit Unterstützung von C0- und C1-Coverage
und der Ausgabe in verschiedene Formate ist derzeit die
beste Wahl
rcov mit Unterstützung der C0-Coverage
Code-Style
Für Python ist derzeit pylint die beste Wahl
Für Ruby konnte ich kein Werkzeug finden 
Hier aber ein paar „ähnliche“ Werkzeuge:
http://devver.net/blog/2008/10/ruby-tools-roundup/

Folie 27

Performance

Generell ist die Performance von Python 2.X ähnlich einzuschätzen als
die von Ruby 1.X bzgl. der Referenzimplementierung
Python 3.X verspricht weitere Optimierung
Siehe auch: http://www.testfreaks.com/blog/news/python-and-ruby-
performance/
Und: http://blog.ianbicking.org/ruby-python-
power.html#performance-environment
Für beide existieren JIT-Compiler zur Optimierung
Python: psycho
Ruby: Ludicrous JIT Compiler
Performancekritische Programmbereiche können von beiden z.B. in C/
C++ ausgelagert werden

Folie 28

Verwendung und Verbreitung

Python
Nutzung in Webframeworks: Django, Pylons, Zope, …
Skriptsprache für C++-Programme
100-Dollar-Laptop
PyPi: 9382 Pakete
Ruby
Webframework: Ruby on Rails
RubyForge und Ruby Application Archive: 7000
TIOBE Programming Community Index (März 2010):
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
Python auf Platz 7
Ruby auf Platz 11

Folie 29

Fazit (1/2)

Generell nehmen sich beide Sprachen nicht viel bzgl. ihrer
grundlegenden „Ausdruckskraft“
Ruby verletzt die Regeln des Python-Zen und kann Perl ähnlich
sehen, was viele Pythonisten abschreckt. Bei genauerem Hinsehen
wird deutlich, dass beide Sprache sehr ähnliche Ziele verfolgen,
diese aber mit unterschiedlichen Mitteln erreichen.
Die Communities von Python und Ruby sind deshalb oft in
produktivem Kontakt.
http://www.ruby-lang.org/de/documentation/ruby-from-other-
languages/to-ruby-from-python/

Lesbarkeit und Wartbarkeit ist meiner Meinung nach bei Python
wesentlich höher ausgeprägt!!

Folie 30

Fazit (2/2)

Werkzeugunterstützung ist ähnlich gut
Vorteil Ruby: Es gibt so etwas wie Standardwerkzeuge zur
Dokumentation und Packaging
Vorteil Python: Stärkere Standardbibliothek und bessere
Unterstützung im QS-Bereich (pylint!)

Performance ist in den Referenzimplementierungen ähnlich
einzuschätzen

Vorteile in der Verwendung und Verbreitung liegen bei Python

Folie 31

Vielen Dank!
Fragen??

Weitere Quellen:
http://de.wikipedia.org/wiki/Python_%28Programmiersprache%29
http://de.wikipedia.org/wiki/Ruby_%28Programmiersprache%29

Folie 32

Tech-Talk: Python vs. Ruby

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Tech-Talk: Python vs. Ruby

Ähnlich wie Tech-Talk: Python vs. Ruby (20)

Tech-Talk: Python vs. Ruby