set vs Sets Py 2.4

[Mad-Marty]

Hi,

was ich mich schon länger frage, wozu ist noch das Sets modul dabei,
die built-in set's können doch das gleiche, oder hab ich da was übersehen ?

Mal abgesehen davon das das modul Sets in python implementiert ist und wahrscheinlich langsamer ist als das built-in ....

[cracki]

kompatibilitaet.


die machen sich alle in die hosen, wenn von einer version auf die andere irgendwelcher python code nicht mehr geht. deswegen werden altlasten ueber ein paar versionen mitgeschleppt.

in ein paar versionen gibts auch das sets modul nicht mehr.

[sape]

Jepp.

Code: Alles auswählen

test = set([1,2,3])

for elem in dir(test):
    if not elem.startswith(('_','__')):
        print elem

Code: Alles auswählen

add
clear
copy
difference
difference_update
discard
intersection
intersection_update
issubset
issuperset
pop
remove
symmetric_difference
symmetric_difference_update
union
update

...

Code: Alles auswählen

import sets

test = sets.Set([1,2,3])

for elem in dir(test):
    if not elem.startswith(('_','__')):
        print elem

Code: Alles auswählen

add
clear
copy
difference
difference_update
discard
intersection
intersection_update
issubset
issuperset
pop
remove
symmetric_difference
symmetric_difference_update
union
union_update
update

...

Das Set Modul bietet einmal ``Set``und ``ImmutableSet``. ImmutableSet ist nicht veränderlich:

Code: Alles auswählen

import sets

test = sets.ImmutableSet([1,2,3])

for elem in dir(test):
    if not elem.startswith(('_','__')):
        print elem

Code: Alles auswählen

copy
difference
intersection
issubset
issuperset
symmetric_difference
union

http://docs.python.org/lib/set-objects.html
http://www.python.org/doc/current/tut/n ... 0000000000

FAZIT:
ImmutableSet ist Sinnlos ``sets.Set`` ist gleich ``set``. Von Daher, das Bulltin-``set`` nutzen und das Modul ``Sets`` ignorieren, das ehe irgendwann, wie cracki schon meinte, wegkommt.

lg
sape

EDIT: Link und Text korrigiert.

[Leonidas]

FAZIT:
ImmutableSet ist Sinnlos ``sets.Set`` ist gleich ``set``.

Nein. ``sets.Set`` wurde einfach von ``set`` obsolet gemacht, ``ImmutableSet`` wurde von ``frozenset`` obsolet gemacht. So einfach ist das.

Man kann seinen Code aber auch Python 2.4 kompatibel machen:

Code: Alles auswählen

try:
    set()
except NameError:
    import sets
    set = sets.Set
    frozenset = sets.ImmutableSet

Und nun kann man sowohl in Python 2.4 als auch 2.5 den gleichen Code nutzen. Nur ist er in Python 2.5 schneller.

[sape]

Nein. ``sets.Set`` wurde einfach von ``set`` obsolet gemacht,

Jepp

``ImmutableSet`` wurde von ``frozenset`` obsolet gemacht

Das wusste ich noch nicht. Jetzt wo ich mir aber zu ``frozenset`` den Text nochmal durchgelesen habe, erinnert das Verhalten doch stakt an ``ImmutableSet`` ^^

...

Wozu braucht man eigentlich eine Immutable Version von ``set`` Mir fällt da kein Szenario ein wo ich das jemals gebraucht habe Oder ist es ein wenig schneller als ``set``?. Weil dann könnte man das doch gebrauchen und das "Updaten" würde sich über ``tuple`` gestalten ^^ ->

Code: Alles auswählen

x = frozenset([1, 2, 3])
print x
x = frozenset(tuple(x) + tuple([1, 2, 3, 4]))
print x

Wobei ich glaube das es dann doch langsamer ist (wegen dem Konvert) als wenn man gleich ``set`` nutzt?

Code: Alles auswählen

x = set([1, 2, 3])
x.update([1,2,3,4])
print x

Was ist schneller? Ansonsten sehe ich den Sinn nicht von einem immutable set.

lg
sape

[Leonidas]

Frozenset hat den gleichen Sinn einem Set gegenüber wie ein Tupel gegenüber einer Liste.
Manchmal will man eben Mengen darstellen, die sich nicht ändern lassen sollen.

[sape]

Frozenset hat den gleichen Sinn einem Set gegenüber wie ein Tupel gegenüber einer Liste.

Naja, ganz so ist es nicht.

Mit ``+`` kann man mehrer ``tuple``s Zusammenfügen:

Code: Alles auswählen

x = tuple([1,2,3,4,5,6])
x += tuple(['a', 'b', 'c'])
print x

In letzter Zeit verwende ich mehr ``tuple``s als ``list``, wenn es nur um einen "rohen" Container brauche (meist Temporär). Eben weil es Speicherschonend und extrem schnell ist.

Mit ``frozenset`` ist so eine Kontatktion mit ``+`` nicht`möglich ohne den Umweg eines ``tuples``. Daher sehe ich den Sinn nicht. Der Konvert ins ``tuple`` Kostet auch Zeit.

Code: Alles auswählen

x = frozenset([1, 2, 3])
x = frozenset(tuple(x) + tuple([1, 2, 3, 4]))

Sowas ist ja nicht möglich:

Code: Alles auswählen

x = frozenset([1, 2, 3])
x = x + frozenset([1, 2, 3, 4])

Code: Alles auswählen

x = frozenset([1, 2, 3])
x += frozenset([1, 2, 3, 4])

Code: Alles auswählen

TypeError: unsupported operand type(s) for +=: 'frozenset' and 'frozenset'

Von daher, hinkt der Vergleich von dir, da ein ``tuple`` diesbezüglich doch mächtiger ist -> Es ist zwar immutable, aber man merkt es nicht wirklich als benutzer im Gegensatz zu ``frozenset``.

anchmal will man eben Mengen darstellen, die sich nicht ändern lassen sollen.

Naja, dann ändert man das Objekt das vom Typ``set`` ist eben nicht. Bei "Konstanten" hat man sich ja auch darauf geeinigt das alles was groß geschrieben ist eine Konstanten ist und man die nicht ändert, obwohl es eigentlich keine Konstanten ist, da Python sowas nicht kennt. Daher ist das nicht wirklich ein Argument das für ``frozenset`` spricht.

lg

EDIT: Korrektur.

[BlackJack]

Vor allem könnte man mal eine Menge in einer Menge speichern oder in einem Dictionary als Schlüssel verwenden wollen. Dann braucht man das `frozenset()`.

[sape]

Vor allem könnte man mal eine Menge in einer Menge speichern oder in einem Dictionary als Schlüssel verwenden wollen. Dann braucht man das `frozenset()`.

Warum? Ist das mit einem ``set`` nicht möglich?

[BlackJack]

Der gleiche Grund wie bei Listen:

Code: Alles auswählen

In [9]: a = set((1,2,3))

In [10]: { a: 'test' }
---------------------------------------------------------------------------
exceptions.TypeError           Traceback (most recent call last)

/home/marc/<ipython console>

TypeError: set objects are unhashable

[sape]

Der gleiche Grund wie bei Listen:
[...]

Ups, stimmt ja, nur immutable werden als Key akzeptiert
Ehm, sorry für die Sinnlosen posts von mir :-[

lg

[Leonidas]

Frozenset hat den gleichen Sinn einem Set gegenüber wie ein Tupel gegenüber einer Liste.

Naja, ganz so ist es nicht.

Mit ``+`` kann man mehrer ``tuple``s Zusammenfügen:

Code: Alles auswählen

x = tuple([1,2,3,4,5,6])
x += tuple(['a', 'b', 'c'])
print x

Ja, zu einem neuen Tupel (weil du += und nicht + verwendest). Geht mit

Code: Alles auswählen

x = frozenset((1, 2))
x = x.union(frozenset((3, 4))
print x

ebenso.

Von daher, hinkt der Vergleich von dir, da ein ``tuple`` diesbezüglich doch mächtiger ist -> Es ist zwar immutable, aber man merkt es nicht wirklich als benutzer im Gegensatz zu ``frozenset``.

Es besitzt keine __add__/__radd__ Methode: macht aber nur sinn wenn man zwei Frozensets zusammennehmen will. Und um solche Sets zu erstellen, braucht man sowieso erstmal eine Liste oder ein Tupel. Sets und Tupel zu addieren ist ja unlogisch.

[birkenfeld]

Frozenset hat den gleichen Sinn einem Set gegenüber wie ein Tupel gegenüber einer Liste.

Naja, ganz so ist es nicht.

Mit ``+`` kann man mehrer ``tuple``s Zusammenfügen:

Code: Alles auswählen

x = tuple([1,2,3,4,5,6])
x += tuple(['a', 'b', 'c'])
print x

Ja, zu einem neuen Tupel (weil du += und nicht + verwendest). Geht mit

Code: Alles auswählen

x = frozenset((1, 2))
x = x.union(frozenset((3, 4))
print x

ebenso.

Von daher, hinkt der Vergleich von dir, da ein ``tuple`` diesbezüglich doch mächtiger ist -> Es ist zwar immutable, aber man merkt es nicht wirklich als benutzer im Gegensatz zu ``frozenset``.

Es besitzt keine __add__/__radd__ Methode: macht aber nur sinn wenn man zwei Frozensets zusammennehmen will. Und um solche Sets zu erstellen, braucht man sowieso erstmal eine Liste oder ein Tupel. Sets und Tupel zu addieren ist ja unlogisch.

Auch nicht ganz richtig: Die entsprechende Operation für Sets heißt `|`. Auch für normale Sets gibt es keinen `+`-Operator. `|=` funktioniert dagegen mit Sets und Frozensets gleich gut.

[birkenfeld]

In letzter Zeit verwende ich mehr ``tuple``s als ``list``, wenn es nur um einen "rohen" Container brauche (meist Temporär). Eben weil es Speicherschonend und extrem schnell ist.

Inwiefern "schnell"?

Mit ``frozenset`` ist so eine Kontatktion mit ``+`` nicht`möglich ohne den Umweg eines ``tuples``. Daher sehe ich den Sinn nicht. Der Konvert ins ``tuple`` Kostet auch Zeit.

Wie schon geschrieben, die entsprechende Operation für frozensets ist `|`.