Das deutsche Python-Forum

poker hat geschrieben:Das ist da doch zuviel gehacke. Dann kann man auch gleich ``class`` als namespace Nutzen. Aber dan kommen die jenigen mit ihrer "reinen" Lehre.

birkenfeld hat geschrieben:

poker hat geschrieben:Das ist da doch zuviel gehacke. Dann kann man auch gleich ``class`` als namespace Nutzen. Aber dan kommen die jenigen mit ihrer "reinen" Lehre.

Ich dachte, das warst du...

birkenfeld hat geschrieben:Ich dachte, das warst du...

birkenfeld hat geschrieben:

poker hat geschrieben:Das ist da doch zuviel gehacke. Dann kann man auch gleich ``class`` als namespace Nutzen. Aber dan kommen die jenigen mit ihrer "reinen" Lehre.

Ich dachte, das warst du...

poker hat geschrieben: Meine Meinung resultiert nicht daraus das andere Leute mir sagen was richtig und falsch ist, sondern durch eigene Erfahrung!

poker hat geschrieben: Letztendlich ist die "reine" Lehre nur soviel Wert bis man auf deren Grenzen stößt, das aber in dem Fall halt nicht gegeben ist. Deshalb empfehlen wir dir auch de anderen Lösungen weil sie "sauberer" und "pythonischer" sind.

Sobald Ihre Programme in Ruby größer und größer werden, werden Sie normalerweise bemerken, dass Sie wiederverwertbaren Code produzieren -- Bibliotheken mit ähnlichen Routinen, die allgemein anwendbar sind. Sie werden diesen Code in separaten Dateien abspeichern möchten, damit ihn auch andere Ruby-Programme verwenden können.

Dieser Code wird oft in Klassen organisiert sein, also werden Sie vermutlich eine Klasse (oder eine Reihe von Klassen, die in Beziehung zueinander stehen) in eine Datei stecken.

Manchmal kommt es jedoch vor, dass man Dinge gruppieren möchte, die normalerweise keine Klasse bilden.

poker hat geschrieben:In diesem Kontext (Für den Gerold und sicher viele andere auch) das haben wollen würden, wäre ein ``namespace`` Super hilfreich. Damit würde es erst gar nicht zu Ideologischen Diskussionen kommen, weil man schlicht und einfach weiß ``class`` != ``namespace`` (Auch wenn die Semantik vielleicht die gleiche bleibt!) Im übrigen würde **ich es auch** nicht schlecht finden, weil es eine zusätzliche neue Qualität der Strukturierung mitbringt die **erstmal** frei von jeder ``class`` behafteten Ideologie/Dogmatik (nenne es wie du wilst) ist .

poker hat geschrieben:Und ich denke damit steht Gerold nicht alleine da. In Ruby hat man das erkannt und deshalb gibt es dort ``module``. Da in Python Module anders definiert sind (Also lediglich dateien die selbst wider ein Objekt darstellen), würde da das von Gerold vorgeschlagenen ``namespace`` treffender sein -- Damit hätte man die gleiche Syntax und Semantik innerhalb eines Python Modules

Leonidas hat geschrieben: Wenn ich mir das so überlege - ich selbst habe selbst mal überlegt so Funktionen zusammenzufassen, aber letztendlich fand ich dass der Vorteil den es bietet zu gering ist, als dass man da weitere Syntaxkonstrukte hinzufügen müsste.

Leonidas hat geschrieben: Außerdem heißt es doch "Flat is better than nested.".. andererseits aber auch "Namespaces are one honking great idea -- let's do more of those!". Der Zen hat also auch zwei Meinungen dazu.

Leonidas hat geschrieben: Ich habe ja vorgeschlagen das in Python zu implementieren. Dann kann man damit auch testen, ob das überhaupt praktikabel ist und als Beispielimplementierung würde dass auch für einen etwaigen PEP handlich sein.

blackbird hat geschrieben:Ich find zwar die Idee nach wie vor bescheuert, aber mit Metaklassen kann man sich damit wenigstens virtuelle Module bauen:

Code: Alles auswählen

import sys, types

class NamespaceType(type):
  def __new__(cls, name, bases, d):
    rv = type.__new__(cls, name, bases, d)
    if namespace is not None:
        rv = rv(rv.__name__)
        sys.modules['%s.%s' % (rv.__module__, rv.__name__)] = rv
    return rv

namespace = None
class namespace(types.ModuleType):
  __metaclass__ = NamespaceType

class foo(namespace):
  def blub(self):
    print "Ich bin ein Modul"

Wenn man das jetzt in blub.py speichert kann man sowas tun:

Code: Alles auswählen

import blub
blub.foo.blub()

Oder halt auch

Code: Alles auswählen

from blub.foo import blub
blub()

poker hat geschrieben: Klar kann man dafür auch einfach eine Klasse nutzen, aber **und** das ist der Punkt, es ist nicht sofort ersichtlich für einen was die Intention ist. Sprich: Wenn ich (und X**N andere) sehe das einer eine Klasse als Funktionssammlung nutzt, ist **mein** erster Gedanke: "Warum keine Module!?". Sprich, die Dogmatik greift da irgendwo **doch** indirekt da man mit ``class`` was andere assoziert als der Einsatzzweck für das man es dann noch gebrauchen könnte!

In diesem Kontext (Für den Gerold und sicher viele andere auch) das haben wollen würden, wäre ein ``namespace`` Super hilfreich. Damit würde es erst gar nicht zu Ideologischen Diskussionen kommen, weil man schlicht und einfach weiß ``class`` != ``namespace`` (Auch wenn die Semantik vielleicht die gleiche bleibt!) Im übrigen würde **ich es auch** nicht schlecht finden, weil es eine zusätzliche neue Qualität der Strukturierung mitbringt die **erstmal** frei von jeder ``class`` behafteten Ideologie/Dogmatik (nenne es wie du wilst) ist .

poker hat geschrieben:würde es erst gar nicht zu Ideologischen Diskussionen kommen, weil man schlicht und einfach weiß ``class`` != ``namespace`` (Auch wenn die Semantik vielleicht die gleiche bleibt!)

blackbird hat geschrieben: //EDIT: Und Gott sei Dank haben wir nicht das Ruby Modulsystem, glaubt mir, das wollt ihr nicht

blackbird hat geschrieben:

Code: Alles auswählen

import blub
blub.foo.blub()

[...]
Oder halt auch

Code: Alles auswählen

from blub.foo import blub
blub()

namespace Foo:
    def bar():
        return "bar"
    def spam():
        return "spam"

print Foo.bar()
print Foo.spam()

class Foo:
    def bar(self):
        return "bar"
    def spam(self):
        return "spam"

foo = Foo()
print foo.bar()
print foo.spam()

poker hat geschrieben:

birkenfeld hat geschrieben:

poker hat geschrieben:Das ist da doch zuviel gehacke. Dann kann man auch gleich ``class`` als namespace Nutzen. Aber dan kommen die jenigen mit ihrer "reinen" Lehre.

Ich dachte, das warst du...

Ganze Sätze Herr Birkenfeld! Also, was meinst du? Kann dir nicht folgen.

Meiner Meinung sollte man Klassen nicht als Namensräume missbrauchen.

poker hat geschrieben:EDIT3: In Ruby ist eine Datei mit Ruby Code kein Modu,l wie es in Python der Fall ist! Das muss man unterscheiden (Falls du das jetzt meintest).

• PEPs ohne Implementierung stehen immer erst mal schlechter da. Eine Implementierung à la Preprocessor ist aber keine, und taugt damit auch nichts.
• Ein generisches PEP für ein "make"-Statement ist abgelehnt worden, siehe PEP 359.
• Die ganze Thematik "ich brauche aber einen Namespace!!!1" kommt mir sowieso spanisch vor. Wenn du "a.b" willst, erstell dir ein Modul "a", und fertig. Ansonsten nimm "a_b" und gut is.

birkenfeld hat geschrieben:

• Die ganze Thematik "ich brauche aber einen Namespace!!!1" kommt mir sowieso spanisch vor. Wenn du "a.b" willst, erstell dir ein Modul "a", und fertig. Ansonsten nimm "a_b" und gut is.

birkenfeld hat geschrieben:

poker hat geschrieben:

birkenfeld hat geschrieben:

poker hat geschrieben:Das ist da doch zuviel gehacke. Dann kann man auch gleich ``class`` als namespace Nutzen. Aber dan kommen die jenigen mit ihrer "reinen" Lehre.

Ich dachte, das warst du...

Ganze Sätze Herr Birkenfeld! Also, was meinst du? Kann dir nicht folgen.

Ich zitiere dich:

Meiner Meinung sollte man Klassen nicht als Namensräume missbrauchen.

blackbird hat geschrieben: Nein. Ich meinte, dass du in Ruby nur einen Namespace hast und die Module einfach nur über den Constant-Lookup die Klassen suchen. Mit allen tollen Nebenwirkungen. Ist eigentlich JavaScript Module auf Drogen

birkenfeld hat geschrieben:Ich habe jetzt weder Zeit noch Lust, sämtliche Posts hier durchzulesen, aber mal ein paar grundsätzliche Dinge dazu:

poker hat geschrieben:Schade das ich nun sauer werden musste.

poker hat geschrieben:Für dich verständlich Ausgedrückt:

Für Kontext eins - Ja, dafür Klassen als Namensräume zu missbrauchen, wo es auch **offensichtlich** (Und das ist offensichtlich, weil Kontext zwei nicht ersichtlich; wie auch => ``class``!!) ein Modul (Was ich vorzugsweise nutze), Borg oder Singelton tut, ist mist.

Für Kontext zwei ist man an der Grenze der "reine" Lehre gestoßen und kann dafür nicht mehr als Grundlage dienen! Um vornherein die ganzen dogmatischen Diskussionen zu vermeiden, plädieren wir auf ein ``namespace``-statement -> Ein Äquivalent zu Rubys ``module``-statement. Den ``class`` weiterhin für Kontext zwei zu nutzen, führt unweigerlich immer zur gleichen Diskussion -> Modul?! ...

Verstehst du diesen kleinen aber feinen Unterscheid? Du kannst nicht einfach eine Aussage die in einem anderen Kontext gemacht wurde - und dafür vollkommen richtig ist - herausreisen und sie auf einen anderen übertragen, für den er garnicht bestimmt war und keinerlei Geltung hat, und damit Werturteilen!

Ich habe jetzt weder Zeit noch Lust, sämtliche Posts hier durchzulesen, aber mal ein paar grundsätzliche Dinge dazu:

So jetzt pass mal auf Birkenfeld! Du nimmst dir das Recht heraus läuten (konkret mir) Aussagen in den Mund zu legen, in dem du Aussagen aus dem Kontext reist und sie einem andere zuordnest, und damit zu Werturteilen, **ohne** den thread gelesen zu haben?

Weist du was das heißt? Zwei läute unterhalten sich, du kommst dazu hörst par Zeilen und labberst dann rum und legst läuten falsche Sachen in den Mund ohne den Zusammenhang zu kenne! Heftig oder?!
Weißt du was, wenn du es nicht für nötig erachtest es zu lesen steht dir auch kein Recht zu fremden läuten die Worte im Mund zu verdrehen und auch kein Werturteil!

Vielleicht sollte man das mal als Abwechslung mit dir machen?

Schade das ich nun sauer werden musste.

Leonidas hat geschrieben:@birkenfeld: Hast du eigentlich eine Strichliste, bei der du notierst wie oft du als Troll bezeichnet wurdest? Ich habe da dunkel einen sehr ähnlichen Thread in Erinnerung