Ruby <-> Python

[BlackJack]

Code: Alles auswählen

import operator

NO_DEFAULT = object()

def my_sum(iterable, default=NO_DEFAULT):
    iterator = iter(iterable)
    try:
        first = iterator.next()
    except StopIteration:
        if default is NO_DEFAULT:
            raise TypeError('empty iterable without default')
        else:
            return default
    return reduce(operator.add, iterator, first)

print my_sum(('H', 'a', 'l', 'l', 'o')) # -> 'Hallo'
print my_sum(xrange(6))                 # -> 15
print my_sum([], 0.0)                   # -> 0.0
print my_sum('')                        # Raises Exception.

Also was du an Code geschrieben hast, ist eher ein Argument für Ruby Nicht böse nehmen
Aber Ruby ist doch um einiges leichter zu lesen und zu verstehen. Was du da für einen Aufwand treiben mußt ist schon jenseits von gut und böse.

Okay, man muss diesen Aufwand nicht treiben. Meine Funktion macht mehr als Deine. Sie kommt nämlich auch damit klar wenn eine leeres iterierbares Objekt übergeben wurde und gibt dann entweder den `default` Wert zurück oder löst eine Ausnahme aus falls es den nicht gibt. Eine direkte Umsetzung Deiner Funktion sähe so aus:

Code: Alles auswählen

import operator

def my_sum(iterable):
    return reduce(operator.add, iterable, None)

Wie sähe die Ruby-Umsetzung von meinem ursprünglichen `my_sum` aus?

[Zambo]

Also mal abgesehen davon, das ich es nicht so machen würde:

Code: Alles auswählen

def my_sum(iterable)
  iterable.inject { |v,n| v+n }
end
  
print my_sum(['H', 'a', 'l', 'l', 'o'])       # -> 'Hallo' 
print my_sum(1..5)                            # -> 15
print my_sum([])                              # -> nil 
print my_sum('')                              # -> nil

Wie du siehst, entsteht bei Ruby überhaupt keine Fehlermeldung, die abgefangen werden muß. Wenn man nichts übergibt, kommt auch nichts raus

Der Code ist trotzdem "etwas" übersichtlicher.

Gruß
Zambo

[sape]

Mal abgesehen davon das mich END Blöcke stören (dann doch lieber die hier { … } wie bei C/C++) scheint nach deinen Beilspielen Ruby schon nicht schlecht zu sein. Ich hab mal vor einiger zeit mal ein Ruby Tutorial angeschaut und bin dann zu dem Ergebnis gekommen das vieles (für mich) zu unübersichtlich ist. Hat mich teilweise doch schon an Perl erinnert, oder besser gesagt viele Möglichkeiten sind genauso unstrukturiert, wirr und machen den Code auf Dauer schlecht wartbar (also für mich jetzt!).

Ich finde jeder sollte selber entscheiden welche Programmiersprache er Hauptsächlich nutzen will. Für mich viel halt die Auswahl auf Python weil der Code sehr Ansprechend aussieht für mich und leicht zu erlernen ist. Ganz früher hatte ich mal in C/C++ Programmiert und muss heute sagen, warum habe ich nicht schon früher in Python geschrieben Naja heute würde ich C/C++ (eher C ^^) bei Zeitkritischen Sachen nutzen und ansonsten alles in Python machen bzw. je nach Anwendungsfall auch mal Perl benutzen. (-> wenns schnell gehen soll und dabei Reguläre ausdrücke zum Einsatz kommen, was in Python mMn zu Kompliziert gelöst ist bzw. ich verstehe die Umsetzung in Python noch nicht wirklich).

lg

[mitsuhiko]

2.) Es gibt Mix-Ins. Das heißt, man schreibt eine Funktion und kann diese zu einer Klasse hinzumischen.

Geht mit Mehrfachvererbung oder...:

Code: Alles auswählen

>>> import sys
>>> def include(obj):
...  ns = sys._getframe(1).f_locals
...  for key, value in obj.__dict__.iteritems():
...   if not key.startswith('_'):
...    ns[key] = value
... 
>>> class Debug(object):
...  def wer_bin_ich(self):
...   return self.__class__.__name__
... 
>>> class MyClass(object):
...  include(Debug)
... 
>>> MyClass().wer_bin_ich()
'MyClass'

@Thema: auf alle Fälle Python. Wegen logischer Syntax, Mehrfachvererbung, Unicode, Dekoratoren, einfachen Closures, First-Class Functions and noch viel mehr (Man kann zb den () Operator überladen ^^)

//EDIT: http://lucumr.pocoo.org/entry/rrrrruby/ <-- meine persönliche: warum ich ruby nicht wirklich leiden kann liste

[BlackJack]

Also mal abgesehen davon, das ich es nicht so machen würde:

Code: Alles auswählen

def my_sum(iterable)
  iterable.inject { |v,n| v+n }
end
  
print my_sum(['H', 'a', 'l', 'l', 'o'])       # -> 'Hallo' 
print my_sum(1..5)                            # -> 15
print my_sum([])                              # -> nil 
print my_sum('')                              # -> nil

Wie du siehst, entsteht bei Ruby überhaupt keine Fehlermeldung, die abgefangen werden muß. Wenn man nichts übergibt, kommt auch nichts raus

Äh, genau darum ging es doch aber. Das man einen Defaultwert übergeben kann und das eine Ausnahme ausgelöst wird wenn die Sequenz leer ist und kein Defaultwert übergeben wurde. Das Ergebnis da hat Deine alte Version auch produziert und ist nicht mit meiner ersten Version äquivalent.

Mal angenommen ich summiere eine Liste die Zahlen enthalten soll und die ist leer; dann möchte ich zur Weiterverarbeitung entweder eine 0 haben, oder eine Ausnahme die mich drauf aufmerksam macht; aber doch nicht `nil`. Spätestens wenn ich damit weiterrechnen will, bekomme ich eine Ausnahme.

Der Code ist trotzdem "etwas" übersichtlicher.

Was nun aber höchstgradig Geschmackssache ist. Sowohl `reduce` als auch `inject` sind nicht wirklich selbsterklärend.

[sape]

//EDIT: http://lucumr.pocoo.org/entry/rrrrruby/ <-- meine persönliche: warum ich ruby nicht wirklich leiden kann liste

Ja genau, das mein ich mit wirren unübersichtlichen code ^^ Sieht irgendwie eigenartig aus xD

[Zambo]

Also wenn du lieber eine Null zurück kriegen willst, könnte ich folgenden Code anbieten:

Code: Alles auswählen

def my_sum(iterable) 
  ergebnis = iterable.inject { |v,n| v+n } 
  return 0 if ergebnis.nil?
  return ergebnis
end 

oder

Code: Alles auswählen

def my_sum(iterable) 
  ergebnis = iterable.inject { |v,n| v+n } 
  return ergebnis.nil? ? 0 : ergebnis
end  

Was nun aber höchstgradig Geschmackssache ist. Sowohl `reduce` als auch `inject` sind nicht wirklich selbsterklärend

Das stimmt natürlich

[jens]

Code: Alles auswählen

...
  return 0 if ergebnis.nil?
  return ergebnis
...
  return ergebnis.nil? ? 0 : ergebnis

Wow

Also die beiden Varianten sind ja der Hammer und das meine ich nur negativ

Also 'return 0 if ergebnis.nil?' Erscheind mir noch einigermaßen logisch, wenn es so aussehen würde: 'return 0 if ergebnis == nil'
Aber die zweite Variante ist echt undurchsichtig!

In Python würde das einfach so aussehen:

Code: Alles auswählen

if ergebnis == "nil":
    return 0
else:
    return ergebnis

Da ist es doch jedem klar, was passiert, selbst wenn einer keine Ahnung von Python hat.
OK man könnte auch in Python einen undurchsichtigen Einzeiler machen...

[Zambo]

Die zweite Version sollte nur zeigen, das es auch kürzer geht. Ich komme ja eigentlich aus der C++ Ecke und da gibts auch so Konstruktionen. Auch wenn ich sie ehrlich gesagt noch nie benutzt habe

Aber natürlich kann man es auch so schreiben:

Code: Alles auswählen

def my_sum(iterable) 
  ergebnis = iterable.inject { |v,n| v+n } 
  return 0 if ergebnis==nil
  return ergebnis
end

oder so

Code: Alles auswählen

def my_sum(iterable) 
  ergebnis = iterable.inject { |v,n| v+n } 
  if ergebnis==nil then
    return 0
  else
    return ergebnis
  end
end 

Ruby läßt da einen sehr viele Möglichkeiten.

[jens]

Das sieht schon Augenfreundlicher aus
Aber das ist andererseits genau das, warum ich Python schöner finde. Vergleichen wir mal direkt:

Code: Alles auswählen

if ergebnis == nil then
    return 0
else
    return ergebnis
end

Code: Alles auswählen

if ergebnis == "nil":
    return 0
else:
    return ergebnis

Wie man sehen kann, sieht beides ähnlich aus. Aber der Python Code ist weniger, aber gleichgut zu lesen. "then" ist einfach nur der Doppelpunkt und "end" wird gleich eingespart, dafür haben wir ja Eingerückt...

Wobei Ruby da auch schon sehr gut ist: Die Blöcke werden zumindest nicht, wie in C/Java/JavaScript mit { und } gebildet, Zeilenenden benötigen auch kein Semikolon. Das ist schon mal was!

Also würde ich mal sagen, Python ist die schönste Sprache, danach kommt Ruby und dann, mit weitem Abstand, der Rest

[BlackJack]

@jens: Das Python äquivalent zu ``if obj.nil?`` ist ``if obj is None``.

Ob die beiden Varianten undurchsichtig sind, hängt von Erfahrungen in anderen Spachen ab.

Das jedes Objekt eine `isNil` Methode hat, die nur beim `Nil` Objekt (Singleton) wahr zurückgibt und bei allen anderen falsch, ist in Smalltalk-ähnlichen Sprachen üblich. Finde ich auch nicht unbedingt schlecht; die Idee alles mit Methoden zu lösen ist eine interessante Möglichkeit. Auf dem Konzept aufbauend, kann man eine Sprache schön einfach halten und zum Beispiel auch ``if`` und Schleifen als Methoden implementieren. So lässt sich die Anzahl der Schlüsselworte in einer Sprache auf ein Minimum reduzieren. Was mich an der ersten Variante stört ist der "Perlismus" mit dem ``if``, das man an verschiedenen Stellen schreiben kann.

Die zweite Variante ist der allseits beliebte Ternäroperator aus C/Java/C# etc. So etwas hässliches bekommen wir mit Python 2.5 ja auch vorgesetzt. Das ist eine der beiden Entscheidungen von Guido, die ich absolut furchtbar finde. Die andere ist diese Inkonsistenz bei `sum()` und Zeichenketten. Über die Dekoratorsyntax bin ich mittlerweile hinweggekommen.

@Zambo: Schön das Du Dich darum drückst einen Default-Parameter in Deinen Quelltext einzubauen der jeden beliebigen Wert annehmen kann und eine Ausnahme falls das Ergebnis `nil` ist und kein Default gesetzt wurde. Du hast gesagt das sieht in Python viel zu aufwändig aus, dann möchte ich das doch gerne mal mit äquivalentem Ruby vergleichen können.

[jens]

@jens: Das Python äquivalent zu ``if obj.nil?`` ist ``if obj is None``.

Das hatte ich vermutet. Aber da ich Ruby nicht kenne und es auch nicht wirklich darum geht, hatte ich einfach "nil" (als String) übernommen...

[Zambo]

Hallo BlackJack,

ich habe den Default-Parameter nicht eingebaut, weil ich ihn überflüssig finde. Aber wenn du umbedingt eine 1 zu 1 übersetzung haben willst:

Code: Alles auswählen

def my_sum(iterable,default=nil) 
  ergebnis = iterable.inject { |v,n| v+n } 
  
  if ergebnis.nil? then  
    raise "empty iterable without default" if default.nil?
    return default
  else
    return ergebnis
  end
end

print my_sum(['H', 'a', 'l', 'l', 'o'])     # -> 'Hallo' 
print my_sum(1..5)                          # -> 15 
print my_sum([],0.0)                        # -> 0.0 
print my_sum('')                            # -> Raises Exception.

Meiner Meinung nach ist das Programm immer noch um einiges verständlicher als

Code: Alles auswählen

import operator 

NO_DEFAULT = object() 

def my_sum(iterable, default=NO_DEFAULT): 
    iterator = iter(iterable) 
    try: 
        first = iterator.next() 
    except StopIteration: 
        if default is NO_DEFAULT: 
            raise TypeError('empty iterable without default') 
        else: 
            return default 
    return reduce(operator.add, iterator, first) 

print my_sum(('H', 'a', 'l', 'l', 'o')) # -> 'Hallo' 
print my_sum(xrange(6))                 # -> 15 
print my_sum([], 0.0)                   # -> 0.0 
print my_sum('')                        # Raises Exception.

Aber mal davon abgesehen. Du hast glaube ich den Anfang unserer Unterhaltung vergessen. Ich habe dir ein Beispiel gezeigt, wie ich die inneren Klassen von Ruby durch Mix-Ins erweitert habe. Du hast mir bis jetzt kein Beispiel in Python zeigen können, dass das kann?

Gruß
Zambo

[mitsuhiko]

Meiner Meinung nach ist das Programm immer noch um einiges verständlicher als ...

Tut auch was anders....

Dein Quelltext sieht in Python so aus:

Code: Alles auswählen

def my_sum(iterable, default=None):
    try:
        return reduce(lambda a, b: a + b, iterable)
    except TypeError:
        if default is None:
            raise ValueError('iterable required')
        return default

Aber mal davon abgesehen. Du hast glaube ich den Anfang unserer Unterhaltung vergessen. Ich habe dir ein Beispiel gezeigt, wie ich die inneren Klassen von Ruby durch Mix-Ins erweitert habe. Du hast mir bis jetzt kein Beispiel in Python zeigen können, dass das kann?

Für was include() wenn du Mixin Klassen in Python hast? Schau dir einfach mal in SimpleHTTPServer um, da findest du beispielsweise Threadin Mixins. Es gibt in Python einfach keine Verwendung für include() weil wir keine Verkrüppelte Vererbung haben
Aber wie ich dir gezeigt habe kann man wunderbar ein include() für Python nachbauen.

@jedie: das then kannst du in Ruby fallen lassen

[Zambo]

Meiner Meinung nach ist das Programm immer noch um einiges verständlicher als ...

Tut auch was anders....

Ach ja

Dein Quelltext sieht in Python so aus:

Code: Alles auswählen

def my_sum(iterable, default=None):
    try:
        return reduce(lambda a, b: a + b, iterable)
    except TypeError:
        if default is None:
            raise ValueError('iterable required')
        return default

Das ist auch eine Möglichkeit.

Für was include() wenn du Mixin Klassen in Python hast? Schau dir einfach mal in SimpleHTTPServer um, da findest du beispielsweise Threadin Mixins. Es gibt in Python einfach keine Verwendung für include() weil wir keine Verkrüppelte Vererbung haben
Aber wie ich dir gezeigt habe kann man wunderbar ein include() für Python nachbauen.

Ich glaube du willst einfach nicht verstehen, das es Vorteile haben kann, die interne Klassenstruktur von einer Programmiersprache zu erweitern. Aber jetzt habe ich echt keine Lust mehr zu schreiben. Schaut euch Ruby einfach mal an. Es ist wirklich eine sehr einfache, klare und gute Programmiersprache und wer noch was wissen will, kann mir gerne eine Nachricht schicken.

[mitsuhiko]

Meiner Meinung nach ist das Programm immer noch um einiges verständlicher als ...

Tut auch was anders....

Ach ja

Ja

Das ist auch eine Möglichkeit.

Das ist dein Quelltext. Das was BlackJack gemacht hat sieht in Ruby so aus:

Code: Alles auswählen

NO_DEFAULT = Object.new

def my_sum iterable, default=NO_DEFAULT
  result = iterable.inject { |a, b| a + b }
  if result.nil?
    if default === NO_DEFAULT
      raise 'empty iterable without default'
    end
    default
  end
  result
end

Wobei das auch nicht ganz richtig ist. Da Ruby keine Iteratoren als solches kennt und "for i in iterable" das gleich ist wie "iterable.each { |i| }" kann ich nicht das erste Element anfordern wie BlackJack das mit seinem Python Code gemacht hat. Das heißt BlackJacks Code sieht jetzt etwa so aus:

Code: Alles auswählen

NO_DEFAULT = object()

def my_sum(iterable, default=NO_DEFAULT):
    try:
        return reduce(lambda a, b: a + b, iterable)
    except TypeError:
        if default is NO_DEFAULT:
            raise TypeError('empty iterable without default')
        return default

Ich glaube du willst einfach nicht verstehen, das es Vorteile haben kann, die interne Klassenstruktur von einer Programmiersprache zu erweitern. Aber jetzt habe ich echt keine Lust mehr zu schreiben. Schaut euch Ruby einfach mal an.

Hab ich schon getan. Ich lästere nicht über Programmiersprachen von denen ich keien Ahnung habe.

Es ist wirklich eine sehr einfache, klare und gute Programmiersprache und wer noch was wissen will, kann mir gerne eine Nachricht schicken.

Ich finde sie weder einfach, noch klar. Ich gebe zu das Ruby auch Tolle Dinge hat: Blöcke, die ich in python gerne als Syntax für anonyme Funktionen hätte, Regexes mit hilfe von // statt re.compile() zu erstellen aber das wars auch schon. Ruby regt mich schon deswegen auf weil es keine Klammern hat. Manche mögen das an Ruby toll finden, mich schränkt es ein weil ich Die Klasse eine Funktion nur durch den Class.method(:name) Umweg bekomme. Auch fehlt mir die Unicode Unterstützung, die Iteratoren und Generatoren.

[BlackJack]

Ich glaube du willst einfach nicht verstehen, das es Vorteile haben kann, die interne Klassenstruktur von einer Programmiersprache zu erweitern.

Ich verstehe das. Und bin in anderen Sprachen auch schon drüber gestolpert, nämlich genau dann, wenn man zwei Bibliotheken hat, die beide der Meinung sind, ein `Integer` müsste eine `foo()` Methode haben.

Wobei das in Python keine Einschränkung von der Sprachspezifikation ist, sondern von der Implementierung in CPython. Die Spezifikation verbietet das Setzen von zusätzlichen Attributen bei den Grunddatentypen nicht.

Schaut euch Ruby einfach mal an. Es ist wirklich eine sehr einfache, klare und gute Programmiersprache [...]

Es gibt einfachere und klarere. Von der Syntax her ist Python einfacher und konsistenter was das Verhalten von Typen und Sprachkonstrukten angeht. Unter den Smalltalk-ähnlichen Programmiersprachen gibt es auch wesentlich einfachere und konsistentere, z.B. Io.

[jens]

Passt jetzt nicht so super hier rein, aber fast.

Unter http://wiki.ubuntuusers.de/Perl steht u.a. das von Perl:

Durch die vorherige Kompilation in Bytecode werden jedoch Syntaxfehler und andere Fehler vor der Ausführung des Skriptes gefunden. Weiterhin wurden schon einige Optimierungen vorgenommen. Wenn man einen Ausdruck wie "10*1024*1024*1024*8" schreibt, um z.B. 10GB in Bit darzsutellen, dann berechnet Perl diesen Ausdruck bloß einmal. Auch Kommentare werden in diesem Zwischencode heraus gefiltert. Bei einer reinen interpretierten Sprache müsste dieser Ausdruck immer wieder neu berechnet werden, sobald der Interpreter diese Zeile erreicht. Jedesmal, wenn der Interpreter eine neue Zeile einliest, muss er erkennen, ob es sich um ein Kommentar handelt, was Performance kostet. Bei Perl müssen man sich um solche Dinge keine Gedanken machen und kann auch Kommentare innerhalb von Schleifen setzen, ohne das die Performance darunter leidet.

Im grunde macht alles das Python auch, insbesondere den fett gedrukten Teil... oder nicht?

Wenn man die Wikiseite bei ubuntuusers liest, hört sich Perl sogar gut an... Naja, vielleicht doch nicht so richtig...

[BlackJack]

Diese Optimierung ist relativ neu. Python 2.4.3:

Code: Alles auswählen

In [4]: def f():
   ...:     return 10*1024*1024*1024*8
   ...:

In [5]: dis.dis(f)
  2           0 LOAD_CONST               1 (10)
              3 LOAD_CONST               2 (1024)
              6 BINARY_MULTIPLY
              7 LOAD_CONST               2 (1024)
             10 BINARY_MULTIPLY
             11 LOAD_CONST               2 (1024)
             14 BINARY_MULTIPLY
             15 LOAD_CONST               3 (8)
             18 BINARY_MULTIPLY
             19 RETURN_VALUE

Python 2.5b2:

Code: Alles auswählen

>>> def f():
...     return 10*1024*1024*1024*8
...
>>> dis.dis(f)
  2           0 LOAD_CONST               7 (85899345920L)
              3 RETURN_VALUE

[rolgal_reloaded]

Also mich hat bei Ruby das end genervt.

Wo kein begin, da braucht es auch kein end. Wie man an Python sieht braucht es auch kein begin, daher konsequneterweise auch kein end

Wie nennt man das Sprachdesign?
Wie auch immer, es gefällt mir bei Ruby nicht.

Zum Thema Mixins, den Sinn habe ich nicht sofort verstanden, das Prinzip der Mehrfachvererbung (das wird ja gerne miteinander verglichen) hingegen sofort (heisst nicht dass ich OOP sofort insgesamt verstehen im Sinne von anwenden konnte).

Liebe Grüße

rolgal_reloaded