lehrzeichen hinter print abschalten

[Chimera]

Guten Tag,

da ich neu hier bin erst mal ein Herzliches Hallo an alle.
Ich habe schon mit der sufu und google gearbeitet aber bin leider nicht zum Ziel gekommen. Entweder ist die Lösung so einfach oder niemand hatte bisher ein Problem mit dem Lehrzeichen hinter dem Print.

Nun zur genauen Schilderung.
Wenn ich folgendes mache:

Code: Alles auswählen

i=1
j=2
print i,j

dann bekomme ich:

Code: Alles auswählen

1 2

Ich habe ein Problem mit dem Lehrzeichen zwischen den zwei Bildschirmausgaben.
Gibt es einen Befehl oder eine Möglichkeit dies beim arbeiten mit der Konsole abzuschalten?

Vielen dank im Vorraus an jeden der sich zur lößung meines kleinen Problems beteiligt.

Gruß an alle, Alex

[jbs]

Du kannst direkt über sys.stdout gehen.

[nomnom]

Code: Alles auswählen

Python 2.6.6 (r266:84292, Sep 15 2010, 15:52:39) 
[GCC 4.4.5] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> i = 1
>>> j = 2
>>> print "{0}{1}".format(i, j)
12
>>> 

[nomnom]

Du kannst direkt über sys.stdout gehen.

So ein Aufwasch, nur dafür?

Eine Frage: Wie geht das?

EDIT:
Also das hab ich getestet:

Code: Alles auswählen

>>> import sys
>>> with open(sys.stdout, 'w') as f:
...     f.write('hi')

Funktioniert aber nicht:

Code: Alles auswählen

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: coercing to Unicode: need string or buffer, file found

EDIT #2:
Hm so auch nicht (ohne Error):

Code: Alles auswählen

>>> with open(str(sys.stdout), 'w') as f:
...     f.write('hi')
... 

[BlackJack]

@nomnom: Schau Dir mal an was `sys.stdout` für einen Typ hat.

[nomnom]

@nomnom: Schau Dir mal an was `sys.stdout` für einen Typ hat.

Oh:

Code: Alles auswählen

<open file '<stdout>', mode 'w' at 0xb74e9078>

Schön doof von mir Danke BlackJack

[Chimera]

Hallo,

wow die antworten sind ja mal Hammer und waren total schnell.
Damit habe ich gar nicht gerechnet, Entschuldigung dass ich mich erst so spät wieder melde.
Ich bin gerade für ein Jahr in Südafrika und habe daher nicht so häufig Internet.
Aber da ich jetzt weiß dass hier die Antworten verdammt schnell kommen, werde ich nun öfters in das Internet gehen.

Code: Alles auswählen

>>> with open(str(sys.stdout), 'w') as f:
...     f.write('hi')
... 

Diese Ausgabe habe ich garnicht verstanden, was macht denn da der Befehl?
Also für was ist das with, und das open und das w und warum as f?

Ich habe auch einmal nach

Code: Alles auswählen

sys.stdout

gesucht aber finde keine wirkliche Anleitung wie man damit arbeitet.
Wie kann ich denn vorgehen wenn ich absolut nicht weiß wofür ein Befehlt ist und wie man den Anwendet?
Also gibt es dafür eine Funktion in Python welche mir dann Zeigt was input und output werte sind oder ähnliches?

Vielen Dank für diese super Unterstützung,
dies ist echt ein geniales Forum.

Gruß alex

[Barabbas]

Hallo Alex,

für den konkreten Zweck kannst du sys.stdout erstmal vergessen. Das benötigt man im Alltag eher selten. Eine mögliche Lösung wurde dir ja bereits genannt:

Code: Alles auswählen

>>> x = "Hallo"
>>> y = "Welt"
>>> print "{0}{1}".format(x, y)
HalloWelt

Hier gibt es einige Beispiele dazu.

Anders gesagt: Du willst nicht wissen, wie man das "Leerzeichen wegbekommt", sondern wie man Zeichenketten nach Wunsch formatiert.

[Chimera]

@Barabbas: Danke für die schnelle Antwort.
Ich habe also die ganze Zeit nach dem falschen Begriff gesucht.

Ich habe mir nun überlegt dass ich euch einfach mein Projekt schildere und warum ich das Lehrzeichen weg haben möchte:

Ich habe es jetzt einmal anderst gelöst aber das ist keine endgültige Lösung da ich viel zu viele Verzweigungen dafür benötige.

Code: Alles auswählen

# -*- coding: utf-8 -*-

#####################################################################################################
#***************************************************************************************************#
#**###############################################################################################**#
#**#                                                                                             #**#
#**#    Programm von Alexander *******                                                           #**#
#**#    Dieses Programm hat folgende Aufgabe:                                                    #**#
#**#    Ping Pong oder wie das Spiel auch immer heißt                                            #**#
#**#                                                                                             #**#    
#**#    Version:    V 1.00                                                                       #**#
#**#                                                                                             #**#                
#**#    Geschrieben von 02.11.2010 bis DD.MM.JJJJ in Afrika                                      #**#
#**#                                                                                             #**#
#**###############################################################################################**#
#***************************************************************************************************#
#####################################################################################################


#####################################################################################################
#**************************************   Funktionen        ****************************************#

def feld(y1,y2,bx,by,fx,fy,hs1,hs2):
    print "\n"*30    
    print "#"*fx
    for i in range(fy-2):
        if i>=(y1-1) and i<=((y1-1)+(hs1-1)):    #Linker Schlitten
            print "|",
        else:
            print " ",
        if i==(by-1) and bx==2:                   #Ball
            print "*"," "*(fx-bx-4),
        elif i==(by-1) and bx==(fx-3):      
            print " "*(bx-3),"*",
        elif i==(by-1) and bx!=2 and bx!=(fx-3):
                print " "*(bx-3),"*"," "*(fx-bx-4),
        else:
            print " "*(fx-4),
        if i>=(y2-1) and i<=((y2-1)+(hs2-1)):    #Recher Schlitten
            print "|"
        else:
            print " "
    print "#"*fx
#**************************************   Ende Funktionen   ****************************************#
#####################################################################################################

fx=50    #feldbreite in x richtung
fy=20    #feldbreite in y richtung

y1 = 1    #Position schiltten eins
y2 = 6    #Position schlitten zwei
bx = 47    #Position ball in x-richtung
by = 7    #Position ball in y-richtung

hs1 = 5    #höhe schlitten eins
hs2 = 5    #höhe schlitten zwei


feld(y1,y2,bx,by,fx,fy,hs1,hs2)

Ich weiß leider nicht mehr den Namen dieses alten Spieles aber ich habe mir überlegt dies einfach mal zu programmieren um ein bisschen in das ganze hinein zu kommen.

So sieht die Ausgabe dann aus:

Code: Alles auswählen

##################################################
|                                                 
|                                                 
|                                                 
|                                                 
|                                                 
                                                 |
                                               * |
                                                 |
                                                 |
                                                 |
                                                  
                                                  
                                                  
                                                  
                                                  
                                                  
                                                  
                                                  
##################################################

Dies ist auch nur die Ausgabe, über die Verarbeitung des ganzen habe ich mir schon ein paar kleine Gedanken gemacht aber mich noch nicht wirklich damit beschäftigt.
Erst einmal muss die Ausgabe des ganzen Funktionieren und dann kann ich mir Gedanken über das Innere machen.

Vielleicht nochmal zur Erklärung:
Mein Nullpunkt ist in der Oberen linken Ecke.
Ich baue das Feld immer wieder mit den aktuellen Koordinaten des Balles und den neuen Koordinaten der Schlitten auf.

Sobald der Ball an dem Schlitten vorbei kommt hat der Spieler verloren.

Ich weiß auch noch nicht wie man die Seite neu aufbaut daher habe ich das

Code: Alles auswählen

print "/n"*30

Um den Bildschirm auf eine etwas unkonventionelle Art zu säubern.

Ich weiß das mein Quellcode noch nicht sehr gut ist, aber ich habe ja auch noch 10 Monate um das Ganze zu verbessern.

Gruß an alle
Alexander

[BlackJack]

@Chimera: ``with`` und `open()` findest Du in der Dokumentation erklärt. Den Typ von einem Objekt erfährst Du mit `type()`:

Code: Alles auswählen

In [446]: import sys

In [447]: type(sys.stdout)
Out[447]: <type 'file'>

Und was `file`-Exemplare für Methoden haben und was die machen, steht auch wieder in der Dokumentation.

[BlackJack]

@Chimera: Wenn Du es nicht so kompliziert mit den ``if``-Abfragen haben möchtest, kannst Du auch einfach eine Liste erstellen, die 20 Listen enthält, die jeweils 50 Leerzeichen als Elemente enthalten. Da kannst Du dann an den entsprechenden Koordinaten die Zeichen für deine Spielelemente einfach eintragen. Dann die inneren Listen zu Zeichenketten zusammenfügen, und diese Zeichenketten dann zu einer grossen zusammenfügen, wobei die einzelnen Zeichenketten durch '\n' getrennt werden. Und schon hast Du ein ganzes Feld.

Bei Deiner jetzigen Lösung könntest Du `i` auch von 1 bis ``fy - 2`` laufen lassen. Dann sparst Du im Folgenden einige ``- 1`` ein. Wobei ich übrigens nicht ganz sicher bin, ob Du wirklich ``- 2`` beim Endwert meintest!?

Bei den ``if``-Abfragen könntest Du einige verknüpfte Bedingungen einfacher schreiben. Python kann Operatoren "verketten". `a op1 b op2 c` ist äquivalent zu `a op1 b and b op2 c`, wobei `op1` und `op2` beliebige binäre logische Operatoren sind.

Der Quelltext auf Modulebene sollte in einer Funktion verschwinden. Das macht das Programm übersichtlicher, verringert die Gefahr, dass in Funktionen "globale" Werte benutzt werden, und mit folgendem Idiom kann man das Modul dann auch als solches importieren, ohne dass das Programm losläuft:

Code: Alles auswählen

def main():
    # Der Code auf Modulebene...


if __name__ == '__main__':
    main()

Zusammengehörige Werte könntest Du zu Tupeln (und später eigenen Datentypen (Klassen)) zusammenfassen und ihnen vernünftige Namen geben. Wenn man etwas durch einen sprechenden Namen ausdrücken kann, sollte man das einem Kommentar vorziehen.

Code: Alles auswählen

    feld_dimensionen = (50, 20)
    schlitten = (1, 6, 1)     # Position und Höhe
    ball = (47, 7)

Wenn man an die Werte dann herankommen möchte, sollte man in der Regel "tupel unpacking" einem Indexzugriff vorziehen, weil man sonst unverständliche "magische" Zahlen, statt sprechender Bezeichner hat.

Code: Alles auswählen

    ball_x, ball_y = ball
    feld[ball_y][ball_x] = '*'
    
    # statt
    
    feld[ball[1]][ball[0]] = '*'
    
    # später mit eigenen Datentypen dann
    
    feld[ball.y][ball.x]

Ich habe die verschachtelte Liste `feld` genannt. Du hast die Funktion so genannt -- bessere Namen für Funktionen und Methoden sind Verben, die Tätigkeiten beschreiben, statt Namen für Dinge. Funktionen tun etwas. ``zeichne_feld()` wäre zum Beispiel ein besserer Name.

Ansonsten noch ein paar Formatierungshinweise: Zeilen sollten nicht länger as 80 Zeichen sein, und vor und nach Operatoren und nach Kommata sollte man jeweils ein Leerzeichen setzen. Leerzeichen sollten auch um Zuweisungen ausserhalb von Argumentlisten stehen. Das erhöht die Lesbarkeit.

Zuguter Letzt möchte ich Dich noch ein wenig bei diesem Projekt bremsen. Du solltest Dich mal um die Benutzereingabe kümmern bevor Du mit etwas anderem weitermachst. Das ist nämlich plattformübergreifend nicht einfach hinzubekommen.

[Chimera]

@BlackJack: Vielen Dank für die vielen Hinweise, da muss ich noch eeeeiniges üben.
Ich muss mir das Ganze noch ein paar mal durchlesen bevor ich verstanden habe was du dort alles an neuem erwähnt hast. Vielen dank für die Zeit und Mühe welche du in die Antwort gesteckt hast.
Ich drucke mir das gleich einmal aus und versuche es zu verstehen.

Ihr seid mir echt eine super Hilfe bei der Einarbeitung in diese Programmiersprache.
Vielen Dank,

Gruß alex

[Chimera]

Hallo, und vielen dank für eure bisherige Hilfe.
Eure Tipps sind echt genial.
@BlackJack: Ich habe es jetzt mal versucht so zu Programmieren wie du gesagt hast, das mit dem:

Code: Alles auswählen

def main():
    # Der Code auf Modulebene...


if __name__ == '__main__':
    main()

Hat nicht so ganz funktioniert da kommt immer eine Fehlermeldung wenn ich mein ganzes Programm da rein packe.

Hier ist mein momentanes Programm, Ich glaube das ich dort noch sehr umständlich gearbeitet habe beim auffüllen der Listen mit Lehrzeichen.
Vielleicht hat jemand eine bessere und schnellere Lösung für das?

Code: Alles auswählen

# -*- coding: utf-8 -*-

#####################################################################################################
#**************************************   Funktionen        ****************************************#
def zeichne_feld(feld_dimensionen, schlitten, ball):
    feld_groesse = []
    for i in range(feld_dimensionen[1]):
        feld_groesse.append(list(feld_dimensionen[0]*" "))
    
    #ab hier verändern des inhaltes von feld_groesse
    feld_groesse[5][5] = "*"
    for t in range (feld_dimensionen[0]):
        feld_groesse[0][t] = "#"
        feld_groesse[feld_dimensionen[1]-1][t] = "#"

    
    
    #ende zum veränder des inhaltes
    feld_druck = ""
    for j in range(feld_dimensionen[1]):
        for k in range(feld_dimensionen[0]):
            feld_druck = feld_druck + str(feld_groesse[j][k])
        feld_druck = feld_druck + "\n"
        
    return feld_druck
    
#**************************************   Ende Funktionen   ****************************************#
#####################################################################################################
feld_dimensionen = (50,20)    #Feld breite, Feld höhe
schlitten = (1,1,5)            #position Schlitten eins, position Schlitten zwei, höhe der schlitten
ball = (5,5)                    #Ball y-Richutng, Ball x-Richtung

print zeichne_feld (feld_dimensionen, schlitten, ball)

Was mir auch noch Probleme macht, was ist der Unterschied zwischen

Code: Alles auswählen

 feld_groesse.append()

und

Code: Alles auswählen

 feld_extend()

Meinem Buch nach haben beide die gleiche Funktion, es funktionierte jedoch nicht mit .extend() nur mit .append() ging es.

Und weiß vielleicht jemand den Befehl um den Bildschirm zu reinigen?
In c++ war es

Code: Alles auswählen

clrscr()

wie heißt der Befehl in Python?
Das mit den 30 mal return gefällt mir irgendwie nicht so ganz.

Vielen dank nochmals für eure bisherige Hilfe, ihr habt mir echt schon sehr weiter geholfen und die neue Methode um das Feld aufzubauen gefällt mir schon viel besser.

Gruß Alex

[Hyperion]

Hier mal ein Beispiel aus einer Python-Shell bezüglich append und extend:

Code: Alles auswählen

In [66]: l = list()

In [67]: ?l.append
Type:           builtin_function_or_method
Base Class:     <type 'builtin_function_or_method'>
String Form:    <built-in method append of list object at 0xa2c8d4c>
Namespace:      Interactive
Docstring:
    L.append(object) -- append object to end                                                                 


In [68]: ?l.extend
Type:           builtin_function_or_method
Base Class:     <type 'builtin_function_or_method'>
String Form:    <built-in method extend of list object at 0xa2c8d4c>
Namespace:      Interactive
Docstring:
    L.extend(iterable) -- extend list by appending elements from the iterable                                


In [69]: l = range(4)

In [70]: l
Out[70]: [0, 1, 2, 3]

In [71]: l.append(1)

In [72]: l
Out[72]: [0, 1, 2, 3, 1]

In [73]: l.append([1, 2])

In [74]: l
Out[74]: [0, 1, 2, 3, 1, [1, 2]]

In [75]: l.pop()
Out[75]: [1, 2]

In [76]: l
Out[76]: [0, 1, 2, 3, 1]

In [77]: l.extend([1, 2])

In [78]: l
Out[78]: [0, 1, 2, 3, 1, 1, 2]

Wie schon in der Hilfe erwähnt, hängt ``append`` einfach das gegebene Objekt an das Ende der Liste. mit ``extend`` hingegen werden die einzelnen Objekte eines ``Iterables`` an die Liste angehängt.

Neben Deinem Buch (welches ist es denn? Mir schwant irgend wie, dass es sich um das OpenBook handeln könnte ) solltest Du auf jeden Fall immer die offizielle Doku im Browser offen haben und eben auch DInge in einer Shell testen.

[/me]

Hat nicht so ganz funktioniert da kommt immer eine Fehlermeldung wenn ich mein ganzes Programm da rein packe.

Bitte gib immer die exakte Fehlermeldung (via Copy & Paste) an, denn sonst stochert man beim Versuch zu helfen nur im Nebel.

Und noch ein Hinweis: Solltest du bei Google nach dem Thema suchen, dann hilft es, wenn die Suchbegriffe korrekt sind. Es heißt "Leerzeichen" und nicht "Lehrzeichen".

[Xynon1]

Quatsch das heißt "whitespace"

[Chimera]

@Hyperion:

Wie schon in der Hilfe erwähnt, hängt ``append`` einfach das gegebene Objekt an das Ende der Liste. mit ``extend`` hingegen werden die einzelnen Objekte eines ``Iterables`` an die Liste angehängt.

Neben Deinem Buch (welches ist es denn? Mir schwant irgend wie, dass es sich um das OpenBook handeln könnte ) solltest Du auf jeden Fall immer die offizielle Doku im Browser offen haben und eben auch DInge in einer Shell testen.

Vielen Dank für die Erklärung, aber was ist ein ``Iterables``?
Wo finde ich denn die Offizielle Doku hast du vielleicht einen Link?
Mein Buch heißt "Objektorientierte Programmierung mit Python von Michael Weigend, es ist jedoch auch von 2006, habe es mir schon vor langem gekauft.
http://www.amazon.de/Objektorientierte- ... 762&sr=1-2

@/me: Das ist mein Programm Text mit dem eingefügten def main:

Code: Alles auswählen

#####################################################################################################
#**************************************   Funktionen        ****************************************#
def main():
    def zeichne_feld(feld_dimensionen, schlitten, ball):
        feld_groesse = []
        for i in range(feld_dimensionen[1]):
            feld_groesse.append(list(feld_dimensionen[0]*" "))
        
        #ab hier verändern des inhaltes von feld_groesse
        feld_groesse[5][5] = "*"
        for t in range (feld_dimensionen[0]):
            feld_groesse[0][t] = "#"
            feld_groesse[feld_dimensionen[1]-1][t] = "#"

        
        
        #ende zum veränder des inhaltes
        feld_druck = ""
        for j in range(feld_dimensionen[1]):
            for k in range(feld_dimensionen[0]):
                feld_druck = feld_druck + str(feld_groesse[j][k])
            feld_druck = feld_druck + "\n"
            
        return feld_druck
    
#**************************************   Ende Funktionen   ****************************************#
#####################################################################################################
feld_dimensionen = (50,20)    #Feld breite, Feld höhe
schlitten = (1,1,5)            #position Schlitten eins, position Schlitten zwei, höhe der schlitten
ball = (5,5)                    #Ball y-Richutng, Ball x-Richtung

if __name__ == '__main__':
    main()
    print zeichne_feld (feld_dimensionen, schlitten, ball)

Und dies ist die Fehlermeldung:

Code: Alles auswählen

Traceback (most recent call last):
  File "/home/chimera/Python/ernste Programme/Ballspiel2.py", line 53, in <module>
    print zeichne_feld (feld_dimensionen, schlitten, ball)
NameError: name 'zeichne_feld' is not defined

Und nunja, ich weiß dass meine Rechtschreibung nicht gerade ideal ist aber finde es unglaublich genial dass es erst jetzt angesprochen wurde. Normaleiweiße sind die erste vier Antworten auf eine Frage immer erst mal auf irgendwelche Schreibfehler bezogen. Was mich in der Vergangenheit total genervt hat, aber hier finde ich es echt nett von der Gemeinde dass man es so lange toleriert hat und du hast es ja nur richtig gestellt dass ich bei der Suche auch nach dem richtigen begriff schaue und nicht um mich bloß zu stellen (hoffe ich). Somit finde ich es echt genial, danke an alle für die Zurückhaltung dummer Kommentare und die super Antworten.

@Xynon1:

Quatsch das heißt "whitespace"

Danke, ich dachte immer es heißt nur space. Wieder etwas gelernt.

Gruß an alle
Alexander

[BlackJack]

@Chimera: Ein "iterable" ist ein Objekt für das man mit der `iter()`-Funktion einen Iterator erstellen kann. Und das ist ein Objekt mit einer `next()`-Methode die bei jedem Aufruf ein Element aus dem "iterable" liefert und zum Schluss eine `StopIteration`-Ausnahme auslöst.

Code: Alles auswählen

In [450]: a = [1, 2, 3]

In [451]: it = iter(a)

In [452]: it.next()
Out[452]: 1

In [453]: it.next()
Out[453]: 2

In [454]: it.next()
Out[454]: 3

In [455]: it.next()
---------------------------------------------------------------------------
<type 'exceptions.StopIteration'>         Traceback (most recent call last)

/home/bj/<ipython console> in <module>()

<type 'exceptions.StopIteration'>:

Das ist etwas was bei ``for``-Schleifen implizit passiert. Nach dem ``in`` einer ``for``-Schleife muss immer ein Ausdruck stehen, der ein "iterable" liefert. Das Konzept ist also ziemlich zentral in Python.

Die Fehlermeldung bekommst Du weil -- wie die Fehlermeldung selbst ja schon sagt -- keine Funktion mit dem Namen `zeichne_feld()` gefunden werden kann. Die existiert nur während die `main()` abgearbeitet wird und der Name ist auch nur innerhalb der `main()`-Funktion verfügbar, wie das bei lokalen Namen so ist.

Statt der `zeichne_feld()`-Funktion, die auf Modulebene bleiben sollte, sind die Zuweisungen nach der `main()` noch zu "öffentlich". Sind ja keine Konstanten.

Edit: Das was Du meinst heist auch nur "space", Dir geht es ja explizit um *das* Leerzeichen und nicht um alle druckbaren Zeichen die Leerraum erzeugen.

[Chimera]

@BlackJack: Vielen dank fuer die schnelle Antwrot.
Ich sitze jetzt an einem Einheimischen Computer, daher nicht wurndern dass es keine Umlaute mer gibt.
Man man das ist ja alles garnicht so einfach wie ich mir das vorgestellt habe. Da muss ich mich heute Abend gleich noch einmal hineinarbeiten.

@all: Haettet ihr das auffuellen und auslesen der Liste anderst gemacht?
Vielen dank fuer eure Hilfe, ich bin nun schon viel weiter gekommen und der neue Aufbau des Prgrammes ist schon viel einfacher zu veraendern und zu bearbeiten.

Gruss Alexander

[BlackJack]

@Chimera: Die der Name `feld_groesse` ist IMHO unpassend. Das Objekt repräsentiert ja tatsächlich das Feld mit Inhalt und nicht nur seine Grösse. `feld_druck` finde ich auch nicht so toll. `druckbares_feld` wäre deutlicher.

Die Indexzugriffe auf die Argumente der Funktion, bzw. im Moment ja nur `feld_dimensionen`, würde ich wie gesagt durch Zuweisung an konkrete Namen ersetzen. ``feld_groesse[feld_hoehe - 1]`` ist leichter verständlich als ``feld_groesse[feld_dimensionen[1] - 1]`` wo erst überlegt werden muss, was die 1 als Index wohl bedeutet. Für diesen konkreten Fall mag das noch durch ein wenig nachdenken und der Konvention das bei Dimensionsangaben Breite vor Höhe kommt, deutlich werden. Aber der Zusammenhang zwischen dem Index 2 und der Bedeutung "Schlittenhöhe", wäre sicher nicht so einfach, ohne dass man in der Dokumentation nachschauen muss.

Das erstellen von `feld_druck` enthält mehrere unschöne Sachen. Unnötige Indexzugriffe -- man kann über Listenelemente direkt iterieren ohne den Umweg über einen Index zu nehmen. Dann sind die Elemente in den inneren Listen schon Zeichenketten, also ist der `str()`-Aufruf überflüssig. Und zuguterletzt ist das aufbauen von Zeichenketten durch wiederholte "Addition" ineffizient weil bei jedem Zeichen immer das ganze bisherige Ergebnis in eine neue Zeichenkette kopiert wird. Es gibt Situationen wo die Laufzeitumgebung das vermeiden kann, aber darauf sollte man sich nicht verlassen. Der idiomatische Weg ist deshalb, die Einzelteile in einer Liste zu sammeln, oder allgemein als "iterable" zur Verfügung zu stellen, und dann mit der `.join()`-Methode auf Zeichenketten zusammenzusetzen. Damit schrumpft alles ab ``feld_druck = ""`` auf eine Zeile zusammen. Ungetestet:

Code: Alles auswählen

def zeichne_feld(feld_dimensionen, schlitten, ball):
    feld_breite, feld_hoehe = feld_dimensionen
    ball_x, ball_y = ball
    
    feld = [[" "] * feld_breite for _ in xrange(feld_hoehe)]
    # 
    # Wände oben und unten.
    # 
    for i in [0, -1]:
        feld[i] = ['#'] * feld_breite

    feld[ball_y][ball_x] = '*'
    
    return '\n'.join(''.join(zeile) for zeile in feld)