klammern in datei entfernen

[seltersarmee]

Hallo liebe Gemeinde,

ich habe ein kleines Problem:
Ich erzeuge mir eine Liste, bestehen aus x,y,z, die ich in eine Datei schreiben lasse.

Code: Alles auswählen

i=1
az_p=8
liste=[]
while i<=az_p:
    y = -1
    x = y*2
    z = y*3
    liste.append ((x,y,z))
    i=i+1
f = open("PUNKTE.txt","w")
liste = map(lambda(x):str(x), liste)
for i in liste:
    f.write(i+"\n")
f.close()

Soweit so gut. Nun will ich die Datei aber als Werte-Liste für ein Programm benutzen und dieses kommt mit den Klammern nicht zurecht. Also dachte ich, dass ich das Problem in etwa so lösen könnte:

Code: Alles auswählen

WEG = open("PATH.txt","w")
data = open("PUNKTE.txt").read()
WEG.write(re.sub("("," ",data))
WEG.close()

Funktioniert aber nicht.
Um mein Problem zusammenzufassen:
Ich möchte mir eine Datei erstellen, in der ich pro Zeile einen x-, y- und z-Wert habe, die ich mir über meine Schleife definiere.
Wie mache ich soetwas am besten?
Einen schönen Abend euch!

[EyDu]

Hallo.

Das csv-Modul sollte dir hier helfen. Alternativ kannst du auch numpy benutzen, kommt ein wenig auf deine Anwendung an. Aber noch ein paar Hinweise zu deinem Code:

- Benutze richtig Namen. Bei "az_p" und "liste" weiß man doch in einer Woche schon nicht mehr, was das bedeutet.
- Du solltest hier eine for-Schleife statt einer while-Schleife benutzen. Die Anzahl der Durchläufe ist offensichtlich vorher bekannt.
- Dateien solltest du mittels with-Statement öffnen.
- ``map(lambda x: str(x), ...`` ist das selbe wie ``map(str, ...``
- Die Klammern um das Argument beim lambda gehören dort nicht hin.

[sparrow]

Moment. Wenn ich das richtig verstehe: du schreibst Daten in eine Datei und möchtest nicht, dass Klammern darin sind? Dann schreib sie doch einfach nicht hinein.

[seltersarmee]

Die klammern werden automatisch gesetzt, da (x,y,z) ein tupple ist und ich sonst die drei Werte noch nebeneinander bekomme.
Ich werde es mit dem CSV-Tool mn versuchen

[Sirius3]

Code: Alles auswählen

with open("PUNKTE.txt","w") as f:
    f.write(''.join('%s\t%s\t%s\n'%xyz for xyz in liste))

[seltersarmee]

Super, funktioniert!
Ich danke dir!!!

[sparrow]

@seltersarmee Du solltest dir ein gutes Python-Tutorial schnappen und es durcharbeiten. Das formatierte Ausgeben von Zeichenketten und das umgehen mit Listen oder Tupeln ist ziemlich fundamental was Python angeht.

Das offizielle Tutorial findest du hier: http://docs.python.org/2/tutorial/

[mutetella]

Code: Alles auswählen

''.join('%s\t%s\t%s\n'%xyz for xyz in liste)

Die Notierung finde ich sehr eigenartig. Warum funktioniert das? Sollte doch eigentlich so aussehen:

Code: Alles auswählen

''.join(['%s\t%s\t%s\n'%xyz for xyz in liste])

- Weshalb nimmt 'join' einen Formatstring als Argument, der für sich allein 'invalid syntax' ist?
- Ließe sich das mit 'format' auch nachbauen? Ich bin bisher daran gescheitert.

mutetella

[Sirius3]

Hallo mutetella,

Code: Alles auswählen

lst=['%s\t%s\t%s\n'%xyz for xyz in liste]

ist eine sogenannte List-Comprehension und berechnet jeden Listeintrag sofort.

Code: Alles auswählen

gen=('%s\t%s\t%s\n'%xyz for xyz in liste)

erzeugt einen Generator, der nach und nach die Werte mit gen.next() berechnet.
Viele built-in-Funktionen von python, die Listen erwarten kommen auch mit Generatoren
zurecht.
Natürlich kann man auch format verwenden:

Code: Alles auswählen

''.join('{0}\t{1}\t{2}\n'.format(*xyz) for xyz in liste)

Grüße
Sirius

[BlackJack]

Etwas anders formuliert: Die Funktionen erwarten keine Listen sondern ganz allgemein irgendein iterierbares Objekt. Und das trifft halt auch auf Listen zu.

Vielleicht noch mal zur Ausgangsfrage. *Das* Programm schreibt man am einfachsten so:

Code: Alles auswählen

#!/usr/bin/env python


def main():
    with open('test.txt', 'w') as points_file:
        points_file.writelines('-1, -2, -3\n' for _ in xrange(8))


if __name__ == '__main__':
    main()

[mutetella]

Der Unterschied zwischen LC und generator-Objekt ist mir schon klar... Allein die Notation finde ich eigenartig.

Das wirft ja verständlicherweise einen SyntaxError:

Code: Alles auswählen

>>> i for i in range(10)
  File "<stdin>", line 1
    i for i in range(10)
        ^
SyntaxError: invalid syntax

Korrekt muss es so notiert sein:

Code: Alles auswählen

>>> (i for i in range(10))
<generator object <genexpr> at 0x7f03649f65f0>

Warum aber kann ich etwas als Argument übergeben, das doch für sich allein nicht korrekt notiert ist:

Code: Alles auswählen

>>> list(i for i in range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Die Klammern um das 'i for i in range(10)' gehören ja zum list-Aufruf, was bleibt ist die nicht korrekte Syntax 'i for i in range(10)'. Warum muss es also nicht so aussehen:

Code: Alles auswählen

>>> list((i for i in range(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Klar, was ich meine?

mutetella

[BlackJack]

@mutetella: Weil die Entwickler von Python freundlicherweise sagen, dass man die Klammern weglassen kann, wenn der Ausdruck sowieso schon von Klammern umgeben ist.

[mutetella]

@BlackJack
Ok. Man stößt ja immer wieder mal auf den Begriff "syntactic sugar". Ist das ein Beispiel dafür?

[BlackJack]

@mutetella: Hm, IMHO nicht. Ich verbinde das mit zusätzlicher Syntax um etwas zu tun was sonst zwar auch möglich ist, aber mit der dedizierten Syntax einfacher und kürzer wird, und nicht damit das man Syntax weglassen kann.

[mutetella]

@BlackJack
Stimmt, man lässt ja was weg... also eher 'bavarian syntactic'...

[BlackJack]

@mutetella: Ein paar Beispiele für syntaktischen Zucker:

Code: Alles auswählen

ys = [f(x) for x in xs if p(x)]
# 
# Zucker für:
# 
ys = list()
for x in xs:
    if p(x):
        ys.append(f(x))

# ----

ys = (f(x) for x in xs if p(x))
# 
# Zucker für:
# 
def gf():
    for x in xs:
        if p(x):
            yield f(x)

ys = gf()

# ----

def gf():
    init()
    while True:
        if end_condition():
            break
        yield next_result()
# 
# Zucker für:
# 
class Iterator(object):
    def __init__(self):
        init()
    
    def __iter__(self):
        return self
    
    def next(self):
        if end_condition():
            raise StopIteration
        return next_result()

gf = Iterator()

# ----

with create_context() as c:
    do_something(c)
# 
# Zucker für (vereinfacht):
# 
c = create_context().__enter__()
try:
    do_something(c)
finally:
    c.__exit__()

# ----

lambda x: do_something(x)
# 
# Zucker für:
# 
def temporary_name(x):
    return do_something(x)

# ----

for x in xs:
    do_something(x)
# 
# Zucker für:
# 
xs_iterator = iter(xs)
while True:
    try:
        x = xs_iterator.next()
    except StopIteration:
        break
    do_something(x)

# ----

def f():
    do_something()
# 
# Zucker für:
# 
class F(object):
    def __call__(self):
        do_something()

f = F()

Das heisst syntaktischer Zucker weil es etwas ”Süsses” ist, was man auf die Syntax noch oben drauf ”streut” um die Sprache ”leckerer” zu machen. Aus dem Blickwinkel könnte man jetzt sagen, dass die beiden letzten Beispiele kein Zucker für ”oben drauf” sind, sondern welcher den man eigentlich als Grundzutat in der ”Sprachbackmischung” erwarten würde. Das hat aber nicht jede Sprache — Java-Programmierer mussten lange auf eine „for-each”-artige Schleife warten und im letzten Java mit dem ich zu tun hatte (Java 6) musste man für Rückruf”funktionen” immer noch Klassen mit einer Methode schreiben, die einen von der API festgelegten Namen haben musste.

[mutetella]

Ein paar Beispiele für syntaktischen Zucker

Danke für die Erklärung...

[BlackJack]

@mutetella: Ja der gehört eigentlich eher hier hin. Hab's mal verschoben.