zwei Konsolen! Geht das?

[Hyperion]

Zumal ein Windows-System immer eine DE dabei hat - oder sollte ich da ein reines Konsolen-Windows nicht kennen?

Also es gibt Windows 2008 Server Core, das hat keine DE dabei, ist aber auch nicht Konsolenbasiert.

Was nutzt es dann als Userinterface?

[Leonidas]

Zumal ein Windows-System immer eine DE dabei hat - oder sollte ich da ein reines Konsolen-Windows nicht kennen?

Also es gibt Windows 2008 Server Core, das hat keine DE dabei, ist aber auch nicht Konsolenbasiert.

Was nutzt es dann als Userinterface?

Sowas

[LP640]

hallo
also ich hab mal versucht mit dem qt designer mein menü zu gestalten, allerdings basiert mein programm auf xturtle und ich möchte nun gerne wissen, ob es irgendwie möglich ist, dieses modul innerhalb der grafischen oberfläche von qt darzustellen?

mfg
LP640

[BlackJack]

@LP640: Selbst wenn das ginge wäre das ziemlich ungewöhnlich ein GUI-Toolkit innerhalb eines anderen zu verwenden. Bei `xturtle` würde es sich ja wohl eher anbieten ein Menü in `Tkinter` zu verwenden.

[LP640]

ok danke für die antwort BlackJack
aber wie kann ich tkinter und xturtle in dem selben fenster anzeigen lassen?

mfg
LP640

[mkesper]

Wenn's die Konsole bleiben soll, würde ich auf `urwid` setzen.

Siehe oben...

[LP640]

so hab mir dieses urwid runtergeladen und entpackt aber hab keine ahnung, wie man das installiert
so wie das im internet beschrieben ist hats bei mir nicht geklappt

kann mir jemand erklären wie ich urwid installiere?

mfg
LP640

[LP640]

hallo

ich glaube, ich hab eine andere lösung für mein programm gefunden:
und zwar klappt das ganze auch mit "easygui" , zwar nicht genauso, wie ich mir das vorgestellt habe, aber trotzdem besser als nix.
aber ich hab noch ein problem:
erstmal ein vereinfachter code aus meinem programm:

Code: Alles auswählen

from xturtle import*
x=-3
while x<=3:
    y=x**2+1
    print "x=",x,"y=",y
    goto(x*50,y*50)
    x=x+0.02

so ich hätte aber nun gerne, dass die die x und y werte aber nicht geprinted werden, während der graph gezeichnet wird, sondern erst später auf abruf des benutzers. Dazu muss ich aber die x und y werte irgendwie absichern oder abspeichern (vielleicht in einer liste oder sowas).
kann mir da jemand weiterhelfen???

mfg
LP640

[Dav1d]

so ich hätte aber nun gerne, dass die die x und y werte aber nicht geprinted werden, während der graph gezeichnet wird, sondern erst später auf abruf des benutzers. Dazu muss ich aber die x und y werte irgendwie absichern oder abspeichern (vielleicht in einer liste oder sowas).
kann mir da jemand weiterhelfen???

du hast dir die Frage doch schon selbst beantwortet

[LP640]

du hast Recht Dav1d das mit den Listen müsste gehen, allerdings komm ich nicht viel weiter
mein aktueller code:

Code: Alles auswählen

from xturtle import*
listex=[]
listey=[]
x=-3
while x<=3:
    y=x**2+1
    listex.append(x)
    listey.append(y)
    print "x=",x,"y=",y
    goto(x*50,y*50)
    x=x+0.1

print"Tabelle x/ y"
###???

so und zwar weis ich nicht, wie man die liste wieder zurückwandeln kann.
dort wo jetzt ###??? steht soll dann eigentlich die liste in Tabellenform (wie vorher mit print) erscheinen
kann mir da jemand helfen?

mfg
LP640

[Dav1d]

Code: Alles auswählen

from xturtle import*
x_werte=[]
y_werte=[]
x=-3
while x<=3:
    y=x**2+1
    x_werte.append(x)
    y_werte.append(y)
    goto(x*50,y*50)
    x=x+0.1

for i, x in enumerate(x_werte)):
    print"x: %s, y: %s" % (x, y_werte[i])

[ms4py]

Das sieht nicht sehr elegant aus...

So wäre es schon besser:

Code: Alles auswählen

from itertools import izip
...
for x,y in izip(x_werte, y_werte):
    print"x: %s, y: %s" % (x, y)

Oder gleich in eine Liste packen ist eigentlich noch geschickter.
Mit numpy.arange sieht das dann auch ein bisschen mehr nach Python aus.

Code: Alles auswählen

from xturtle import*
from numpy import arange
werte = []
for x in arange(-3, 3, 0.1):
    y = x**2+1
    werte.append((x, y))
    goto(x*50, y*50)

for x, y in werte:
    print "x: %s, y: %s" % (x, y)

Edit: Außerdem sollte man nie * importieren, sondern immer nur die Module, die du auch benötigst.
Und ja ich weiß, mit numpy könnte man das noch viel eleganter lösen

[Dav1d]

Das sieht nicht sehr elegant aus...

Da hast du wohl recht.

Das mit den Tupeln hab ich gesucht, is mir aber einfach nicht eingefallen

[ms4py]

Oder so (ohne numpy):

Code: Alles auswählen

def arange2(start, stop, interval):
    i = start
    while i <= stop:
        yield i
        i += interval

werte = [(x, x**2+1) for x in arange2(-3, 3, 0.1)]

[LP640]

vielen dank Dav1d und ice2k3
eure lösung funktioniert (habe sie etwas "unelegant" verändert)
allerdings möchte ich die tabelle nicht in dieser konsole, sondern mithilfe von easygui (ich hoffe, ihr kennt das) erstellen
das sieht dann etwa so aus:

Code: Alles auswählen

from xturtle import*
import easygui as g
x_werte=[] 
y_werte=[] 
x=-3 
while x<=3: 
    y=x**2+1 
    x_werte.append(x) 
    y_werte.append(y) 
    goto(x*50,y*50) 
    x=x+0.1 


###for i,x in enumerate(x_werte): 
###    print"x:"+str(x)+" y:"+str(y_werte[i])

text=g.codebox("aaaaaaaa","bbbbbbbbb",
"""x hat den wert: """+"###"+"""
x= y=
.............
.............""")

das was nach den ### kommt soll sozusagen irgendwie in diese codebox gepackt werden
weis einer wie das gehen könnte???

mfg
LP640

[ms4py]

Zu was mach ich mir eigentlich die Mühe, dir bessere Lösungen vorzuschlagen, wenn du diese eh ignorierst...

Mit meiner Lösung kannst du den Text so erstellen.

Code: Alles auswählen

text = '\n'.join('x: %s, y: %s' % (x,y) for x, y in werte)

[numerix]

allerdings möchte ich die tabelle nicht in dieser konsole, sondern mithilfe von easygui (ich hoffe, ihr kennt das) erstellen

Ich "kenne" EasyGui und es ist ekelig und überflüssig.
Stattdessen kannst du z.B.
- mittels xturtle direkt auf die Zeichenfläche schreiben und dir so eine Tabelle konstruieren
- oder statt xturtle das frog-Modul einsetzen (such mal im Forum danach) und dann die Zeichenfläche entweder in eine Tkinter-GUI einbinden und dort z.B. ein Text-Widget für die Ausgabe der Wertetabelle verwenden
- oder das frog-Modul einsetzen und dort direkt in die Zeichenfläche schreiben. Das geht damit eigentlich ganz gut. Ansatz dazu (zum selber weiterentwickeln) im Code unten:

Code: Alles auswählen

from frog import Pool, Frog

blatt = Pool(width=600, height=1000)
stift = Frog(blatt, visible=False)
# Punkte berechnen
punkte = [(.1*x,(.1*x)**2+1) for x in xrange(-30,30)]
# Parabel Zeichnen
faktor = 50
x0, y0 = punkte.pop(0)
stift.pos = faktor*x0, faktor*y0
for x,y in punkte:
    stift.moveto(faktor*x, faktor*y)
# Wertetabelle anzeigen
stift.pos = -50,0
zeilenhoehe = stift.textsize("1")[1]+5 # px
for punkt in punkte:
    stift.y -= zeilenhoehe
    stift.write("%.2f | %.2f" %punkt)
blatt.ready()

Zum frog-Modul gibt es eine ausführliche dt. Doku.

[LP640]

naja also so wie ich das dann verändert habe verstehe ich selber am besten, das ergebnis ist ja das gleiche und für das, was ich damit bewirken will reicht es jedenfalls
trotzdem danke für deine verbesserungvorschläge
aber weis den jetzt jemand wie das mit easygui geht???

oh schon wieder ne neue antwort da:
das mit frog ist ja eigentlcih das selbe wie mit xturtle (frog kenn ich seit neuem auch schon)
das problem ist ja, dass die gesamte tabelle nicht sichtbar ist, da man nicht runterscrollen kann.

also am liebsten wäre mir wirklich das mit easygui wie beschrieben
hat jemand ne idee?

mfg
LP640

[LP640]

oh ice2k3 tut mir echt leid ich hab irgendwie deine Lösung mit dem code übersehen
vielen dank klappt prima

mfg
LP640

[numerix]

das mit frog ist ja eigentlcih das selbe wie mit xturtle (frog kenn ich seit neuem auch schon)

Nicht dasselbe, aber vergleichbar. Ich mag den Frosch lieber als die Kröte, aber das ist sicher Geschmackssache und hat auch damit zu tun, was genau man machen möchte.

Richtig ist: Die Zeichenfläche des frog-Moduls ist nicht scrollbar, die von xturtle (= turtle für Python > 2.5) IMHO schon. Einer meiner Vorschläge war deshalb auch Tkinter-GUI mit Text-Widget für die Wertetabelle (oder auch Listbox), die sich scrollen lassen und eine eingebettete Zeichenfläche, z.B. als frog-Zeichenfläche oder auch ein reines Tkinter-Canvas. Da sind die Zeichenbefehle zwar nicht ganz so eingängig wie bei xturtle/frog, aber wenn es nur um das Zeichnen eines Graphen geht, ist da ja auch nicht viel zu machen.