Das deutsche Python-Forum

Das eine "get" hat mit dem anderen nichts zu tun. Guck mal hier:

http://docs.python.org/lib/typesmapping.html

Jetz bin ich bissl verwirrt

Also das get was du mir gerade geschickt hast, das kenn ich, des wollte ich hernehmen statt dem "if d2.has_key(Suchabfrage1):", aber ich merke gerade das das zweideutig geschrieben ist!
Dann, glaube ich, verstehe ich was EyDu geschrieben hat. Das heißt, wenn the_artist noch ned drinsteht schreibt er den mit rein, andernfalls schreibt er gar nichts rein, und in beiden Fällen kommt aber new_title dazu!?

Spitze!!!

Arr, ja den Code hast du richtig verstanden, nur der Interpret kam bei meinem alten Beispiel nicht dazu. Worauf ich eigentlich hinaus wollte:

Code: Alles auswählen

titles = the_dicionary.get(the_artist, [])
titles.append(new_title)
the_dictionary[the_artist] = titles

EyDu hat geschrieben:Eine LC ohne Prädikat entspricht übrigens einem "map":
Code: Alles auswählen
import string
with open('test.txt') as fh:
    data = map(string.split, fh)
    print data 

Ist mir schon klar...allerdings sind LC nicht langsamer und vor allem in solchen Fällen einfach...direkter.
Außerdem bringt map viele Neulinge dazu, es mit lambda zu nutzen, was völlig blöd wäre

Soll ich jetzt noch Rücksicht auf Neulinge nehmen und deshalb praktische Funktionen nicht nutzen

. Und wenn es um Direktheit geht, finde ich ein "map" viel sprechender. Zumindest, wenn man keine Lambda-Ausdrücke schreiben muss, das ist in einer LC kompakter.

Und jetzt bitte nicht mit dem "Zusatzimport" anfangen, das Thema hatten wir letztens doch erst

EyDu hat geschrieben:Soll ich jetzt noch Rücksicht auf Neulinge nehmen und deshalb praktische Funktionen nicht nutzen . Und wenn es um Direktheit geht, finde ich ein "map" viel sprechender. Zumindest, wenn man keine Lambda-Ausdrücke schreiben muss, das ist in einer LC kompakter.

Und jetzt bitte nicht mit dem "Zusatzimport" anfangen, das Thema hatten wir letztens doch erst

Ich find halt, wenns schon eine extra split-Methode gibt, dann sollte man die auch nutzen:

Code: Alles auswählen

>>> l = ['foo bar fooooobar', 'bar foo foobar']
>>> from itertools import imap
>>> call = lambda f: f()
>>> map(call, imap(operator.attrgetter('split'), l))
[['foo', 'bar', 'fooooobar'], ['bar', 'foo', 'foobar']]

Nich wahr?

Ps:
Bin ich froh, wenn in 2.6 endlich operator.call da ist /o\

Das ist wirklich Eleganz auf ganz hohem Niveau

Aber wenn du imap schon importierst, dann musst du es schon ausnutzen:

Code: Alles auswählen

list(imap(call, imap(operator.attrgetter('split'), l)))

EyDu hat geschrieben:Das ist wirklich Eleganz auf ganz hohem Niveau

Und auch nur etwa halb so schnell

EyDu hat geschrieben:Das ist wirklich Eleganz auf ganz hohem Niveau

Aber wenn du imap schon importierst, dann musst du es schon ausnutzen:
Code: Alles auswählen
list(imap(call, imap(operator.attrgetter('split'), l)))

Beim letzten will ich ja aber sowieso die Liste, und so spar ich mir nen Funktionsaufruf

btw:
Ich weiß, wie ineffizient das ist, daher nutze ich ja gerne LCs

Ich will LCs in Java :/

Ums mal genau zu sagen:

Code: Alles auswählen

from itertools import imap
import operator

l = ['foo bar fooooobar', 'bar foo foobar']
call = lambda f: f()

def test():
    return map(call, imap(operator.attrgetter('split'), l))
def calltest():
    return [f() for f in imap(operator.attrgetter('split'), l)]

def lctest():
    return [line.split() for line in l]
def gctest():
    return list(line.split() for line in l)

if __name__=='__main__':
    from timeit import Timer
    for func in ['test', 'calltest', 'lctest', 'gctest']:
        t = Timer("%s()" % func, "from __main__ import %s" % func)
        print "Function %s took %fs" % (func, t.timeit())

Function test took 11.511894s
Function calltest took 5.119288s
Function lctest took 3.460341s
Function gctest took 9.458675s

Ich schließe daraus, dass wir dringend operator.call in der stdlib brauchen

€dit:
http://docs.python.org/dev/library/oper ... thodcaller

\o/
damit wäre dann das Beispiel folgendermaßen:

Code: Alles auswählen

def mctest():
    return map(methodcaller('split'), l)

Das fände ich gut.

Hm, also im Moment scheint es noch einen Fehler zwischen Auslesen und ins dict schreibenzu geben, und zwar kommt nur die letzte Zeile der Textdatei auch wirklich in den dictionarys an:

Code: Alles auswählen

datei = file('F:\Test.txt','r')
daten = str(datei.read()) #nimmt den Zeilenumbruch nicht mit
datei.close()
liste = daten.split("\n") # das ist der Zeilenumbruch, fungiert als
                          # Trennungsmarke

for e in range(len(liste)):
       
    woerter = liste[e].split(" - ")

    print 'woerter:'
    print woerter
     
d1 = {woerter[0]:woerter[1]}             #w0 = Interpret / w1 = Titel
d2 = {woerter[1]:woerter[0]}

print 'd1: '
print d1
print 'd2: '
print d2

Liefert folgendes Ergebnis:

woerter:
['Linkin Park', 'No Roads Left']
woerter:
['SUM41', 'Summer']
woerter:
['Yellowcard', 'Takedown']
woerter:
['Yellowcard', 'Fighting']
d1:
{'Yellowcard': 'Fighting'}
d2:
{'Fighting': 'Yellowcard'}

Aber ich versteh ned wieso. Angesprochen wird immer das erste und das zweite Element der Liste. Ich erhalte 4 Listen, warum erreicht nur eine das dict? Ich dachte erst es liegt daran, das dict-Zeilen nicht eingerückt sind, aber Fehlanzeige. Kann es sein, das ein dictionary-Einträge jedesmal überschrieben werden?

EDIT: Ach wie geil, ich habs gelöst!!

Scheint wirklich jedes mal überschirben zu werden, denn aufgrund dieser Annahme hab ich mir überlegt ich erstelle 2 leere dictionaries und füge dann nach und anch die Werte hinzu. Und voila, es klappt!!

Code: Alles auswählen

d1 = {}
d2 = {}
for e in range(len(liste)):
       
    woerter = liste[e].split(" - ")

    print 'woerter:'
    print woerter
     
    d1[woerter[0]] = woerter[1]          #w0 = Interpret / w1 = Titel
    d2[woerter[1]] = woerter[0]

woerter:
['Linkin Park', 'No Roads Left']
woerter:
['SUM41', 'Summer']
woerter:
['Yellowcard', 'Takedown']
woerter:
['Yellowcard', 'Fighting']
d1:
{'Linkin Park': 'No Roads Left', 'SUM41': 'Summer', 'Yellowcard': 'Fighting'}
d2:
{'Summer': 'SUM41', 'Fighting': 'Yellowcard', 'Takedown': 'Yellowcard', 'No Roads Left': 'Linkin Park'}

Zef*x, jetzt fehlt bei d1 aber wieder ein Element...

Ich habe dir die Lösung in einer meine vorigen Posts doch schon längst genannt. Benutze Listen bei den Werte. Im Moment überschreibst du einfach immer. "=" ist ein ZUWEISUNG und keine magisches Anhängen.

Und benutze doch bitte "readlines" und implementiere es nicht selber. Die überschüssigen Newlines wirst du mit der "strip"-Methode los. Unter Windows zum Beispiel funktioniert dein Ansatz nämlich nicht korret, da das "carriage return" erhalten bleibt.

Code: Alles auswählen

pairs = {}
for line in liste:
    artist, title = line.split(' - ')
    # wenn artist noch nicht im dict ist,
    # lege eine neue liste an und hänge dort title an
    # wenn er schon im dict ist -> hänge an
    pairs[artist] = pairs.get(artist, []) + [title]

# oder hier, etwas einfacher:
from collections import defaultdict
pairs = defaultdict(list)
for line in liste:
    artist, title = line.split(' - ')
    pairs[artist].append(title)

So also würde man das wohl tun und so hab ich sowas schon öfters getan...

@ EyDu: Ja, ich weiß das du mir nen Lösungsvorschlag schonmal geliefert hast, allerdings hatte ich dessen "Wirkung" nicht komplett verstanden und hab ihn deshalb nicht übernommen. Weil es bringt mich ja ned weiter wenn ich den "selbstgeschrieben" Code ned verstanden habe

Und nochmal nachfragen wollte ich auch ned

"readlines" hatte ich im ersten Codeentwurf drin, allerdings hat mir das jemand (weiß leider nicht mehr wer) mir read ersetzt, weil read wohl die Teilenumbrüche nicht mitnimmt.

@ audax: Mir wär dein erster Vorschlag lieber, weil ich erstmal versuchen möchte mit den "Standarts" zurechtzukommen bevor ich mich auf die Importierung von "Addons" stürze

Ich wusste gar ned das ne Doppelzuweisung wie in Zeile 4 bei sowas auch funktioniert. Heißt das du bringst in einer Zeile unter, das artist immer das vor dem Trennzeichen und title immer das dahinter ist?!

Nochmal vielen Dank für die Mühe und die Geduld...

Code: Alles auswählen

In [1]: foo = range(5)

In [2]: print foo
[0, 1, 2, 3, 4]

In [3]: zero, one, two, three, four = foo

In [4]: print zero
0

In [5]: print one
1

Siehe:
Tutorial[/url]

Und man kann es fast noch lesen:

Code: Alles auswählen

>>> from operator import itemgetter
>>> from itertools import groupby
>>> l = [(1,"a"), (2,"b"), (1,"c")]
>>> dict((k, map(itemgetter(1), g)) for k, g in groupby(sorted(l), itemgetter(0)))
{1: ['a', 'c'], 2: ['b']}
>>>

hallo,

ich wollt nochmal kurz was zu dem 'methodcaller' sagen:

kann man da nicht auch einfach 'exec(string)' nehmen?

mfg
roschi

Nein, weil String-Code auszuführen zu Security und Maintainability-Nightmares führt.

hallo,

naja, wenn du meinst.
ich hatte zwar noch keine probleme damit. aber ich habe es auch noch nicht SO OFT genutzt.

mfg
roschi

Das meint nicht nur Leonidas. Es gibt eigentlich so gut wie immer eine Alternative zu ``exec``, die direkter, nicht so fehleranfällig, und in der Regel schneller ist. Zusätzlich zu den schon genannten Problemen wird bei ``exec`` jedesmal der Compiler angeworfen um das Stückchen selbst gebastelten Quelltext in Bytecode zu übersetzen.

``exec`` und auch `eval()` werden normalerweise von Leuten benutzt, die die Sprache noch nicht beherrschen und dafür einen unsaubere Abkürzung brauchen.

Das deutsche Python-Forum

Wort aus Text auslesen.