set vs Sets Py 2.4

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Mad-Marty
User
Beiträge: 317
Registriert: Mittwoch 18. Januar 2006, 19:46

set vs Sets Py 2.4

Beitragvon Mad-Marty » Samstag 6. Januar 2007, 13:21

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
User
Beiträge: 72
Registriert: Montag 25. Dezember 2006, 05:01

Beitragvon cracki » Samstag 6. Januar 2007, 13:46

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.
...meh...
sape
User
Beiträge: 1157
Registriert: Sonntag 3. September 2006, 12:52

Beitragvon sape » Samstag 6. Januar 2007, 14:12

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.
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Samstag 6. Januar 2007, 14:41

sape hat geschrieben: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.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
sape
User
Beiträge: 1157
Registriert: Sonntag 3. September 2006, 12:52

Beitragvon sape » Samstag 6. Januar 2007, 14:57

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
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Samstag 6. Januar 2007, 15:22

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.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
sape
User
Beiträge: 1157
Registriert: Sonntag 3. September 2006, 12:52

Beitragvon sape » Samstag 6. Januar 2007, 15:40

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.
Zuletzt geändert von sape am Samstag 6. Januar 2007, 15:42, insgesamt 1-mal geändert.
BlackJack

Beitragvon BlackJack » Samstag 6. Januar 2007, 15:42

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
User
Beiträge: 1157
Registriert: Sonntag 3. September 2006, 12:52

Beitragvon sape » Samstag 6. Januar 2007, 15:44

BlackJack hat geschrieben: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

Beitragvon BlackJack » Samstag 6. Januar 2007, 15:46

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
User
Beiträge: 1157
Registriert: Sonntag 3. September 2006, 12:52

Beitragvon sape » Samstag 6. Januar 2007, 15:54

BlackJack hat geschrieben:Der gleiche Grund wie bei Listen:
[...]
Ups, stimmt ja, nur immutable werden als Key akzeptiert :D
Ehm, sorry für die Sinnlosen posts von mir :-[

lg
Benutzeravatar
Leonidas
Administrator
Beiträge: 16023
Registriert: Freitag 20. Juni 2003, 16:30
Kontaktdaten:

Beitragvon Leonidas » Samstag 6. Januar 2007, 16:12

sape hat geschrieben:
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.

sape hat geschrieben: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.
My god, it's full of CARs! | Leonidasvoice vs Modvoice
Benutzeravatar
birkenfeld
Python-Forum Veteran
Beiträge: 1603
Registriert: Montag 20. März 2006, 15:29
Wohnort: Die aufstrebende Universitätsstadt bei München

Beitragvon birkenfeld » Montag 8. Januar 2007, 23:08

Leonidas hat geschrieben:
sape hat geschrieben:
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.

sape hat geschrieben: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.
Dann lieber noch Vim 7 als Windows 7.

http://pythonic.pocoo.org/
Benutzeravatar
birkenfeld
Python-Forum Veteran
Beiträge: 1603
Registriert: Montag 20. März 2006, 15:29
Wohnort: Die aufstrebende Universitätsstadt bei München

Beitragvon birkenfeld » Montag 8. Januar 2007, 23:13

sape hat geschrieben: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 `|`.
Dann lieber noch Vim 7 als Windows 7.

http://pythonic.pocoo.org/

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder